超好用的纯C语言矩阵运算库

最新推荐文章于 2024-08-08 07:56:34 发布
最新推荐文章于 2024-08-08 07:56:34 发布
阅读量9.7k 收藏 100
点赞数 20
分类专栏： 基础算法库 文章标签： C 矩阵运算库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870191/article/details/92417340
版权

超好用的纯C语言矩阵运算库 easyMatrix


最近开发基于异构传感器的异步定位数据的卡尔曼滤波，因为最终要用在一个老爷DSP上，已有代码都是C写的，不想研究这种老爷设备下的C++调用，Eigen这超好用的矩阵运算库算是没法用了。随便搜了几个C矩阵库发现不是超难用就是有bug，比如csdn某小哥写的matrix库，矩阵维数一大，逆矩阵计算就出错。项目结束后，想着可能很多嵌入式开发人员也许有类似的需求，决定自己还是写一个操作友好的matrix库，工具虽小，好用就行。
支持矩阵的加、减、乘法运算，转置、逆矩阵、伴随矩阵、LU分解、行列式计算、线性方程求解等功能
废话不说，上代码：
github地址： https://github.com/fellylanma/easyMatrix 

//使用例子
int main() {
	//create matrix on stack
 	float val1[] = {1,2,3,4,5,6,7,8,9};
	float val2[] = {1,1,1,1,1,1,1,1,1};
	CREATE_MATRIX_ONSTACK(3,3,A,val1);
	CREATE_MATRIX_ONSTACK(3,3,B,val2);
	CREATE_MATRIX_ONSTACK(3,3,C,NULL);
	addMatrix(&A,&B,&C);
	dumpMatrix(&C);
    printf("det is:%f\n",detMatrix(&A));
	int x = A.rows;
	int y = A.cols;
	printf("element[1,1] is:%f\n",A.element[1*x+1]);
	//create matrix on heap and you need to delete the pointer
	CREATE_DYNAMIC_MATRIX_ONHEAP(x,y,D,val1);
	CREATE_DYNAMIC_MATRIX_ONHEAP(x,y,E,val2);
	CREATE_DYNAMIC_MATRIX_ONHEAP(x,y,F,NULL);
	multiMatrix(D,E,&C);
	multiMatrix(D,E,F);

	DELETE_DYNAMIC_MATRIX(D);
	DELETE_DYNAMIC_MATRIX(E);
	DELETE_DYNAMIC_MATRIX(F);
}

easyMatrix.h

#ifndef _MAGRIDE_PLANNING_EASYMATRIX_H_
#define _MAGRIDE_PLANNING_EASYMATRIX_H_

#include <stdlib.h>
typedef unsigned char uint8;
typedef float DATA_TYPE;


#define CREATE_MATRIX_ONSTACK(x,y,matrix,initval) \
struct easyMatrix matrix;\
DATA_TYPE val##x##N##y##N##matrix[x*y];\
    matrix.rows = x;\
    matrix.cols = y;\
    matrix.element = val##x##N##y##N##matrix;\
    if(initval!=NULL) setMatrix(initval, &(matrix))

#define CREATE_DYNAMIC_MATRIX_ONHEAP(x,y,matrix,initval) \
struct easyMatrix *matrix = (struct easyMatrix*)malloc(sizeof(struct easyMatrix));\
matrix->rows = x;\
matrix->cols = y;\
matrix->element = (DATA_TYPE*) malloc(sizeof(DATA_TYPE)*(x)*(y));\
if(initval!=NULL) setMatrix(initval, (matrix))

#define DELETE_DYNAMIC_MATRIX(matrix) \
    free((matrix)->element);\
    free(matrix)

struct easyMatrix {\
    uint8 rows,cols;\
    DATA_TYPE* element;
};\

struct easyMatrix* setMatrix(DATA_TYPE* const a,struct easyMatrix* c);
struct easyMatrix* copyMatrix(struct easyMatrix* const a,struct easyMatrix* c);
struct easyMatrix* transMatrix(struct easyMatrix* const a,struct easyMatrix* c);

DATA_TYPE detMatrix(struct easyMatrix* const a);

DATA_TYPE invMatrix(struct easyMatrix* const a, struct easyMatrix*b);

struct easyMatrix* scaleMatrix(DATA_TYPE, struct easyMatrix* const a, struct easyMatrix*);

struct easyMatrix* addMatrix(const struct easyMatrix* const a, const struct easyMatrix *const  b, struct easyMatrix * c);

