精华内容
下载资源
问答
  • OpenCV进行顶点法向量计算先介绍一下我接触此题的背景。我需要将一个.obj文件中的vn即顶点法向量计算出来。现在有的数据是f(三角面片索引),v(顶点坐标),但是网上找的代码不是很多,逻辑也不是很清楚,因此自己写了...

    OpenCV进行顶点法向量计算

    先介绍一下我接触此题的背景。我需要将一个.obj文件中的vn即顶点法向量计算出来。现在有的数据是f(三角面片索引),v(顶点坐标),但是网上找的代码不是很多,逻辑也不是很清楚,因此自己写了代码,并与大家分享。有错误敬请指出!

    顶点法向量的计算方法

    这里大概摘自这篇文章

    最简单也是最直接的求顶点的法向量的方法是遍历此顶点所关联的所有三角形,将这些三角形上的法向量单位化后叠加,然后求出法向量的均值即可。

    伪代码:

    vertexNormal = (0,0,0);

    for each triangle connect to current vertex;

    vertexNormal += triangleNormal;

    vertexNormal /= connectedTriangleNums;

    但这样求出的法向量往往效果不好,特别是当一些很小的多边形共面时。为了解决这个问题就需要使各个三角形并不是简单的等比例贡献法向量。直观上很容易发现,每个三角形与顶点相关联的那个角的大小是变化的,因此就可以使用此角度的大小来作为单个三角形对顶点法向量的贡献因子。

    vertexNormal = 0,0,0;

    totalAngle = 0;

    for each triangle connect to current vertex;

    angle = acos(dot(edge1 , edge2));

    vertexNormal += trangleNormal * angle;

    totalAngle += angle;

    vertexNormal /= totalAngle;

    在实现时要注意,使用的角为关联当前顶点的那个角。

    本文采用的算法是第二种

    但是,根据数据结构不同,具体按需要编写代码

    实现代码及解析

    为每一个顶点定义一个存储法向量和与总角度的结构体:

    using namespace cv;

    typedef struct vet_data

    {

    Vec3f vn;

    double total_angle;

    } vet_data;

    新建点与面数据进行模拟:

    Vec3f v[4] = {

    Vec3f(33.7193, 24.7910, 50.5333),

    Vec3f(34.6217, 23.1564, 51.2146),

    Vec3f(42.6307, 22.9352, 49.5766),

    Vec3f(41.6282, 24.5848, 48.7240)

    };

    Vec3f f[4] = {

    Vec3f(0, 1, 2),

    Vec3f(0, 2, 3),

    Vec3f(1, 2, 3),

    Vec3f(0, 1, 3)

    };

    初始化:

    vet_data v_data[4];

    for(int i = 0; i < 4; ++i) {

    v_data[i].vn = Vec3f(0,0,0);

    v_data[i].total_angle = 0;

    }

    运算过程:

    for(int i = 0; i < 4; ++i) {

    int indx[3];

    for(int j = 0;j < 3; ++j) {

    indx[j] = f[i][j];

    }

    Vec3f v0 = v[indx[0]],

    v1 = v[indx[1]],

    v2 = v[indx[2]];

    Vec3f e1 = v1 - v0;

    Vec3f e2 = v2 - v1;

    Vec3f vn = normalize(e1.cross(e2));

    double angle[3] = { 0.0, 0.0, 0.0 };

    double t1, t2, t3;

    t1 = (v1 - v0).dot(v2 - v0) / mod(v1 - v0) / mod(v2 - v0) * CV_PI / 180.0;

    t2 = (v0 - v1).dot(v2 - v1) / mod(v0 - v1) / mod(v2 - v1) * CV_PI / 180.0;

    t3 = (v0 - v2).dot(v1 - v2) / mod(v0 - v2) / mod(v1 - v2) * CV_PI / 180.0;

    angle[0] = acos(t1);

    angle[1] = acos(t2);

    angle[2] = acos(t3);

    cout << angle[0] << " " << angle[1] << " " << angle[2] << "\t# " << t1 << " " << t2 << " " << t3 << std::endl;

    for(int i = 0; i < 3; ++i) {

    v_data[indx[i]].vn += vn * angle[i];

    v_data[indx[i]].total_angle += angle[i];

    }

    }

    ofstream out("outputvn.txt");

    out << "-----vn-------" << endl;

    for(int i = 0; i < 4; ++i) {

    Vec3f vn = v_data[i].vn / v_data[i].total_angle;

    out << "vn" << " " << vn[0] << " " << vn[1] << " " << vn[2] << std::endl;

    cout << "vn" << " " << vn[0] << " " << vn[1] << " " << vn[2] << std::endl;

    }

    展开全文
  • 在Apache Commons Math 3中,EigenDecomposition接受非对称矩阵,但它使用RealVector和RealMatrix类返回结果.要获得实际的复杂结果,您必须将适当的实际结果组合成复杂的共轭对.... 1}这两个向量都与复合共轭特征...

    在Apache Commons Math 3中,EigenDecomposition接受非对称矩阵,但它使用RealVector和RealMatrix类返回结果.要获得实际的复杂结果,您必须将适当的实际结果组合成复杂的共轭对.

    在特征向量的情况下,您得到:

    eigenvector[0] = {-0.8660254038; 0}

    eigenvector[1] = {0.5; 1}

    这两个向量都与复合共轭特征值对相关联getRealEigenvalue(0)getImagEigenvalue(0)* i和getRealEigenvalue(1)getImagEigenvalue(1)* i,但这些向量不是实际的特征向量.实际的特征向量是复共轭对

    特征向量[0]特征向量[1] * i和特征向量[0] – 特征向量[1] * i.

    那些向量仍然不匹配numpy返回的结果,但这是因为这两个库没有使用相同的规范化.特征向量不是唯一的;特征向量乘以任何非零标量(包括复数标量)仍然是特征向量. Java结果和numpy结果之间的唯一区别是标量乘数.

    为方便起见,我将浮点值转换为它们的确切值.也就是说,-0.8660254038是-sqrt(3)/ 2的浮点近似. Java数学库提供以下特征向量:

    [-sqrt(3)/2 + (1/2)*i] and [-sqrt(3)/2 - (1/2)*i]

    [ 0 + 1*i] [ 0 - 1*i]

    如果你将第一个特征向量乘以 – (sqrt(2)/ 2)* i和第二个乘以(sqrt(2)/ 2)* i,你将得到numpy返回的特征向量.

    这是一个带有该计算的ipython会话. v1和v2是上面显示的向量.

    In [20]: v1 = np.array([-np.sqrt(3)/2 + 0.5j, 1j])

    In [21]: v1

    Out[21]: array([-0.8660254+0.5j, 0.0000000+1.j ])

    In [22]: v2 = np.array([-np.sqrt(3)/2 - 0.5j, -1j])

    In [23]: v2

    Out[23]: array([-0.8660254-0.5j, 0.0000000-1.j ])

    将v1乘以 – (sqrt(2)/ 2)* i得到numpy.linalg.eig返回的第一个特征向量:

    In [24]: v1*(-np.sqrt(2)/2*1j)

    Out[24]: array([ 0.35355339+0.61237244j, 0.70710678-0.j ])

    将v2乘以(sqrt(2)/ 2)* i得到numpy.linalg.eig返回的第二个特征向量:

    In [25]: v2*(np.sqrt(2)/2*1j)

    Out[25]: array([ 0.35355339-0.61237244j, 0.70710678+0.j ])

    为方便起见,这里是numpy计算的重复. evecs列是特征向量.

    In [28]: evals, evecs = np.linalg.eig(a)

    In [29]: evecs

    Out[29]:

    array([[ 0.35355339+0.61237244j, 0.35355339-0.61237244j],

    [ 0.70710678+0.j , 0.70710678-0.j ]])

    展开全文
  • 1.初始化定义 typedef double ElemType; typedef ElemType* Vector; typedef ElemType** Matrix; typedef ElemType*** MatrixStack;.../* brief:创建向量 ** param:长度 ** output:Vector */ Vector

    1.初始化定义

    typedef double ElemType;
    typedef ElemType* Vector;
    typedef ElemType** Matrix;
    typedef ElemType*** MatrixStack;
    
    #define ZERO_MATRIX 0
    #define ONES_MATRIX 1
    #define UNIT_MATRIX 2
    

    2.向量操作

    2.1向量初始化

    /* brief:创建向量
    ** param:长度
    ** output:Vector
    */
    Vector initVector(int len) {
        Vector res = (ElemType*)malloc(sizeof(ElemType)*len);
        if (res == NULL) {
            printf("VECTOR CREATE ERROR\n");
            return NULL;
        }
        return res;
    }
    

    2.2向量销毁

    /* brief:销毁向量
    ** param:向量
    ** output:整数
    */
    int destoryVector(Vector vec) {
        free(vec);
        return 1;
    }
    

    2.3向量相加

    /* 说明:两个向量的加法
    ** param[0]:向量A
    ** param[1]:向量B
    ** param[2]:长度
    ** output:向量
    */
    Vector vectorAdd(const Vector vecA, const Vector vecB, int len) {
        Vector C = initVector(len);
        for (int i = 0; i<len; i++) {
            C[i] = vecA[i] + vecB[i];
        }
        return C;
    }
    

    2.4向量相减

    /* 说明:两个向量的减法
    ** param[0]:向量A
    ** param[1]:向量B
    ** param[2]:长度
    ** output:向量
    */
    Vector vectorSubtract(const Vector vecA, const Vector vecB, int len) {
        Vector C = initVector(len);
        for (int i = 0; i<len; i++) {
            C[i] = vecA[i] - vecB[i];
        }
        return C;
    }
    

    2.5向量相乘(1,N)*(N,1)

    /* brief:向量相乘(1,N)*(N,1)
    ** param[0]:向量A
    ** param[1]:向量B
    ** param[2]:向量长度
    ** output:浮点数
    */
    ElemType vecDotVecToElem(const Vector vecA, const Vector vecB, int n) {
        int i, i1;
        ElemType ret = vecA[n - 1] * vecB[n - 1];
        for (i = n - 2; i >= 1; i -= 2) {
            i1 = i - 1;
            ret += vecA[i] * vecB[i] + vecA[i1] * vecB[i1];
        }
        if (i == 0) ret += vecA[0] * vecB[0]; 
        return ret;
    }
    

    2.6向量相乘(N,1)*(1,N)

    /* brief:向量相乘(N,1)*(1,N)
    ** param[0]:向量A
    ** param[1]:向量A长度
    ** param[2]:向量B
    ** param[3]:向量B长度
    ** output:矩阵
    */
    Matrix vecDotVecToMatrix(const Vector vecA, int aLen, const Vector vecB, int bLen) {
        Matrix res=(ElemType**)malloc(sizeof(ElemType*)*aLen);
        for(int i=0;i<aLen;i++){
            res[i]=(ElemType*)malloc(sizeof(ElemType)*bLen);
            for(int j=0;j<bLen;j++){
                res[i][j]=vecA[i]*vecB[j];
            }
        }
        return res;
    }
    

    2.7向量乘数值

    /* brief:Vector乘数值
    ** param[0]:向量
    ** param[1]:长度
    ** param[2]:数值
    ** output:向量
    */
    Vector vectorMulNum(const Vector vec, int len, ElemType num) {
        Vector res = initVector(len);
        for (int i = 0; i<len; i++) {
            res[i] = vec[i] * num;
        }
        return res;
    }
    

    2.8向量除以数值

    /* brief:Vector除以数值
    ** param[0]:向量
    ** param[1]:长度
    ** param[2]:数值
    ** output:向量
    */
    Vector vectorDivNum(const Vector vec, int len, ElemType num) {
        Vector res = initVector(len);
        for (int i = 0; i<len; i++) {
            res[i] = vec[i] / num;
        }
        return res;
    }
    

    2.9向量的均方根

    /* brief:向量的均方根
    ** param[0]:向量
    ** param[1]:长度
    ** output:均方根
    */
    ElemType vectorRootMeanSquare(const Vector vec, int len) {
        ElemType nor;
        for (int i = 0; i<len; i++) {
            nor += vec[i] * vec[i];
        }
        return sqrt(nor);
    }
    

    2.10打印向量

    /* brief:打印向量
    ** param[0]:向量
    ** param[1]:长度
    ** output:无
    */
    void vectorPrint(const Vector vec, int len) {
        for (int i = 0; i<len; i++) {
            printf("%lf\t", vec[i]);
        }
        printf("\n");
    }
    

    3.矩阵操作

    3.1创建矩阵

    /* brief:创建矩阵
    ** param[0]:行
    ** param[1]:列
    ** output:矩阵
    */
    Matrix initMatrix(int row, int col) {
        Matrix mat = (ElemType**)malloc(sizeof(ElemType*)*row);
        if (mat == NULL) {
            printf("MATRIX CREATE ERROR\n");
            return NULL;
        }
        for (int i = 0; i<row; i++) {
            mat[i] = (ElemType*)malloc(sizeof(ElemType)*col);
            if (mat[i] == NULL) {
                printf("MATRIX CREATE ERROR\n");
                return NULL;
            }
        }
        return mat;
    }
    

    3.2销毁矩阵

    /* brief:销毁矩阵
    ** param[0]:数组
    ** param[1]:行
    ** output:整数
    */
    int destroyMatrix(Matrix mat, int row) {
        if (!mat) return 1;
        for (int i = 0; i<row; i++) {
            free(mat[i]);
        }
        free(mat);
        mat = NULL;
        return 1;
    }
    

    3.3填充矩阵

    /* brief:填充矩阵
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:类型[ZERO_MATRIX, ONES_MATRIX, UNIT_MATRIX]
    ** 输出:矩阵
    */
    Matrix fillMatrix(Matrix mat, int row, int col, int type) {
        int i, j, k;
        switch (type) {
        case ZERO_MATRIX:
            for (i = 0; i<row; ++i) {
                for (j = 0; j<col; ++j) {
                    mat[i][j] = 0.0;
                }
            }
            break;
        case UNIT_MATRIX:
            for (i = 0; i<row; ++i) {
                for (j = 0; j<col; ++j) {
                    mat[i][j] = 0.0;
                }
            }
            k = (col<row) ? col : row;
            for (i = 0; i<k; ++i) {
                mat[i][i] = 1.0;
            }
            break;
        case ONES_MATRIX:
            for (i = 0; i<row; ++i) {
                for (j = 0; j<col; ++j)
                    mat[i][j] = 1.0;
            }
            break;
        }
        return mat;
    }
    

    3.4矩阵获取行

    /* brief:浮点矩阵获取行
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:行定位
    ** output:Vector
    */
    Vector getRow(const Matrix mat, int row, int col, int loc) {
        if (loc >= row) {
            printf("GET ROW ERROR\n");
            return NULL;
        }
        int i;
        Vector x = initVector(col);
        for (i = col - 1; i>0; --i) {
            x[i] = mat[loc][i];
            --i;
            x[i] = mat[loc][i];
        }
        if (i == 0) x[0] = mat[loc][0];
        return x;
    }
    

    3.5矩阵获取列

    /* brief:浮点矩阵获取列
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:列定位
    ** output:Vector
    */
    Vector getCol(const Matrix mat, int row, int col, int loc) {
        if (loc >= col) {
            printf("GET COLUMN ERROR\n");
            return NULL;
        }
        int i;
        Vector x = initVector(row);
        for (i = row - 1; i>0; --i) {
            x[i] = mat[i][loc];
            --i;
            x[i] = mat[i][loc];
        }
        if (i == 0) x[0] = mat[0][loc];
        return x;
    }
    

    3.6设置行

    /* brief:设置行
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:插入的行
    ** param[4]:插入的位置
    ** output:1
    */
    int setRow(Matrix A, int row, int col, Vector V, int loc){
        if(loc<0 || loc>row){
            return 0;
        }
        for(int i=0;i<col;i++){
            A[loc][i]=V[i];
        }
        return 1;
    }
    

    3.7设置列

    /* brief:设置列
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:插入的列
    ** param[4]:插入的位置
    ** output:1
    */
    int setCol(Matrix A, int row, int col, Vector V, int loc){
        if(loc<0 || loc>col){
            return 0;
        }
        for(int i=0;i<row;i++){
            A[i][loc]=V[i];
        }
        return 1;
    }
    

    3.8矩阵加法

    /* brief:矩阵加法
    ** param[0]:矩阵A
    ** param[1]:矩阵B
    ** param[2]:矩阵A行
    ** param[3]:矩阵A列
    ** param[4]:矩阵B行
    ** param[5]:矩阵B列
    ** output:矩阵
    */
    Matrix matrixAdd(const Matrix x, const Matrix y, int xrow, int xcol, int yrow, int ycol) {
        if (xrow != yrow || xcol != ycol) {
            printf("MATRIX ADD ERROR\n");
            return NULL;
        }
        Matrix res = (ElemType**)malloc(sizeof(ElemType*)*xrow);
        for (int i = 0; i<xrow; i++) {
            res[i] = (ElemType*)malloc(sizeof(ElemType)*xcol);
            for (int j = 0; j<xcol; j++) {
                res[i][j] = x[i][j] + y[i][j];
            }
        }
        return res;
    }
    

    3.9矩阵减法

    /* brief:矩阵减法
    ** param[0]:矩阵A
    ** param[1]:矩阵B
    ** param[2]:矩阵A行
    ** param[3]:矩阵A列
    ** param[4]:矩阵B行
    ** param[5]:矩阵B列
    ** output:矩阵
    */
    Matrix matrixSubtract(const Matrix x, const Matrix y, int xrow, int xcol, int yrow, int ycol) {
        if (xrow != yrow || xcol != ycol) {
            printf("MATRIX SUBTRACT ERROR\n");
            return NULL;
        }
        Matrix res = (ElemType**)malloc(sizeof(ElemType*)*xrow);
        for (int i = 0; i<xrow; i++) {
            res[i] = (ElemType*)malloc(sizeof(ElemType)*xcol);
            for (int j = 0; j<xcol; j++) {
                res[i][j] = x[i][j] - y[i][j];
            }
        }
        return res;
    }
    

    3.10矩阵乘以数值

    /* brief:矩阵乘以数值
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** param[3]:数值
    ** output:数组
    */
    Matrix matrixMulNum(const Matrix mat, int row, int col, ElemType num) {
        Matrix res = (ElemType**)malloc(sizeof(ElemType*)*row);
        for (int i = 0; i<row; i++) {
            res[i] = (ElemType*)malloc(sizeof(ElemType)*col);
            for (int j = 0; j<col; j++) {
                res[i][j] = mat[i][j] * num;
            }
        }
        return res;
    }
    

    3.11矩阵乘法

    Matrix _marixDotMatrixSmall(const Matrix x, const Matrix y, int xrow, int xcol, int ycol) {
        Matrix ret = (ElemType**)malloc(sizeof(ElemType*)*xrow);
        for (int i = 0; i<xrow; i++) {
            ret[i] = (ElemType*)malloc(sizeof(ElemType)*ycol);
        }
        for (int i = xrow - 1; i >= 0; i--) {
            for (int k = ycol - 1; k >= 0; k--) {
                int j;
                ElemType woo = x[i][xcol - 1] * y[xcol - 1][k];
                for (j = xcol - 2; j >= 1; j -= 2) {
                    int i0 = j - 1;
                    woo += x[i][j] * y[j][k] + x[i][i0] * y[i0][k];
                }
                if (j == 0) woo += x[i][0] * y[0][k];
                ret[i][k] = woo;
            }
        }
        return ret;
    }
    
    Matrix _marixDotMatrixBig(const Matrix x, const Matrix y, int xrow, int xcol, int ycol) {
        int m = xrow, n = ycol;
        Matrix A = initMatrix(m, n);
        for (int i = n - 1; i != -1; --i) {
            Vector v = getCol(y, xrow, xcol, i);
            for (int j = m - 1; j != -1; --j) {
                Vector xj = getRow(x, xrow, xcol, j);
                A[j][i] = vecDotVecToElem(xj, v, n);
                destoryVector(xj);
            }
            destoryVector(v);
        }
        return A;
    }
    
    /* brief:矩阵乘法
    ** param[0]:矩阵A
    ** param[1]:矩阵B
    ** param[2]:矩阵A行
    ** param[3]:矩阵A列
    ** param[4]:矩阵B行
    ** param[5]:矩阵B列
    ** 输出:矩阵相乘结果
    */
    Matrix matrixMultiply(const Matrix x, int xrow, int xcol, const Matrix y, int yrow, int ycol) {
        if (xcol != yrow) {
            printf("MATRIX MULTIPLY ERROR\n");
            return NULL;
        }
        if (xcol < 10) {
            return _marixDotMatrixSmall(x, y, xrow, xcol, ycol);
        }
        else {
            return _marixDotMatrixBig(x, y, xrow, xcol, ycol);
        }
    }
    

    3.12矩阵转置

    /* brief:矩阵转置
    ** param[0]:矩阵
    ** param[1]:行
    ** param[2]:列
    ** output:转置结果
    */
    Matrix matrixTranspose(const Matrix mat, int row, int col) {
        Matrix res = (ElemType**)malloc(sizeof(ElemType*)*col);
        for (int i = 0; i<col; i++) {
            res[i] = (ElemType*)malloc(sizeof(ElemType)*row);
            for (int j = 0; j<row; j++) {
                res[i][j] = mat[j][i];
            }
        }
        return res;
    }
    

    3.13矩阵复制

    /* brief:矩阵复制
    ** param[0]:待复制矩阵
    ** param[1]:行
    ** param[2]:列
    ** output:复制结果
    */
    Matrix matrixCopy(const Matrix mat, int row, int col) {
        Matrix result = initMatrix(row, col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                result[i][j] = mat[i][j];
            }
        }
        return result;
    }
    

    3.14求行列式

    /* brief:求行列式
    ** param[1]:输入方阵
    ** param[2]:方阵的行数
    ** 输出:行列式结果
    */
    ElemType matrixDet(const Matrix mat, int n) {
        if (n == 1) {
            return mat[0][0];
        }
        ElemType ans = 0.0;
        Matrix temp = initMatrix(n, n);
        int i, j, k;
        for (i = 0; i<n; i++) {
            for (j = 0; j<n - 1; j++) {
                for (k = 0; k<n - 1; k++) {
                    temp[j][k] = mat[j + 1][(k >= i) ? k + 1 : k];
    
                }
            }
            ElemType t = matrixDet(temp, n - 1);
            if (i % 2 == 0) {
                ans += mat[0][i] * t;
            }
            else {
                ans -= mat[0][i] * t;
            }
        }
        return ans;
    }
    

    3.15矩阵取逆

    //计算每一行每一列的每个元素所对应的余子式,组成A*
    void _getMatrixStart(Matrix arcs, int row, int col, Matrix ans) {
        if (row != col) printf("GET A* ERROR\n");
        int n = row;
        if (n == 1) {
            ans[0][0] = 1;
            return;
        }
        int i, j, k, t;
        Matrix temp = initMatrix(row, col);
        for (i = 0; i<n; i++) {
            for (j = 0; j<n; j++) {
                for (k = 0; k<n - 1; k++) {
                    for (t = 0; t<n - 1; t++) {
                        temp[k][t] = arcs[k >= i ? k + 1 : k][t >= j ? t + 1 : t];
                    }
                }
                ans[j][i] = matrixDet(temp, n - 1);
                if ((i + j) % 2 == 1) {
                    ans[j][i] = -ans[j][i];
                }
            }
        }
    }
    
    Matrix _matrixInverse(Matrix mat, int row, int col) {
        ElemType det = matrixDet(mat, row);
        Matrix result = initMatrix(row, col);
        Matrix temp = initMatrix(row, col);
        if (det == 0) {
            printf("GET INVERSE ERROR\n");
            return NULL;
        }
        else {
            _getMatrixStart(mat, row, col, temp);
            for (int i = 0; i<row; i++) {
                for (int j = 0; j<col; j++) {
                    result[i][j] = temp[i][j] / det;
                }
            }
        }
        return result;
    }
    
    /* brief:矩阵取逆
    ** param[0]:待取逆矩阵
    ** param[1]:行
    ** param[2]:列
    ** output:取逆结果
    */
    Matrix matrixInverse(const Matrix mat, int row, int col) {
        Matrix tmp1, tmp2, tmp3, tmp4;
        Matrix B, X, X_H, B_R;
        Matrix ret;
    
        if (row < col) {
            tmp1 = matrixTranspose(mat, row, col);
            B = matrixMultiply(mat, row, col, tmp1, row, col);
    
            tmp2 = matrixMultiply(B, row, col, B, row, col);
            tmp3 = _matrixInverse(tmp2, row, col);
            X_H = matrixMultiply(tmp3, row, col, B, row, col);
    
            X = matrixTranspose(X_H, row, col);
            tmp4 = matrixMultiply(X, row, col, B, row, col);
            B_R = matrixMultiply(tmp4, row, col, X_H, row, col);
    
            ret = matrixMultiply(tmp1, row, col, B_R, row, col);
    
            destroyMatrix(tmp1, row);
            destroyMatrix(tmp2, row);
            destroyMatrix(tmp3, row);
            destroyMatrix(tmp4, row);
            destroyMatrix(X_H, row);
            destroyMatrix(X, row);
            destroyMatrix(B, row);
            destroyMatrix(B_R, row);
        }
        else if (row > col) {
            tmp1 = matrixTranspose(mat, row, col);
            B = matrixMultiply(tmp1, row, col, mat, row, col);
    
            tmp2 = matrixMultiply(B, row, col, B, row, col);
            tmp3 = _matrixInverse(tmp2, row, col);
            X_H = matrixMultiply(tmp3, row, col, B, row, col);
    
            X = matrixTranspose(X_H, row, col);
            tmp4 = matrixMultiply(X, row, col, B, row, col);
            B_R = matrixMultiply(tmp4, row, col, X_H, row, col);
    
            ret = matrixMultiply(B_R, row, col, tmp1, row, col);
    
            destroyMatrix(tmp1, row);
            destroyMatrix(tmp2, row);
            destroyMatrix(tmp3, row);
            destroyMatrix(tmp4, row);
            destroyMatrix(X_H, row);
            destroyMatrix(X, row);
            destroyMatrix(B, row);
            destroyMatrix(B_R, row);
        }
        else {
            ret = _matrixInverse(mat, row, col);
        }
        return ret;
    }
    

    3.16求每一列的均值

    /* brief:求每一列的均值
    ** param[0]:输入矩阵
    ** param[1]:行
    ** param[2]:列
    ** output:均值矩阵
    */
    Matrix matrixMeanCol(const Matrix mat, int row, int col) {
        int i, j;
        Matrix result = initMatrix(1, col);
        // 第一行设置为0
        for (j = 0; j < col; j++)
            result[0][j] = 0.0;
        for (i = 0; i < row; i++) {
            for (j = 0; j < col; j++)
                result[0][j] += mat[i][j];
        }
        for (j = 0; j < col; j++)
            result[0][j] /= (ElemType)row;
        return result;
    }
    

    3.17矩阵标准化?

    /* brief:矩阵标准化?
    ** param[0]: 输入矩阵
    ** param[1]: 均值矩阵
    ** param[2]:输入矩阵行
    ** param[3]:输入矩阵列
    ** param[4]:均值矩阵行
    ** param[5]:均值矩阵列
    ** output:标准化矩阵
    */
    Matrix matrixStd(const Matrix mat, const Matrix mean, int rowMat, int colMat, int rowMean, int colMean) {
        int i, j, row, col;
        Matrix std = initMatrix(rowMean, colMean);
        for (j = 0; j < colMat; j++) {
            for (i = 0; i < rowMat; i++) {
                std[0][j] += (mat[i][j] - mean[0][j]) * (mat[i][j] - mean[0][j]);
            }
        }
        for (i = 0; i < colMean; i++) {
            std[0][i] = std[0][i] / (((ElemType)rowMean) - (ElemType)1.0);
            std[0][i] = sqrt(std[0][i]);
        }
        return std;
    }
    

    3.18打印矩阵

    /* brief:打印矩阵
    ** param[0]: 输入矩阵
    ** param[1]:行
    ** param[2]:列
    ** output:无
    */
    void matrixPrint(const Matrix mat, int row, int col) {
        for (int i = 0; i<row; i++) {
            for (int j = 0; j<col; j++) {
                printf("%f\t", mat[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    }
    

    3.19对角化

    /* brief:对角化
    ** param[0]: 输入方阵
    ** param[1]:行
    ** output:无
    */
    Matrix diag(Vector d, int N){
        int i1,j;
        Matrix A = initMatrix(N,N);
        for(int i=N-1;i>=0;i--) {
            i1 = i+2;
            for(j=N-1;j>=i1;j-=2) {
                A[i][j] = 0;
                A[i][j-1] = 0;
            }
            if(j>i) { A[i][j] = 0; }
            A[i][i] = d[i];
            for(j=i-1;j>=1;j-=2) {
                A[i][j] = 0;
                A[i][j-1] = 0;
            }
            if(j==0) { A[i][0] = 0; }
        }
        return A;
    }
    
    展开全文
  • 计算Python Numpy向量之间的欧氏距离,已知vec1和vec2是两个Numpy向量,欧氏距离计算如下:import numpydist = numpy.sqrt(numpy.sum(numpy.square(vec1 - vec2)))或者直接:dist = numpy.linalg.norm(vec1 - vec2)...

    计算Python Numpy向量之间的欧氏距离,已知vec1和vec2是两个Numpy向量,欧氏距离计算如下:import numpy

    dist = numpy.sqrt(numpy.sum(numpy.square(vec1 - vec2)))

    或者直接:dist = numpy.linalg.norm(vec1 - vec2)

    补充知识:Python中计算两个数据点之间的欧式距离,一个点到数据集中其他点的距离之和

    如下所示:

    计算数两个数据点之间的欧式距离import numpy as np

    def ed(m, n):

    return np.sqrt(np.sum((m - n) ** 2))

    i = np.array([1, 1])

    j = np.array([3, 3])

    distance = ed(i, j)

    print(distance)

    在jupyter 中运输代码输出结果如下:

    计算一个点到数据集中其他点的距离之和from scipy import *

    import pylab as pl

    all_points = rand(500, 2)

    pl.plot(all_points[:, 0], all_points[:, 1], 'b.')

    pl.show()

    在jupyter 中运输代码输出结果如下:

    from scipy import *

    import pylab as pl

    all_points = rand(500, 2)

    pl.plot(all_points[:, 0], all_points[:, 1], 'b.')

    pl.show()

    定义函数计算距离def cost(c, all_points): #指定点,all_points:为集合类的所有点

    return sum(sum((c - all_points) ** 2, axis=1) ** 0.5)

    以上这篇计算Python Numpy向量之间的欧氏距离实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持。

    展开全文
  • C++计算对称矩阵的实特征值和特征向量C++计算对称矩阵的实特征值和特征向量完整源码 C++计算对称矩阵的实特征值和特征向量完整源码 #include <cassert> #include <cmath> #include <cstdlib> #...
  • 在apachecommons math3中,EigenDecomposition接受非对称矩阵,但它使用...在在特征向量的情况下,你得到:eigenvector[0] = {-0.8660254038; 0}eigenvector[1] = {0.5; 1}这两个向量都与复共轭特征值对getRealEi...
  • 在与该矩阵的实际特征值相对应的特征向量(由Python计算)似乎不是特征向量,而由Wolfram Alpha计算的特征向量似乎有效。(我的同事证实,在R中进行计算时,出现了相同的病理现象,但我没有转录本。)代码片段:>>...
  • 是可以实现线性计算的,numpy库提供了矩阵运算,可以实现求取矩阵特征向量,scipy也可以实现numpy库提供的矩阵运算功能,是对numpy库提供矩阵运算的扩展,本文介绍python中计算矩阵特征向量的两种方法:1、使用numpy...
  • 用C#代码实现该计算 效果图 实现代码 private int[,] GetMath(int[,] a,int [,]b) { int Arow = a.GetLength(0);//获取A的行数 int Acloumn = a.GetLength(1);//获取A的列数 int Brow = b.GetLength(0);//...
  • 步骤:(1)读取3篇txt格式的英文文档;(2)对每篇文档进行分词;(3)利用正则表达式去掉逗号、句号等标点符号;(4)计算文档频率;(5)统计特征向量
  • 遗言 恩,你没听错,就是遗言,因为大学的时候是一名学渣,没有好好学习3D图形相关的几何知识.现在用到了,才感到其强大之...要得到任意维度向量的负向量,只需要简单地将向量地每一个分量变负即可.数学表达式如下. -[a1,a..
  • 计算2-维离散型随机向量(X,Y)(X,Y)(X,Y)的条件分布律,譬如P(X∣Y=yj)P(X|Y=y_j)P(X∣Y=yj​),就是用YYY的边缘分布中的P(Y=yj)=p⋅jP(Y=y_j)=p_{\cdot j}P(Y=yj​)=p⋅j​遍除联合分布律中第jjj列中每个元素pijp_{...
  • 46.5.2 幂法及其MATLAB 程序5.2.2 幂法的MATLAB 程序用幂法计算矩阵A 的主特征值和对应的特征向量的MATLAB 主程序function [k,lambda,Vk,Wc]=mifa(A,V0,jd,max1) lambda=0;k=1;Wc =1; ,jd=jd*0.1;state=1; V=V0; ...
  • 你的代码很少出错。在my vector a should be of dimension 10, but it ...在for t in range(0,10,1):for j in range(0, len(c)):if c[j]>t/10:a.append(sum(c[j]>t))对于每个阈值,t,每次迭代一个c中的所有1...
  • 核心代码段 /** * 根据矩阵和阶数计算最大特征值和特征向量 * * @param matrixParam * @return */ public MatrixBO matrixCal(MatrixParam matrixParam) { log.info("矩阵计算-->{}",matrixParam); DecimalFormat ...
  • 平面向量计算和运用实例相关概念有向线段:具有方向的线段叫做有向线段,以A为起点,B为终点的有向线段记作 或AB;向量的模:有向线段AB的长度叫做向量的模,记作|AB|;零向量:长度等于0的向量叫做零向量,记作 ...
  • 2.1.1 相似度计算举例下面我们考虑一个固定的查询和文档集,包含一个查询Q和三篇文档组成的文档集:Q:"gold silver truck"D1:"Shipment of gold damaged in a fire"D2:"Delivery of silver arrived in a silver ...
  • 凡K为考虑点邻居的数目在附近Pi,p表示3D质心最近的邻居,λjj协方差矩阵的特征值第,并且\vec{{\mathsf v}_j} 在j个特征向量。 #include <iostream> #include <pcl\io\pcd_io.h> #include
  • 第3章 矩阵特征值与特征向量计算 数值分析与各种算法的matlab代码3.3.2 Jacobi旋转法 由于一次正交相似变换A→C=PTAP可将A的两个非对角元素化为零。因此可选一系列正交变换矩阵Pk,对A进行正交相似变换,直至将A...
  • 向量坐标相乘的计算算法

    千次阅读 2021-03-18 15:53:37
    比如已知向量AB=(2,3)...|i j k| |x y z| |u v w| 向量的记法:印刷体记作粗体的字母(如a、b、u、v),书写时在字母顶上加一小箭头“→”。 如果给定向量的起点(A)和终点(B),可将向量记作AB(并于顶上加→)
  • 向量距离与相似性度量计算(1)欧式距离(2)曼哈顿距离(3)切比雪夫距离(4)闵氏距离(闵可夫斯基)(5)马氏距离(马哈拉诺比斯距离)(6)余弦距离(7)汉明距离(编辑距离)(8)杰卡德相似系数(9)相关系数 ( Correlation ...
  • 计算两个向量的点积

    2021-07-11 22:27:40
    给定两个向量计算它们的点积(内积)。 输入 输入数据有若干行。每行上有两个向量(维数皆不超过20),对应一种情形。 输出 对于每一种情形,先输出"Case #: "(#为序号,从1起),然后输出结果(保留2位小数),...
  • 现在想计算这m个样本相互之间的欧式距离,除了直接的两层循环实现之外,在网上搜索发现matlab已经提供了类似功能的函数:pdist和pdist2(前者计算一个向量自身的距离矩阵,后者计算两个向量之间的距离矩阵;...
  • 【电工学常用单位计算与换算公式大全】一、电工学常用公式:电功:电流在一段时间内通过某一电路,电场力所做的功W表示功,功的单位是:焦耳(J)W = P * tP --- 功率(单位:瓦w)t --- 时间 (单位:秒s)W = U * I * tU...
  • 假设集合A有m个向量,集合B有n个向量。所有向量的维度都是d维。如何求这m个向量与这n个向量的距离(共m*n个)? 二、分析 一般,我们会想到使用两重循环的方式来求。 for i in range(m): for j in range(n): ...
  • 使用scipy 计算预选值 from scipy.spatial import distance print(1-distance.cosine([1,0],[0,1])) 具体 应用:使用bert 计算 相似度 import keras_bert from scipy.spatial import distance # bert 模型地址...
  • 本题要求编写程序,计算两个二维平面向量的和向量。 输入格式: 输入在一行中按照“x1,y1,x2,y2​​ ”的格式给出两个二维平面向量v​1=(x1, y1)和v​2=(x2, y2)的分量。 输出格式: 在一行中按照(x, y)的格式输出...
  • 利用QR算法求解矩阵的特征值和特征向量为了求解一般矩阵(不是那种幼稚到shi的2 x 2矩阵)的特征值.根据定义的话,很可能需要求解高阶方程...这明显是个坑...高阶方程你肿么破...折腾了好久1.我要求特征值和...
  • 曼哈顿距离——两点在南北方向上的距离加上在东西方向上的距离,即d(i,j)=|xi-xj|+|yi-yj|。对于一个具有正南正北、正东正西方向规则布局的城镇街道,从一点到达另一点的距离正是在南北方向上旅行的距离加上在东西...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,124
精华内容 56,849
关键字:

向量计算j