精华内容
下载资源
问答
  • 时间管理优先矩阵

    2012-06-15 14:08:01
    时间管理优先矩阵 管理自己时间的利器 !
  • 时间管理的心理建设与优先矩阵.doc
  • 时间管理的心理建设与优先矩阵讲义全.doc
  • 编译原理算符优先矩阵的构造

    千次阅读 2018-07-12 12:20:03
    算符优先法中算符优先矩阵的构造需要求出firstTerm以及lastTerm,由于这个是在预测分析法上进行修改的,结构体的定义并未进行修改,其中包含该非终结符a以及其对应的first(即为firstTerm)和follow(即为lastTerm)...

    算符优先法中算符优先矩阵的构造需要求出firstTerm以及lastTerm,由于这个是在预测分析法上进行修改的,结构体的定义并未进行修改,其中包含该非终结符a以及其对应的first(即为firstTerm)和follow(即为lastTerm),输入格式如下(以#结束输入)
    Z::=E
    E::=T|E+T
    T::=F|T*F
    F::=(E)|i
    #

    #include<bits/stdc++.h>
    using namespace std;
    //判断终结符和非终结符 返回1是非终结符 返回0是终结符 
    int Norterminal(char c)
    {
        if(c>='A'&&c<='Z') 
            return 1;
        else if(c!=':'&&c!='='&&c!='<'&&c!='>'&&c!=' '&&c!='|') 
            return 0; 
    
    }  
    struct GRAM
    {
        //$代表空 
        string  a;
        string first;
        string follow;
    };
    struct LIST
    {
        int num;
        string s;
    };
    int main()
    {
        GRAM gram[50]; 
        string grammer; 
        cout<<"请输入文法(以#结束)"<<endl;
        std::vector<string> strN;
        cin>>grammer;//输入规则 
        strN.push_back(grammer); 
        char str[10][80];  
        const char *ch = "|";  
        char *result;  
        vector<string> strN1;  //存处理过“|”规则的 
    
        for(int i=0;i<grammer.length();i++)
        {
            str[0][i]=grammer[i];
        } 
        for(int h=grammer.length();h<80;h++)
        {
                str[0][h]=NULL;
        }
        result = strtok(str[0],ch);  
        while(result!=NULL)  
        {  
            strN1.push_back(result);  
            result = strtok(NULL,ch);  
        }  
        for(int i=1;grammer!="#";i++)
        {
            cin>>grammer;
            strN.push_back(grammer); 
            /*处理转换的规则形式输入部分*/
            for(int h=0;h<grammer.length();h++)
            {
                str[i][h]=grammer[h];
            } 
            for(int h=grammer.length();h<80;h++)
            {
                str[i][h]=NULL;
            }
            result = strtok(str[i],ch);  
            while(result!=NULL)  
            {  
                strN1.push_back(result);  
                result = strtok(NULL,ch);  
            }  
        } 
        /*
        获取firstTerm集合 
        */
        //直接获取firstTerm
        for(unsigned i=0;i<strN.size();i++)
        {
            gram[i].a=strN[i][0];
            gram[i].first="";
            if(!Norterminal(strN[i][4]))
            {
                gram[i].first=strN[i][4];
            }
            else
            {
                if(!Norterminal(strN[i][5]))
                {
                    gram[i].first=strN[i][5];
                }
            }
            for(unsigned k=5;k<strN[i].length();k++)
            {
                if(strN[i][k]=='|')
                {
    
                    if(!Norterminal(strN[i][k+1]))
                    {
    
                        gram[i].first+=strN[i][k+1];
                    }
                    else
                    {
                        if(!Norterminal(strN[i][k+2]))
                        {
                            gram[i].first+=strN[i][k+2];
                        }
                    }
                }
            } 
    
        } 
        int num=strN1.size();
        //当第一个字符是非终结符时 
        for(int i=num-1;i>=0;i--)
        {
            for(unsigned l=0;l<strN.size()-1;l++)
            {
                if(gram[l].a[0]==strN1[i][0])
                {
                        for(unsigned h=0;h<strN.size()-1;h++)
                        {
                            if(strN1[i][4]==gram[h].a[0]&&strN1[i][4]!=strN1[i][0])
                            {
    
                                gram[l].first+=gram[h].first; 
                                string ustr(gram[l].first);
                                sort(ustr.begin(), ustr.end());
                                ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                                gram[l].first=ustr; 
                                break;
                            }       
                        }
                }
            }        
    
        }
        cout<<"firstTerm集合为:"<<endl;
        for(unsigned i=0;i<strN.size()-1;i++)
        {
            for(int k=0;k<gram[i].first.length();k++)
            {
                if(gram[i].first[k]==NULL)
                {
                    gram[i].first.erase(gram[i].first.begin()+k);
                }
            }
            cout<<gram[i].a<<" "<<gram[i].first<<endl;
        }
        string term="";
        cout<<"终结符为:"<<endl;
        for(unsigned i=0;i<strN.size()-1;i++)
        {
            for(int j=0;j<strN[i].length();j++)
            {
                if(!Norterminal(strN[i][j])&&strN[i][j]!='$')
                   term+=strN[i][j];
            }
            string ustr(term);
            sort(ustr.begin(), ustr.end());
            ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
            term=ustr;
        }
        cout<<term<<endl;
        /*转换规则形式*/
        cout<<"转换后的规则形式为:"<<endl; 
        int listnumber =0; 
        for(unsigned i=0;i<strN1.size()-1&&i-1>=0;i++)
        {
    
            if(strN1[i].find("::")==-1)
            {
                string add="";
                add=add+strN1[i-1][0]+"::="+strN1[i];
                strN1[i]=add;
    
            }   
            cout<<strN1[i]<<endl;
        }
        /*获取lastTerm*/
        //直接获取lastTerm
        for(int i=0;i<num-1;i++)
        {
            for(unsigned l=0;l<strN.size()-1;l++)
            {
                    if(gram[l].a[0]==strN1[i][0])
                    {
                            for(unsigned h=0;h<strN.size()-1;h++)
                            {
                                int k=strN1[i].length();
                                if(!Norterminal(strN1[i][k-1]))
                                {
    
                                    gram[l].follow+=strN1[i][k-1]; 
                                    string ustr(gram[l].follow);
                                    sort(ustr.begin(), ustr.end());
                                    ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                                    gram[l].follow=ustr;    
                                    break;
                                }
                                else
                                {
                                    if(!Norterminal(strN1[i][k-2]))
                                    {
                                        gram[l].follow+=strN1[i][k-2]; 
                                        string ustr(gram[l].follow);
                                        sort(ustr.begin(), ustr.end());
                                        ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                                        gram[l].follow=ustr;    
                                        break;
                                    }
                                }       
                            }
                    }
            }        
       }
       for(int i=num-1;i>=0;i--)
       {
            for(unsigned l=0;l<strN.size()-1;l++)
            {
                if(gram[l].a[0]==strN1[i][0])
                {
                        for(unsigned h=0;h<strN.size()-1;h++)
                        {
                                int k=strN1[i].length();
                                if(Norterminal(strN1[i][k-1]))
                                {
    
                                     for(unsigned h1=0;h1<strN.size()-1;h1++)
                                     if(gram[h1].a[0]==strN1[i][k-1])
                                     {
                                            gram[l].follow+=gram[h1].follow; 
                                            string ustr(gram[l].follow);
                                            sort(ustr.begin(), ustr.end());
                                            ustr.erase(unique(ustr.begin(), ustr.end()), ustr.end() );
                                            gram[l].follow=ustr;    
                                            break;
                                     }
    
                                }
                        }   
                }
            }        
    
        }
        cout<<"lastTerm集合为:"<<endl; 
        for(unsigned i=0;i<strN.size()-1;i++)
        {
            cout<<gram[i].a<<" "<<gram[i].follow<<endl;
        } 
        int list[term.length()][term.length()]; 
        for(int i=0;i<term.length();i++)
        {
            for(int j=0;j<term.length();j++)
            {
                list[i][j]=0;
            }
        }
        cout<<"相等的关系为:"<<endl; 
       for(int i=num-1;i>=0;i--)
       {
            for(int k=0;k<strN1[i].length()&&k+1<strN1[i].length();k++)
            {
                if(Norterminal(strN1[i][k]))
                {
                    if(!Norterminal(strN1[i][k-1])&&!Norterminal(strN1[i][k+1]))
                    {
                        cout<<strN1[i][k-1]<<strN1[i][k+1]<<endl;;
                        for(int h=0;h<term.length();h++)
                        {
                            if(strN1[i][k-1]==term[h])
                            for(int g=0;g<term.length();g++)
                            {
                                if(strN1[i][k+1]==term[g])
                                {
                                    list[h][g]=1;
                                }
                            }
                        }
                    }
                }
                else
                {
                    if(!Norterminal(strN1[i][k+1]))
                    {
                        cout<<strN1[i][k]<<strN1[i][k+1]<<endl;
                        for(int h=0;h<term.length();h++)
                        {
                            if(strN1[i][k]==term[h])
                            for(int g=0;g<term.length();g++)
                            {
                                if(strN1[i][k+1]==term[g])
                                {
                                    list[h][g]=1;
                                }
                            }
                        }
                    }
                }
            }   
       } 
       //cout<<"小于关系为:"<<endl;
       for(int i=0;i<num-1;i++)
       {
            for(int k=0;k<strN1[i].length();k++)
            {
                if(!Norterminal(strN1[i][k]))
                {
                    if(Norterminal(strN1[i][k+1]))
                    {
                        for(int h=0;h<term.length();h++)
                        {
                            if(strN1[i][k]==term[h])
                            {
                                for(int j=0;j<num-1;j++)
                                {
                                    if(strN1[i][k+1]==gram[j].a[0])
                                    {
                                        for(int g=0;g<term.length();g++)
                                        {
                                            for(int f=0;f<gram[j].first.length();f++)
                                            if(gram[j].first[f]==term[g])
                                            {
                                                list[h][g]=2;
                                            }
                                        }
                                    }
                                }
                            }
                        }
    
                    }
                }
            }
    
    
       } 
       //大于关系    
       for(int i=0;i<num-1;i++)
       {
            for(int k=0;k<strN1[i].length();k++)
            {
                if(Norterminal(strN1[i][k]))
                {
                    if(!Norterminal(strN1[i][k+1]))
                    {
                        for(int h=0;h<term.length();h++)
                        {
                            if(strN1[i][k+1]==term[h])
                                for(int j=0;j<num-1;j++)
                                {
                                    if(strN1[i][k]==gram[j].a[0])
                                    {
                                        for(int g=0;g<term.length();g++)
                                        {
                                            for(int f=0;f<gram[j].first.length();f++)
                                            if(gram[j].follow[f]==term[g])
                                            {
                                                list[g][h]=3;
                                            }
                                        }
                                    }
                                }
                        }
    
                    }
                }
            }
       } 
       for(int i=0;i<term.length();i++)
        {
            for(int j=0;j<term.length();j++)
            {
                cout<<list[i][j]<<" ";
            }
            cout<<endl;
        }
    
        cout<<"算符优先矩阵为:"<<endl;
        cout<<"    |";
        for(int i=0;i<term.length();i++)
        {
            cout<<setw(10)<<term[i];
            cout<<"|";
        }
        cout<<endl; 
        cout<<"____________________________________________________________________________"<<endl;
    
        for(int i=0;i<term.length();i++)
        {
            printf("%2c",term[i]);
            cout<<"  "<<"|";
            for(int j=0;j<term.length();j++)
            {
                if(list[i][j]==0)
                cout<<setw(10)<<" "<<"|";
                if(list[i][j]==1)
                cout<<setw(10)<<"="<<"|";
                if(list[i][j]==2)
                cout<<setw(10)<<"<"<<"|";
                if(list[i][j]==3)
                cout<<setw(10)<<">"<<"|";
    
            }
            cout<<endl;
            cout<<"____________________________________________________________________________"<<endl;
    
        }
    
    } 

    运行结果如下:
    这里写图片描述

    展开全文
  • cublas库是CUDA标准的线代库,但没有专门针对稀疏矩阵的操作。 其中cublasSgemm实现C=α*A*B+β*C功能 函数原型为 /* GEMM */ CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemm_v2 (cublasHandle

    引用:http://www.cnblogs.com/scut-fm/p/3756242.html
    cublas库是CUDA标准的线代库,但没有专门针对稀疏矩阵的操作。
    其中cublasSgemm实现C=α*A*B+β*C功能
    函数原型为
    /* GEMM */
    CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemm_v2 (cublasHandle_t handle, 
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb, 
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const float *alpha, /* host or device pointer */  
                                                          const float *A, 
                                                          int lda,
                                                          const float *B,
                                                          int ldb, 
                                                          const float *beta, /* host or device pointer */  
                                                          float *C,
                                                          int ldc);
    函数中handle为blas库对象
    transa 为矩阵A属性参数
    transb 为矩阵B属性参数
    M A,C行数,即C的高
    N B,C列数,即C的宽
    K A的列数和B的行数
    alpha 运算式的α的地址
    A A在显存中的地址
    lda A的主维度,所表达的矩阵的高
    B B在显存中的地址
    ldb B的主维度,所表达的矩阵的高
    beta 运算式的β的地址
    C C在显存中的地址
    ldc C的主维度,所表达的矩阵的高

    若列优先计算矩阵乘法
    |1 0| * |2 0 3| = |2 0 3|
            |1 1 0|
    A     * B       = C
    则*alpha=1.0,*β=0.0
    列存储形式:
    A={1,0}表示矩阵,矩阵宽2,高1
    1 0
    B={2,1,0,1,3,0},矩阵宽3,高2
    2 0 3
    1 1 0
    C={2,0,3},矩阵宽3,高1
    2 0 3
    ABC均按列存储,所以AB属性设置为CUBLAS_OP_N,得到的C矩阵也是按列存储
    MNK分别为1,3,2
    lda,ldb,ldc分别为三个矩阵的高,即1,2,1
    全部代码如下
    // CUDA runtime 库 + CUBLAS 库
    #include "cuda_runtime.h"
    #include "cuda_runtime_api.h"
    #include "cublas_v2.h"
    
    #include <time.h>
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "MyTimer.h"
    //本代码实现了cublas的列存储矩阵乘法
    //#include <common_functions.h>
    /*
    |1 0| * |2 0 3| = |2 0 3|
            |1 1 0|
    A     * B       = C
    cublasSgemm 实现的功能为C = alpha*A*B + beta*C
    ABC均为列存储
    */
    using namespace std;
    
    // 定义测试矩阵的维度
    int const aW = 2;
    int const aH = 1;
    int const bW = 3;
    int const bH = 2;
    int const cW = bW;
    int const cH = aH;
    
    int main()
    {
        // 定义状态变量
        cublasStatus_t status;
    
        // 在 内存 中为将要计算的矩阵开辟空间
        float *h_A = (float*)malloc (aW*aH*sizeof(float));
        float *h_B = (float*)malloc (bW*bH*sizeof(float));
    
        // 在 内存 中为将要存放运算结果的矩阵开辟空间
        float *h_C = (float*)malloc (cW*cH*sizeof(float));
    
        // 为待运算矩阵的元素赋值
        h_A[0]=1; h_A[1]=0;
        h_B[0]=2; h_B[1]=1; h_B[2]=0; h_B[3]=1; h_B[4]=3; h_B[5]=0;
    
        // 打印待测试的矩阵
        cout << "矩阵 A :" << endl;
        for (int i=0; i<aW*aH; i++){
            cout << h_A[i] << " ";
            if ((i+1)%aW == 0) cout << endl;
        }
        cout << endl;
        cout << "矩阵 B :" << endl;//按照行优先打印的,不正确
        for (int i=0; i<bW*bH; i++){
            cout << h_B[i] << " ";
            if ((i+1)%bW == 0) cout << endl;
        }
        cout << endl;
    
        /*
        ** GPU 计算矩阵相乘
        */
    
        // 创建并初始化 CUBLAS 库对象
        cublasHandle_t handle;
        status = cublasCreate(&handle);
    
        if (status != CUBLAS_STATUS_SUCCESS)
        {
            if (status == CUBLAS_STATUS_NOT_INITIALIZED) {
                cout << "CUBLAS 对象实例化出错" << endl;
            }
            getchar ();
            return EXIT_FAILURE;
        }
    
        float *d_A, *d_B, *d_C;
        // 在 显存 中为将要计算的矩阵开辟空间
        cudaMalloc (
            (void**)&d_A,    // 指向开辟的空间的指针
            aW*aH * sizeof(float)    // 需要开辟空间的字节数
        );
        cudaMalloc (
            (void**)&d_B,
            bW*bH * sizeof(float)
        );
    
        // 在 显存 中为将要存放运算结果的矩阵开辟空间
        cudaMalloc (
            (void**)&d_C,
            cW*cH * sizeof(float)
        );
    
        // 将矩阵数据传递进 显存 中已经开辟好了的空间
        cublasSetVector (
            aW*aH,    // 要存入显存的元素个数
            sizeof(float),    // 每个元素大小
            h_A,    // 主机端起始地址
            1,    // 连续元素之间的存储间隔
            d_A,    // GPU 端起始地址
            1    // 连续元素之间的存储间隔
        );
        cublasSetVector (
            bW*bH,
            sizeof(float),
            h_B,
            1,
            d_B,
            1
        );
    
        // 同步函数
        cudaThreadSynchronize();
    
        Timer myTimer;
        myTimer.start();
        // 传递进矩阵相乘函数中的参数,具体含义请参考函数手册。
        float a=1; float b=0;
        // 矩阵相乘。该函数必然将数组解析成列优先数组
        cublasSgemm (
            handle,    // blas 库对象
            CUBLAS_OP_N,    // 矩阵 A 属性参数
            CUBLAS_OP_N,    // 矩阵 B 属性参数
            cH,    // A, C 的行数
            cW,    // B, C 的列数
            aW,    // A 的列数和 B 的行数
            &a,    // 运算式的 α 值
            d_A,    // A 在显存中的地址
            aH,    // lda
            d_B,    // B 在显存中的地址
            bH,    // ldb
            &b,    // 运算式的 β 值
            d_C,    // C 在显存中的地址(结果矩阵)
            cH    // ldc
        );
        // 同步函数
        cudaThreadSynchronize();
        myTimer.stop();
        printf("use: %lf\n", myTimer.getElapsedTime());
    
        // 从 显存 中取出运算结果至 内存中去
        cublasGetVector (
            cW*cH,    //  要取出元素的个数
            sizeof(float),    // 每个元素大小
            d_C,    // GPU 端起始地址
            1,    // 连续元素之间的存储间隔
            h_C,    // 主机端起始地址
            1    // 连续元素之间的存储间隔
        );
    
        // 打印运算结果
        cout << "计算结果的转置 ( (A*B)的转置 ):" << endl;
    
        for (int i=0;i<cW*cH; i++){
                cout << h_C[i] << " ";
                if ((i+1)%cW == 0) cout << endl;
        }
    
        // 清理掉使用过的内存
        free (h_A);
        free (h_B);
        free (h_C);
        cudaFree (d_A);
        cudaFree (d_B);
        cudaFree (d_C);
    
        // 释放 CUBLAS 库对象
        cublasDestroy (handle);
    
        getchar();
    
        return 0;
    }
    
    C语言中行优先是更加习惯的使用,因此,在介绍下使用cublas实现行优先矩阵乘法的方法
    C=A*B则C'=B'*A'
    行存储形式:
    A={1,0}表示矩阵,矩阵宽2,高1
    1 0
    B={2,0,3,1,1,0},矩阵宽3,高2
    2 0 3
    1 1 0
    C={2,0,3},矩阵宽3,高1
    2 0 3
    ABC均按行存储
    我们设置AB属性为CUBLAS_OP_N,cublas将AB按照列优先解析,并将A按宽1高2,B按宽2高3,C按宽1高3的方式设置。
    则cublas认为B是
    2 1
    0 1
    3 0
    即B的转置,AC同理
    那么计算C=A*B时,我们按照上面设置将参数传入cublasSgemm函数,得到的即为C'=B'*A'即实现了行优先存储乘法(行优先和列优先在计算时,输入输出矩阵数据分别按照行优先和列优先给出,赋值时宽高不必做转换,该是什么就是什么,但
    cublasSgemm函数中的宽高需要改成其转置,A和B也要互换,具体看代码)
    行优先存储全部代码如下
    /*
     * cublasLearn.cpp
     *
     *  Created on: 2017年4月6日
     *      Author: wjt
     */
    
    // CUDA runtime 库 + CUBLAS 库
    #include "cuda_runtime.h"
    #include "cuda_runtime_api.h"
    #include "cublas_v2.h"
    
    #include <time.h>
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "MyTimer.h"
    //本代码实现了cublas的行存储矩阵乘法
    //#include <common_functions.h>
    /*
    |1 0| * |2 0 3| = |2 0 3|
            |1 1 0|
    A     * B       = C
    cublasSgemm 实现的功能为C = alpha*A*B + beta*C
    ABC均为列存储
    */
    using namespace std;
    
    // 定义测试矩阵的维度
    int const aW = 2;
    int const aH = 1;
    int const bW = 3;
    int const bH = 2;
    int const cW = bW;
    int const cH = aH;
    
    int main()
    {
        // 定义状态变量
        cublasStatus_t status;
    
        // 在 内存 中为将要计算的矩阵开辟空间
        float *h_A = (float*)malloc (aW*aH*sizeof(float));
        float *h_B = (float*)malloc (bW*bH*sizeof(float));
    
        // 在 内存 中为将要存放运算结果的矩阵开辟空间
        float *h_C = (float*)malloc (cW*cH*sizeof(float));
    
        // 为待运算矩阵的元素赋值
        h_A[0]=1; h_A[1]=0;
        h_B[0]=2; h_B[1]=0; h_B[2]=3; h_B[3]=1; h_B[4]=1; h_B[5]=0;
    
        // 打印待测试的矩阵
        cout << "矩阵 A :" << endl;
        for (int i=0; i<aW*aH; i++){
            cout << h_A[i] << " ";
            if ((i+1)%aW == 0) cout << endl;
        }
        cout << endl;
        cout << "矩阵 B :" << endl;
        for (int i=0; i<bW*bH; i++){
            cout << h_B[i] << " ";
            if ((i+1)%bW == 0) cout << endl;
        }
        cout << endl;
    
        /*
        ** GPU 计算矩阵相乘
        */
    
        // 创建并初始化 CUBLAS 库对象
        cublasHandle_t handle;
        status = cublasCreate(&handle);
    
        if (status != CUBLAS_STATUS_SUCCESS)
        {
            if (status == CUBLAS_STATUS_NOT_INITIALIZED) {
                cout << "CUBLAS 对象实例化出错" << endl;
            }
            getchar ();
            return EXIT_FAILURE;
        }
    
        float *d_A, *d_B, *d_C;
        // 在 显存 中为将要计算的矩阵开辟空间
        cudaMalloc (
            (void**)&d_A,    // 指向开辟的空间的指针
            aW*aH * sizeof(float)    // 需要开辟空间的字节数
        );
        cudaMalloc (
            (void**)&d_B,
            bW*bH * sizeof(float)
        );
    
        // 在 显存 中为将要存放运算结果的矩阵开辟空间
        cudaMalloc (
            (void**)&d_C,
            cW*cH * sizeof(float)
        );
    
        // 将矩阵数据传递进 显存 中已经开辟好了的空间
        cublasSetVector (
            aW*aH,    // 要存入显存的元素个数
            sizeof(float),    // 每个元素大小
            h_A,    // 主机端起始地址
            1,    // 连续元素之间的存储间隔
            d_A,    // GPU 端起始地址
            1    // 连续元素之间的存储间隔
        );
        cublasSetVector (
            bW*bH,
            sizeof(float),
            h_B,
            1,
            d_B,
            1
        );
    
        // 同步函数
        cudaThreadSynchronize();
    
        Timer myTimer;
        myTimer.start();
        // 传递进矩阵相乘函数中的参数,具体含义请参考函数手册。
        float a=1; float b=0;
        // 矩阵相乘。该函数必然将数组解析成列优先数组
        cublasSgemm (
            handle,    // blas 库对象
            CUBLAS_OP_N,    // 矩阵 A 属性参数
            CUBLAS_OP_N,    // 矩阵 B 属性参数
            bW,    // A, C 的行数
            aH,    // B, C 的列数
            bH,    // A 的列数和 B 的行数
            &a,    // 运算式的 α 值
            d_B,    // A 在显存中的地址
            bW,    // lda
            d_A,    // B 在显存中的地址
            aW,    // ldb
            &b,    // 运算式的 β 值
            d_C,    // C 在显存中的地址(结果矩阵)
            cW    // ldc
        );
        // 同步函数
        cudaThreadSynchronize();
        myTimer.stop();
        printf("use: %lf\n", myTimer.getElapsedTime());
    
        // 从 显存 中取出运算结果至 内存中去
        cublasGetVector (
            cW*cH,    //  要取出元素的个数
            sizeof(float),    // 每个元素大小
            d_C,    // GPU 端起始地址
            1,    // 连续元素之间的存储间隔
            h_C,    // 主机端起始地址
            1    // 连续元素之间的存储间隔
        );
    
        // 打印运算结果
        cout << "计算结果的转置 ( (A*B)的转置 ):" << endl;
    
        for (int i=0;i<cW*cH; i++){
                cout << h_C[i] << " ";
                if ((i+1)%cW == 0) cout << endl;
        }
    
        // 清理掉使用过的内存
        free (h_A);
        free (h_B);
        free (h_C);
        cudaFree (d_A);
        cudaFree (d_B);
        cudaFree (d_C);
    
        // 释放 CUBLAS 库对象
        cublasDestroy (handle);
    
        getchar();
    
        return 0;
    }
    
    


    展开全文
  • 优先矩阵图也被认为是矩阵数据分析法,与矩阵图法类似,它能清楚地列出关键数据的格子,将大量数据排列成列阵,能够容易地看到和了解。与达到目的最优先考虑的选择或二者挑一的抉择有关系的数据,用一个简略的双轴的...
    优先矩阵图也被认为是矩阵数据分析法,与矩阵图法类似,它能清楚地列出关键数据的格子,将大量数据排列成列阵,能够容易地看到和了解。与达到目的最优先考虑的选择或二者挑一的抉择有关系的数据,用一个简略的双轴的相关关系图表示出来,相关关系的程度可以用符号或数值来代表。它区别于矩阵图法的是:不是在矩阵图上填符号,而是填数据,形成一个数据矩阵,它是一种定量分析问题 的方法,应用这种方法,往往要借助计算机来求解。
    绘制工具:Excel、Word

    例:


    展开全文
  • 我们知道matlab中的矩阵是列优先存储的,而c++中的数据是行优先存储的,而习惯了使用c++的伙伴们,也习惯了行优先存储方式了啦。所以在进行c++调用matlab引擎处理时,这会给两者矩阵数据传递会带来诸多的烦恼,这也...

    我们知道matlab中的矩阵是列优先存储的,而c++中的数据是行优先存储的,而习惯了使用c++的伙伴们,也习惯了行优先存储方式了啦(比如看一个二维数组,总会先看行序号,再看列序号)。所以在进行c++调用matlab引擎处理时,这会给两者矩阵数据传递会带来诸多的烦恼,这也是诸多程序bug的来源之一。关于c++调用matlab引擎编程,可参考我的另一篇文,网址为http://blog.csdn.net/feichizhongwu888/article/details/47277565。

    下面举一个例子,说明c++的数据存储顺序和matlab的存储数据方式。

    int main()
    {
        //c++ matrix:2*5=10 elements
        double a[10] = {0,1,2,3,4,5,6,7,8,9};
        Engine* ep;
        if(!(ep = engOpen(NULL)))
        {
            std::cout<<"can't start Matlab Engine!!"<<std::endl;
            return EXIT_FAILURE;
        }
        engSetVisible(ep, true);
        //generating matlab matrix::aa
        mxArray *aa = mxCreateDoubleMatrix(2, 5, mxREAL);
        memcpy(mxGetPr
    展开全文
  • 关于图的深度优先遍历邻接矩阵的方法,欢迎使用
  • 邻接表 邻接矩阵 广度优先搜索 深度优先搜索
  • 本篇介绍Eigen中矩阵及二维数组的系数存储顺序--行优先及列优先,已经如何指定优先顺序。 行优先(row-majoe)、 列优先(column-majoe) 矩阵的系数条目组成了一个二维的结构,在内存内存储矩阵时,必须以某种结构来...
  • 给定1个1000行×20列的0-1矩阵,对于该矩阵的任意1列,其中值为1的元素的数量不超过10%。设有两个非空集合A和B,每个集合由矩阵的若干列组成。集合A和B互斥是指对于矩阵的任意一行,同时满足下列2个条件:1)若A中有...
  • 矩阵优先与列优先

    2017-10-17 09:07:36
    C、C++、CUDA C 行优先; FORTRAN、MATLAB列优先
  • 广度优先搜索-邻接矩阵.cpp
  • Eclipse java工程: 图的深度优先遍历、广度优先遍历 demo:http://download.csdn.net/detail/keen_zuxwang/9875848 import java.util.ArrayList; import java.util.LinkedList; /** * @description 邻接矩阵...
  • matlab中的矩阵是行优先还是列优先

    千次阅读 2018-11-15 03:27:49
    matlab中的矩阵是行优先还是列优先
  • 矩阵中 “行优先“ 和 “列“ 优先

    千次阅读 2020-01-29 21:26:17
    比如 一个矩阵[m][n] , 表示为 m行n列矩阵,表示为行优先,当表示为 m 列n行的时候就是表示列优先。 一个三维空间中的向量p分别沿着x方向y方向z方向上分别平移为a,b,c距离,用行优先的平移矩阵表示为 ,用一个列...
  • 数据结构-图的深度优先搜索和广度优先搜索(邻接矩阵实现) 无需过分关注代码本身,核心在于代码的设计思路 深度优先 利用递归算法实现,代码设计思路就是 两个for循环表示对矩阵的每个元素进行一次访问 递归函数...
  • OpenGL之矩阵相乘

    2020-07-16 22:18:28
    优先矩阵经过转置 即可的到列优先矩阵 矩阵的点乘 矩阵可以进行点乘的前提:两个矩阵的行列数相等 矩阵A · 矩阵B = 矩阵C -规则: 矩阵A的第一个元素与矩阵B的第一个元素的乘积 = 矩阵C的第一个元素 矩阵的叉乘 ...
  • 广度优先搜索——邻接矩阵

    千次阅读 2018-12-09 11:58:17
    广度优先搜索——邻接矩阵 需要了解的是,图的广度搜索遍历类似于二叉树的层次遍历,用到了队的操作 代码如下 #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #define OK 1 #...
  • 图的邻接矩阵表示法非常简单,一个定点数组,一个二维数组搞定,类似与这样 下面简单实现一个邻接矩阵表示的方法的图,以及遍历的两种方式。 Graph.h #pragma once #define MAX_SIZE 30 templateclass T,...
  • 由于比较仓促所以直接以代码的形式来讲解,所用为c++中的模板类。· 首先是此代码中用到的头文件:#include&lt;iostream&gt; #include&...· 因为邻接矩阵的广度优先遍历会用到队列,所以我...
  • 因此图可以有一个二阶矩阵来记录各个节点的联通关系,由一个数组来记录各个节点的内容。图的广度优先遍历和深度优先遍历。 输出如下: 深度优先遍历: 1 2 4 8 5 6 3 7 广度优先遍历: 1 2 3 4 ...
  • 矩阵的按行优先存储和按列优先存储 a = 1 2 3 4 5 6 7 8 9 行优先:[[123][456][789]] 列优先:[[147][258][369]] 行优先或列优先看需求
  • 分别用邻接矩阵和邻接表表示图,设计实现深度优先搜索的完整算法,并用适当的实例测试其正确性。
  • 深度优先搜索——邻接矩阵的遍历

    千次阅读 2018-12-08 13:18:21
    深度搜索——邻接矩阵的遍历(图) 在深度优先遍历过程中,首先需要明白深度优先遍历的实质,就是从邻结点入手,逐一遍历,当访问到一个邻结点后,又从该邻结点开始,向下一个邻接点访问,知道所有访问例所有结点的...
  • 用c++实现邻接矩阵的广度优先遍历,供初学者参考
  • 基于邻接矩阵的深度优先搜索遍历

    千次阅读 2017-11-30 20:58:59
    基于邻接矩阵的深度优先搜索遍历 Time Limit: 1000MS Memory Limit: 65536KB Problem Description 给定一个无向连通图,顶点编号从0到n-1,用深度优先搜索(DFS)遍历,输出从某个顶点出发的遍历序列。(同...
  • C++实现,数据结构,图的邻接矩阵表示,深度优先遍历,广度优先遍历,DFS,BFS,为什么要五十个字才能上传啊

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,905
精华内容 24,362
关键字:

优先矩阵