struct easyMatrix* leftMatrix(uint8, uint8, struct easyMatrix* const a, struct easyMatrix* b);

struct easyMatrix* subMatrix(struct easyMatrix* const a, struct easyMatrix* const  b, struct easyMatrix* c);

struct easyMatrix* multiMatrix(struct easyMatrix* const a, struct easyMatrix* const b, struct easyMatrix* c);

struct easyMatrix* zerosMatrix(struct easyMatrix* e);

struct easyMatrix* eyesMatrix(struct easyMatrix* e);

void dumpMatrix(struct easyMatrix* const e);

struct easyMatrix* adjMatrix(struct easyMatrix* const a,struct easyMatrix* c);

struct easyMatrix* getLUMatrix(struct easyMatrix* const A, struct easyMatrix* L,struct easyMatrix* U) ;

struct easyMatrix* invLMatrix(struct easyMatrix* const L, struct easyMatrix* L_inv) ;
struct easyMatrix* invUMatrix(struct easyMatrix* const U, struct easyMatrix* U_inv) ;

struct easyMatrix* solveEquationMatrix(const struct easyMatrix* const A,const struct easyMatrix* const Y, struct easyMatrix* X) ;


DATA_TYPE fastDetMatrix(struct easyMatrix* const in) ;
#endif//_MAGRIDE_PLANNING_EASYMATRIX_H_

#easyMatrix.c

#include <stdlib.h>
#include <float.h>
#include "easyMatrix.h"

int isFiniteNumber(double d) {
    return (d<=DBL_MAX&&d>=-DBL_MAX);
}
struct easyMatrix* setMatrix(DATA_TYPE * const a,struct easyMatrix* c) {
    uint8 x = c->rows;
    uint8 y = c->cols;
    int t = x*y;
    for(int i=0;i<t;++i) {
        c->element[i] = a[i];
    }
    return c;
}

struct easyMatrix* copyMatrix(struct easyMatrix* const a,struct easyMatrix* c) {
    if(a->rows != c->rows) return NULL;
    if(a->cols != c->cols) return NULL;
    int t = a->rows*a->cols;
    for(int i=0;i<t;++i) {
        c->element[i] = a->element[i];
    }
    return c;
}

struct easyMatrix* transMatrix(struct easyMatrix* const a,struct easyMatrix* c) {
    if(a->rows != c->cols) return NULL;
    if(a->cols != c->rows) return NULL;
    int index = 0;
    int index_src = 0;
    for(uint8 ii=0;ii<a->cols;++ii) {
        index_src=ii;
        for(uint8 jj=0;jj<a->rows;++jj) {
            //c->element[index] = a->element[jj*a->cols+ii];
            c->element[index] = a->element[index_src];
            index++;
            index_src+=a->cols;
        }
    }
    return c;
}

struct easyMatrix* leftMatrix(uint8 x_i,uint8 y_i, struct easyMatrix* const in, struct easyMatrix* out) {
    if(in->rows != in->cols) return NULL;
    if(out->rows != out->cols) return NULL;
    if(in->rows != (out->rows+1)) return NULL;
    int index = 0;
    int index_src = 0;
    uint8 x =in->rows;
    uint8 y =in->cols;
    for(uint8 kk=0;kk<x;++kk) {
        for(uint8 ww=0;ww<y;++ww) {
            if(!(kk==x_i||ww==y_i)) {
                //out->element[index] = in->element[kk*y+ww];
                out->element[index] = in->element[index_src];
                index++;
            }
            index_src++;
        }
    }
    return out;
}
struct easyMatrix* adjMatrix(struct easyMatrix* const in, struct easyMatrix* out) {
    if(in->rows != out->cols) return NULL;
    if(in->cols != out->rows) return NULL;
    int index = 0;
    uint8 x = in->rows;
    uint8 y = in->cols;
    CREATE_DYNAMIC_MATRIX_ONHEAP(x-1,y-1,ret,NULL);
    signed char sign1 = 1;
    signed char sign2 = 1;
    for(uint8 ii=0;ii<x;++ii) {
        sign2 = sign1;
        index = ii;
        for(uint8 jj=0;jj<y;++jj) {
            leftMatrix(ii,jj,in,ret);
            //out->element[jj*y+ii] = sign2*detMatrix(ret);
            out->element[index] = sign2*detMatrix(ret);
            sign2 = - sign2;    
            index+=y;
        }
        
        sign1 = - sign1;
    }
    DELETE_DYNAMIC_MATRIX(ret);
    return out;
}

DATA_TYPE invMatrix(struct easyMatrix *const in , struct easyMatrix * out) {
    if(in->cols!=in->rows) return 0;
    if(in->rows != out->cols) return 0;
    if(in->cols != out->rows) return 0;
    uint8 N = in->cols;
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,L,NULL);
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,LINV,NULL);
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,U,NULL);
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,UINV,NULL);
    getLUMatrix(in,L,U);
    invLMatrix(L,LINV);
    invUMatrix(U,UINV);
    multiMatrix(UINV,LINV,out);
    double s = 1;
    for(int i = 0;i<N;i++) 
        s *= U->element[i*N+i];   
    /*
    adjMatrix(in,out);
    DATA_TYPE scale = detMatrix(in);
    if(scale<1e-5&&scale>-1e-5) return 0.0;
    scale = 1/scale;
    scaleMatrix(scale,out,out);
*/
    DELETE_DYNAMIC_MATRIX(L);
    DELETE_DYNAMIC_MATRIX(U);
    DELETE_DYNAMIC_MATRIX(LINV);
    DELETE_DYNAMIC_MATRIX(UINV);
    return isFiniteNumber(s);
}

struct easyMatrix* getLUMatrix(struct easyMatrix* const A, struct easyMatrix* L,struct easyMatrix* U) {
    int row=0;
    DATA_TYPE s = 0;
    uint8 N = A->cols;
    int t = N*N;
    for(int i =0;i<t;i++) {
        L->element[i] = 1e-20;
        U->element[i] = 1e-20;
    }
    for(int i=0;i<N;i++) {
        L->element[i*N+i] = 1.0;
    }
    for(int i=0;i<N;i++) {
        for(int j=i;j<N;j++) {
            s = 0.0;
            for(int k=0;k<i;++k) {
                s+=L->element[i*N+k]*U->element[k*N+j];
            }
            U->element[i*N+j]= A->element[i*N+j] - s; 
        }
        for (int j = i + 1;j < N;j++) {
            s = 0.0;
            for (int k = 0; k < i; k++)
            {
                s += L->element[j*N+k] * U->element[k*N+i];
            }
            L->element[j*N+i] = (A->element[j*N+i] - s) / U->element[i*N+i];      //按列计算l值
        }
    }
    return L;

}

struct easyMatrix* invLMatrix(struct easyMatrix* const L, struct easyMatrix* L_inv) { 
    uint8 N = L->cols;
    DATA_TYPE s;
    int t = N*N;
    for(int i =0;i<t;i++) {
        L_inv->element[i] = 1e-13;
    }
    for (uint8 i = 0;i < N;i++)  {
        L_inv->element[i*N+i] = 1;
    }
    for (uint8 i= 1;i < N;i++) {
        for (uint8 j = 0;j < i;j++) {
            s = 0;
            for (uint8 k = 0;k < i;k++) {
                s += L->element[i*N+k] * L_inv->element[k*N+j];
            }
            L_inv->element[i*N+j] = -s;
        }
    }
    return L_inv;
}
struct easyMatrix* invUMatrix(struct easyMatrix* const U, struct easyMatrix* U_inv) { 
    uint8 N = U->cols;
    DATA_TYPE s;
    int t = N*N;
    for(int i =0;i<t;i++) {
        U_inv->element[i] = 1e-13;
    }
 for (uint8 i = 0;i < N;i++)                    //按列序，列内按照从下到上，计算u的逆矩阵
    {
        U_inv->element[i*N+i] = 1 / U->element[i*N+i];
    }
    for (uint8 i = 1;i < N;i++) {
        for (int j = i - 1;j >=0;j--) {
            s = 0;
            for (uint8 k = j + 1;k <= i;k++) {
                s += U->element[j*N+k] * U_inv->element[k*N+i];
            }
            U_inv->element[j*N+i] = -s / U->element[j*N+j];
        }
    }
    return U_inv;
}
DATA_TYPE fastDetMatrix(struct easyMatrix* const in) {
    uint8 x = in->rows;
    uint8 y = in->cols;
    if(x!=y) return 0;
    if(x==0 ) return 0;
    if(x==1 ) return in->element[0];
    DATA_TYPE *a =in->element;
    if(x==2) return(a[0]*a[3]-a[1]*a[2]);
    int N = x;
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,L,NULL);
    CREATE_DYNAMIC_MATRIX_ONHEAP(N,N,U,NULL);
    getLUMatrix(in,L,U);
    double s = 1;
    for(int i = 0;i<N;i++) 
        s *= U->element[i*N+i];
    DELETE_DYNAMIC_MATRIX(L);
    DELETE_DYNAMIC_MATRIX(U);
    return s;
}

DATA_TYPE detMatrix(struct easyMatrix* const in) {
    uint8 x = in->rows;
    uint8 y = in->cols;
    if(x!=y) return 0;
    if(x==0 ) return 0;
    if(x==1 ) return in->element[0];
    DATA_TYPE *a =in->element;
    if(x==2) return(a[0]*a[3]-a[1]*a[2]);

    DATA_TYPE result = 0;
    signed char sign = 1;
    CREATE_DYNAMIC_MATRIX_ONHEAP(x-1,y-1,ret,NULL);
    for(uint8 i=0;i<x;++i) {
        leftMatrix(0,i,in,ret);
        result += sign*a[i]*detMatrix(ret);
        sign = - sign;
    }
    DELETE_DYNAMIC_MATRIX(ret);
    return result;
}

struct easyMatrix* addMatrix(const struct easyMatrix* const a,const struct easyMatrix* const b, struct easyMatrix* c) {
    if(a->cols != b->cols) return NULL;
    if(a->rows != b->rows) return NULL;
    struct easyMatrix* obj = (struct easyMatrix*)a;
    int t = obj->rows*obj->cols;
    for(int i=0;i<t;++i) {
        c->element[i] = obj->element[i]+b->element[i];
    }
    return c;
}

struct easyMatrix* subMatrix(struct easyMatrix* const a, struct easyMatrix* const b, struct easyMatrix* c) {
    if(a->cols != b->cols) return NULL;
    if(a->rows != b->rows) return NULL;
    struct easyMatrix* obj = (struct easyMatrix*)a;
    int t = obj->rows*obj->cols;
    for(int i=0;i<t;++i) {
        c->element[i] = obj->element[i]-b->element[i];
    }
    return c;
}

struct easyMatrix* scaleMatrix(DATA_TYPE scale, struct easyMatrix* const a, struct easyMatrix* b) {
    int t = a->cols*a->rows;
    for (int i = 0;i<t;++i) {
        b->element[i] = a->element[i]*scale;
    }
    return b;
}

struct easyMatrix* multiMatrix(struct easyMatrix* const a,struct easyMatrix* const b, struct easyMatrix* c) {
    if(NULL==c) return NULL;
    if(c == a || c == b) return NULL;
    if(a->cols != b->rows) return NULL;
    int count = 0;
    int t_cnt = 0;
    int z_cnt = 0;
    uint8 x = a->rows;
    uint8 y = a->cols;
    uint8 z = b->cols;
    for(uint8 i = 0;i<x;++i) {
        for(uint8 k = 0;k<z;++k) {
            c->element[count] = 0;
            z_cnt = 0;
            for(uint8 j = 0;j<y;++j) {
                c->element[count] += a->element[t_cnt+j]*b->element[z_cnt+k];
                z_cnt += z;
            }
            count++;
        }
        t_cnt+=y;
    }
    return c;
}

struct easyMatrix* zerosMatrix(struct easyMatrix* e) {
    int t = e->cols*e->rows;
    for(int i=0;i<t;++i) {
        e->element[i] = 0;
    }
    return e;
}

struct easyMatrix* eyesMatrix(struct easyMatrix* e) {
    if(e->rows != e->cols) return NULL;
    zerosMatrix(e);
    int index = 0;
    for(uint8 i=0;i<e->rows;++i) {
        e->element[index] = 1.0;
        index+=(e->cols);
        ++index;
    }
    return e;
}

struct easyMatrix* solveEquationMatrix(const struct easyMatrix* const A,const struct easyMatrix* const Y, struct easyMatrix* X) { 
    CREATE_DYNAMIC_MATRIX_ONHEAP(A->rows,A->cols,AINV,NULL);
    invMatrix(A,AINV);
    multiMatrix(AINV,Y,X);
    DELETE_DYNAMIC_MATRIX(AINV);
    return X;
}
void dumpMatrix(struct easyMatrix* const e) {
    int count = 0;
    int x = e->rows;
    int y = e->cols;
    printf("cols is:%d, rows is:%d\n",x,y);
    for(uint8 i = 0;i<x;++i) {
        for(uint8 j = 0;j<y;++j) {
            printf("%8f,",e->element[count]);
            ++count;
        }
        printf("\n");
    }
    return;
}
腾TO的技术输出
关注
专栏目录
C语言矩阵运算库大起底
ZSZ_shsf的博客
11-30 1万+
C语言矩阵运算库
【C C++开源库】C C++矩阵运算开源库_c
2401_84263262的博客
04-12 1244
在条件允许的情况下，可以优先使用eigen矩阵运算库。自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Go语言工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Go语言全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Matrix_hub 矩阵运算库——C语言实现指南
最新发布
gitblog_01004的博客
08-08 534
Matrix_hub 矩阵运算库——C语言实现指南 Matrix_hubA lib of Matrix operation for C language. (矩阵运算库--C语言) 项目地址:https://gitcode.com/gh_mirrors/ma/Matrix_hub 1. 项目介绍 Matrix_hub 是一个由Amoiensis（Yu Xiping）开发的C语言矩阵运算库，它提...
C语言写矩阵库，适合做矩阵运算
09-17
C语言写的矩阵库，适合做矩阵运算的程序调用
Matrix Hub 矩阵运算库 C语言
yxp189的博客
08-09 2205
Matrix_hub 矩阵运算库–C语言 ##The lib of Matrix operation for C language. (矩阵运算库–C语言) Author: Amoiensis Email: Amoiensis@outlook.com Data:2020.02.12 更多资料和信息： https://github.com/Amoiensis/Matrix_hub 源代码下载： 发布：https://github.com/Amoiensis/Matrix_hub/releases/ 下载：
基于C语言的矩阵运算库
Alexon Xu的博客
05-23 1万+
最近本着锻炼自己编程能力的目的，捣鼓了一下矩阵运算，看到网上很多的矩阵运算库都是基于C++的，很少有基于C语言的，于是自己想要写一个纯C语言的矩阵运算库。大神看到了不要喷我，我只是个小白。 个人感觉矩阵运算最重要的是数据结构的安排，我看到有些使用C语言编写的矩阵运算库里面的矩阵元素是使用以为数组存储的，这样的好处是确定了矩阵的行和列，直接将矩阵结构中的指针指向对应的数组即可；其形式如下： ...
C语言矩阵运算库（Light Matrix）
热门推荐
Echo的专栏
08-09 3万+
最近在做卡尔曼滤波和最小二乘的一些算法，都需要运用到矩阵的运算，所以索性就写了个纯C的矩阵库(Light Matrix)，只所以叫Light Matrix，因为目前只包含了矩阵的基本运算，尽量做到短小精悍。目前支持矩阵的加，减，乘，转置，行列式，伴随矩阵和逆矩阵，后续有时间会继续更新，可以关注我的github(https://github.com/zjc666/LightMatrix) 如果发现
【C/C++开源库】C/C++矩阵运算开源库
qq_41854911的博客
08-20 1万+
文章目录一、C++矩阵运算库 - eigen1.下载及安装1.1Linux安装及配置1.2Windows配置2.测试使用2.1DevC++2.2Clion3.深入学习二、C++矩阵运算库 - Armadillo1.下载及安装1.1Linux安装1.2Windows配置2.测试使用3.深入学习三、C++矩阵运算库 - boost四、C语言矩阵运算库 -1.C语言矩阵库12.C语言矩阵库23.C语言矩阵库34.C语言矩阵库45.C语言矩阵库56.C语言矩阵库67.C语言矩阵库78.C语言矩阵库89.C语言矩阵库
纯C语言 实现SVM，VS工程，亲测可用
04-09
标题中的“纯C语言 实现SVM，VS工程”指的是使用C编程语言实现的支持向量机（Support Vector Machine，简称SVM）算法的项目，且该实现是在Microsoft Visual Studio（VS）开发环境中构建的工程。SVM是一种监督学习...
用C语言写的SVM程序
08-18
8. **代码实现**：在C语言中实现SVM，你需要处理数据结构（如样本数组、支持向量数组）、矩阵运算、优化算法（如SMO算法）以及与核函数相关的计算。这涉及到基本的C编程技巧，如动态内存分配、循环和条件判断等。 9...
C语言矩阵运算函数库已详细注释
07-15
调用matrix_test（）；即可测试如下函数， // 创建矩阵 返回矩阵指针 // 创建多个矩阵 返回矩阵指针 // 创建零矩阵 返回矩阵指针 // 创建单位矩阵 返回矩阵指针 // 创建对角矩阵 // 矩阵转变为均匀随机矩阵 // 矩阵转变为正态随机矩阵 // 矩阵加法 A+B=C // 矩阵减法 A-B=C // 矩阵数乘 a*B=C // 矩阵乘法 A*B=C // 向量相乘得矩阵 v1*v2'=M // 矩阵横向拼接 C=[A,B] // 矩阵纵向拼接 C=[A;B] // 矩阵提取 C=A（Rs:Rs+C->row,Cs:Cs+C->column） // 矩阵赋值 C（Rs:Rs+C->row,Cs:Cs+C->column）=A // 矩阵求行列式 // 矩阵求逆 // 矩阵转置 // 矩阵的迹 // 正定矩阵A的Cholesky 分解，输出下三角矩阵 // n行n列矩阵A的LUP分解 // LUP分解解矩阵方程AX=B
C语言矩阵运算库最后版_stm32等嵌入式平台用
10-19
修复log1 已修复矩阵转置函数的致命错误，行列数传入错误 https://blog.csdn.net/shuoyueqishilove/article/details/80427501 工作学习上都需要用到C语言裸机下运算矩阵，找了一些库不是很理想； 浏览了上述博客中博主的程序，发现他 @shuoyueqishilove 写得很清晰， 简明易懂；不过原程序无法直接达到我想在stm32上运行的需求，安全性 也有很多欠缺考虑的地方，于是花费了一点时间在他的算法基础上修改了， 达到了在stm32上跑的要求，测试通过可以使用，其中最重要的求逆运算例程 算出的结果跟原博主的是一样的；
mini数学矩阵运算库 C语言
05-24
本数学矩阵运算库采用C语言编写，可以实现基本的数学矩阵运算，如加减，相乘，求行列式的值，求矩阵的逆等，使用方便。
C语言实现常用的矩阵运算
12-28
C语言实现常用的矩阵运算，其中矩阵的求逆运算提供了两种方法，伴随矩阵法和高斯消元法，随着矩阵的变大，高斯消元法比伴随矩阵的效率越来越高。
矩阵运算 c语言实现_c语言矩阵运算库_
10-02
用于矩阵运算的调用，可以是卡尔曼滤波或者其他应用等等
（收藏向）超齐全常用python库汇总，有备无患！
【CSDN官方推荐】
01-20 2404
前言 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。 PS：如有需要Python学习资料的小伙伴可以加点击下方链接自行获取 python免费学习资料以及群交流解答点击即可加入 Chardet→字符编码探测器，可以自动检测文本、网页、xml的编码。 colorama →主要用来给文本添加各种颜色，并且非常简单易用。 Prettytable→ 主要用于在终端或浏览器端构建格式化的输出。 difflib→ [Python]标准库，计算文本差.
Python机器学习、深度学习库总结（内含大量示例，建议收藏）
m0_54849873的博客
06-12 2423
目前，随着人工智能的大热，吸引了诸多行业对于人工智能的关注，同时也迎来了一波又一波的人工智能学习的热潮，虽然人工智能背后的原理并不能通过短短一文给予详细介绍，但是像所有学科一样，我们并不需要从头开始”造轮子“，可以通过使用丰富的人工智能框架来快速构建人工智能模型，从而入门人工智能的潮流。 人工智能指的是一系列使机器能够像人类一样处理信息的技术；机器学习是利用计算机编程从历史数据中学习，对新数据进行预测的过程；神经网络是基于生物大脑结构和特征的机器学习的计算机模型；深度学习是机器学习的一个子集，它处理大量的非
c语言矩阵运算库源码
12-27
C语言矩阵运算库是一个用C语言编写的库，用于处理矩阵和向量的运算。该库通常包括矩阵的加法、减法、乘法、转置、求逆、行列式计算等基本操作，以及一些高级运算如特征值、特征向量计算等功能。 在矩阵运算库的源码中，通常包括了对矩阵和向量的定义和数据结构的实现，以及各种操作的具体算法实现。比如矩阵乘法可以通过嵌套循环实现，矩阵的转置可以通过临时变量实现行列的互换，矩阵求逆可以通过高斯-约当消元法等算法来实现。 该库的源码通常会采用模块化的设计，将矩阵和向量的操作划分为不同的函数或模块，以方便用户进行调用和扩展。同时，为了提高运算效率，源码中通常会使用一些优化技巧，比如矩阵的存储方式可以采用行优先或列优先存储，以便于内存访问的连续性。 此外，好的矩阵运算库源码应该包括详细的注释和文档，方便用户理解和使用。另外，还需要进行充分的测试和优化，以确保库的稳定性和性能。 总的来说，C语言矩阵运算库源码是一个重要的工具库，它能够帮助程序员在C语言环境下进行矩阵和向量运算，是许多科学计算和工程应用中不可或缺的一部分。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值