精华内容
下载资源
问答
  • 矩阵运算C语言初学者)
    2021-11-26 15:51:39

    【问题描述】
    对于多个N阶矩阵,依次进行加、减运算。

    【输入形式】
    从标准输入读取输入。第一行只有一个整数N(1≤N≤10),代表矩阵的阶数。
    接下来是一个矩阵,是N行,每行有N个整数(可能是正、负整数),是矩阵的所有元素。
    然后一行只含一个字符"+"或"-",代表加、减操作。
    然后用同样的方式输入另一个矩阵。
    后续仍然是运算符和矩阵。直至运算符为"#"时停止计算,将结果输出。

    【输出形式】
    向标准输出打印矩阵的操作结果。输出N行,每行对应矩阵在该行上的所有元素,每一行末均输出一个回车符。每个元素占5个字符宽度(包括负号),向右对齐,不足部分补以空格。
     

    #include<stdio.h>
    #define N 20
    int main()
    {
    	int a[N][N],b[N][N];
    
    	int i,j,n;
    	
    	char op;
    
    	scanf("%d",&n);
    
    	for(i=0;i<n;i++)
    		for(j=0;j<n;j++)
    			scanf("%d",&b[i][j]);//先读入一个数组
    	
    		scanf("%c",&op);
    	
    	while(op!='#')
    	{
    	
    		for(i=0;i<n;i++)
    			for(j=0;j<n;j++)
    				scanf("%d",&a[i][j]);
    
    		switch(op)
    		{
    
    		case'+':	for(i=0;i<n;i++)
    						for(j=0;j<n;j++)
    							b[i][j]=b[i][j]+a[i][j];//进行矩阵加减运算
    						break;
    		case'-':	for(i=0;i<n;i++)
    						for(j=0;j<n;j++)
    							b[i][j]=b[i][j]-a[i][j];
    						break;
    		}
    
    		scanf("%c",&op);
    
    	}
    		
    	for(i=0;i<n;i++)
    		
    	{	
    		for(j=0;j<n;j++)	
    			printf("%5d",b[i][j]);
    		
    		printf("\n");
    	}
    
    	return 0;
    }

    更多相关内容
  • 矩阵运算 c语言编程

    2021-05-26 10:35:13
    C语言实现矩阵转置、求逆阵、矩阵加减乘除法#include #include #include #include #include void init(int *a,int m,int n){//随机产生函数srand(time(NULL));int i,j;for(i=0;i{for(j=0;j*(a+i*n+j)=rand()%10+1;}}...

    C语言实现矩阵转置、求逆阵、矩阵加减乘除法

    #include

    #include

    #include

    #include

    #include

    void init(int *a,int m,int n)

    {//随机产生函数

    srand(time(NULL));

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(a+i*n+j)=rand()%10+1;

    }

    }

    void input(int *a,int m,int n)

    {//用户输入函数

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    scanf("%d",a+i*n+j);

    }

    }

    void choose(int *a,int m,int n)

    {//是随机产生还是用户输入

    int i;

    printf("是想输入矩阵(输入0)还是随机产生(输入1):\n");

    scanf("%d",&i);

    switch(i)

    {

    case 1:init(a,m,n);

    break;

    case 0:printf("请输入%d个数\n",m*n);

    input(a,m,n);

    break;

    default:printf("你的输入有误,请重新输入:\n");

    break;

    }

    }

    void print(int *a,int m,int n)

    {//打印函数

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    printf("%4d",*(a+i*n+j));

    printf("\n");

    }

    }

    //矩阵关于y轴翻转

    void juzheny(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*n+j)=*(a+i*n+n-j-1);

    }

    }

    //矩阵关于x轴翻转

    void juzhenx(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*n+j)=*(a+(m-i-1)*n+j);

    }

    }

    //顺时针旋转90°,逆时针旋转270°

    void juzhens(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*m+j)=*(a+(m-j-1)*n+i);

    }

    }

    //逆时针旋转90°,顺时针旋转270°

    void juzhenn(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*m+j)=*(a+j*n+(n-i-1));

    }

    }

    // 顺/逆时针旋转180°

    void juzhens1(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*n+j)=*(a+(m-i-1)*n+n-j-1);

    }

    }

    //矩阵转置

    void juzhenzz(int *a,int *b,int m,int n)

    {

    int i,j;

    for(i=0;i

    {

    for(j=0;j

    *(b+i*m+j)=*(a+j*n+i);

    }

    }

    //任意修改矩阵的元素值

    void juzhenyz(int *a,int i,int j,int x,int m,int n)

    {

    *(a+i*n+j)=x;

    }

    void jiemian()

    {

    int i;

    for(i=0;i<80;i++)

    printf("*");

    printf("\n");

    printf(" ");

    }

    void menu()

    {//菜单界面初始化

    int i;

    for(i=1;i<3;i++)

    printf("\n");

    printf("\n关于一些矩阵方面的应用!\n");

    for(i=0;i<80;i++)

    printf("=");

    printf("\n0.查询矩阵中元素所在的行号和列号。 1.任意修改矩阵的元素值。\n");

    printf("\n2.矩阵转置。 3.矩阵关于y轴翻转。 4.矩阵关于x轴翻转。\n");

    printf("\n5.矩阵顺或逆时针旋转90°或逆或顺时针旋转270°。 \n");

    printf("\n6.矩阵旋转180°。7.删除矩阵中该元素所在的行和列,得到了新的二维数组。\n");

    printf("\n8.矩阵的逆矩阵。9.矩阵对应行列式的值。10.求矩阵的伴随矩阵。 11.退出系统. \n");

    for(i=0;i<80;i++)

    printf("=");

    printf("\n");

    }

    int zhanghao()//用户输入用户名账号和密码

    {

    char str1[80],str2[80],

    展开全文
  • 矩阵运算,包含加法、数乘、两个矩阵相乘。在kile环境下编写,单片机编程直接可用。C编写。包含h文件和C文件。
  • C语言实现常用的矩阵运算,其中矩阵的求逆运算提供了两种方法,伴随矩阵法和高斯消元法,随着矩阵的变大,高斯消元法比伴随矩阵的效率越来越高。
  • 矩阵运算 c语言实现
  • 矩阵运算C语言实现

    2015-11-25 12:26:14
    控制台中实现矩阵运算的小软件,C语言实现的
  • C语言矩阵运算

    2021-10-30 23:06:27
    这是一个用C语言编写的矩阵运算头文件,话不多说,上代码 matrix.h /** * File name: matrix.h * Author: Tiancai Xu * Version: 1.0 * Data: 2021-10-29 * Copyright: 2021.10, Tiancai Xu * This file ...

    这是一个用C语言编写的矩阵运算头文件,话不多说,上代码

    matrix.h

    /**
     * File name: matrix.h
     * Author: Tiancai Xu
     * Version: 1.0
     * Data: 2021-10-29
     * Copyright: 2021.10, Tiancai Xu
     * This file defines the matrix and its basic operations
     * This file is for study or reference only
    */
    
    #ifndef _STDARG_H
    #include <stdarg.h>
    #endif // _STDARG_H
    
    #ifndef _STDIO_H
    #include <stdio.h>
    #endif // _STDIO_H
    
    #ifndef _STDLIB_H
    #include <stdlib.h>
    #endif // _STDLIB_H
    
    #ifndef _TIME_H
    #include <time.h>
    #endif // _TIME_H
    
    #ifndef _MATRIX_H
    #define _MATRIX_H
    
    #define size_m unsigned int
    
    /**< Matrix variable */
    typedef struct
    {
        double** M; /**< Data of Matrix */
        size_m row; /**< The number of row */
        size_m col; /**< The number of column */
    } Matrix;
    /**< Tips: This format is recommended for declarations: Matrix M = {NULL, 0, 0}; */
    
    Matrix from(double* arr, size_m row, size_m col);
    Matrix zeros(size_m row, size_m col);
    Matrix ones(size_m row, size_m col);
    Matrix diag(int order, ...);
    Matrix diag_M(Matrix A);
    Matrix iden(int order);
    Matrix randM(size_m row, size_m col);
    Matrix add(Matrix A, Matrix B);
    Matrix sub(Matrix A, Matrix B);
    Matrix mult_MM(Matrix A, Matrix B);
    Matrix mult_kM(double k, Matrix B);
    Matrix T(Matrix A);
    Matrix inv(Matrix A);
    Matrix cof(Matrix A, int r, int c);
    double mode(Matrix A);
    void scanM(Matrix* A);
    void printM(Matrix A);
    void clearM(Matrix* A);
    
    #endif // _MATRIX_H
    

    matrix.c

    /**
     * File name: matrix.c
     * Author: Tiancai Xu
     * Version: 1.0
     * Data: 2021-10-29
     * Copyright: 2021.10, Tiancai Xu
     * This file includes the implementation of the functions declarated in matrix.h
     * This file is for study or reference only
    */
    
    #include "matrix.h"
    
    /** \brief Create a block of 2-D array memory
     *
     * \param row The number of row
     * \param col The number of column
     * \return M 2-D array pointer
     *
     */
    static double** getM(size_m row, size_m col)
    {
        int i;
        double** M;
    
        M = (double**)malloc(sizeof(double*) * row);
    
        for (i = 0; i < row; i++)
            *(M + i) = (double*)malloc(sizeof(double) * col);
    
        return M;
    }
    
    /** \brief Transform a 2-D array to Matrix
     *
     * \param arr The first adress of the a-D array
     * \param row The number of row
     * \param col The number of column
     * \return M Matrix
     *
     * For a 2-D array arr[r][c], use from((double*)arr,r,c) to avoid the gcc compiler warning
     */
    Matrix from(double* arr, size_m row, size_m col)
    {
        int i, j;
        Matrix M;
        M.row = row;
        M.col = col;
        M.M = getM(row, col);
    
        for (i = 0; i < row; i++)
            for (j = 0; j < col; j++)
                M.M[i][j] = *(arr + i * col + j);
    
        return M;
    }
    
    /** \brief Create a zeros Matrix
     *
     * \param row The number of row
     * \param col The number of column
     * \return M Matrix
     *
     */
    Matrix zeros(size_m row, size_m col)
    {
        int i, j;
        Matrix M;
        M.row = row;
        M.col = col;
        M.M = getM(row, col);
    
        for (i = 0; i < row; i++)
            for (j = 0; j < col; j++)
                M.M[i][j] = 0;
    
        return M;
    }
    
    /** \brief Create a ones Matrix
     *
     * \param row The number of row
     * \param col The number of column
     * \return M Matrix
     *
     */
    Matrix ones(size_m row, size_m col)
    {
        int i, j;
        Matrix M;
        M.row = row;
        M.col = col;
        M.M = getM(row, col);
    
        for (i = 0; i < row; i++)
            for (j = 0; j < col; j++)
                M.M[i][j] = 1;
    
        return M;
    }
    
    /** \brief Create a diagonal Matrix
     *
     * \param order The order of the Matrix
     * \return M Matrix
     *
     */
    Matrix diag(int order, ...)
    {
        int i;
        va_list valist;
        Matrix M;
        M = zeros(order, order);
    
        va_start(valist, order);
    
        for (i = 0; i < order; i++)
            M.M[i][i] = va_arg(valist, double);
    
        return M;
    }
    
    /** \brief Create a diagonal Matrix
     *
     * \param A It's a row or column vector
     * \return M Matrix
     *
     */
    Matrix diag_M(Matrix A)
    {
        int i, order;
        Matrix M;
        order = A.row * A.col;
        M = zeros(order, order);
    
        if (A.row == 1)
            for (i = 0; i < order; i++)
                M.M[i][i] = A.M[0][i];
        else if (A.col == 1)
            for (i = 0; i < order; i++)
                M.M[i][i] = A.M[i][0];
        else
        {
            fprintf(stderr, "Error: Arguments must be a row or column vector.\n");
            exit(-1);
        }
    
        return M;
    }
    
    /** \brief Create a identity Matrix
     *
     * \param order The order of the Matrix
     * \return M Matrix
     *
     */
    Matrix iden(int order)
    {
        int i;
        Matrix M;
        M = zeros(order, order);
    
        for (i = 0; i < order; i++)
            M.M[i][i] = 1;
    
        return M;
    }
    
    /** \brief Create a random Matrix between 0 and 1.0
     *
     * \param row The number of row
     * \param col The number of column
     * \return M Matrix
     *
     */
    Matrix randM(size_m row, size_m col)
    {
        time_t t;
        int i, j;
        Matrix M = zeros(row, col);
        srand((unsigned) time(&t));
    
        for (i = 0; i < row; i++)
            for (j = 0; j < col; j++)
                M.M[i][j] = ((double) rand()) / ((double)RAND_MAX);
        return M;
    }
    
    /** \brief Matrix addition
     *
     * \param A Matrix
     * \param B Matrix
     * \return M Matrix, M = A + B
     *
     */
    Matrix add(Matrix A, Matrix B)
    {
        if (!(A.row == B.row && A.col == B.col))
        {
            fprintf(stderr, "Error: The two matrices must have the same size.\n");
            exit(-1);
        }
    
        int i, j;
        Matrix M;
        M.row = A.row;
        M.col = A.col;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
                M.M[i][j] = A.M[i][j] + B.M[i][j];
    
        return M;
    }
    
    /** \brief Matrix subtraction
     *
     * \param A Matrix
     * \param B Matrix
     * \return M Matrix, M = A - B
     *
     */
    Matrix sub(Matrix A, Matrix B)
    {
        if (!(A.row == B.row && A.col == B.col))
        {
            fprintf(stderr, "Error: The two matrices must have the same size.\n");
            exit(-1);
        }
    
        int i, j;
        Matrix M;
        M.row = A.row;
        M.col = A.col;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
                M.M[i][j] = A.M[i][j] - B.M[i][j];
    
        return M;
    }
    
    /** \brief Matrix multiplication
     *
     * \param A Matrix
     * \param B Matrix
     * \return M Matrix, M = A * B
     *
     */
    Matrix mult_MM(Matrix A, Matrix B)
    {
        if (A.col != B.row)
        {
            fprintf(stderr, "Error: The number of columns in matrix A must be equal to the number of rows in matrix B.\n");
            exit(-1);
        }
    
        int i, j, k;
        Matrix M;
        M.row = A.row;
        M.col = B.col;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
            {
                M.M[i][j] = 0;
    
                for (k = 0; k < A.col; k++)
                    M.M[i][j] += A.M[i][k] * B.M[k][j];
            }
    
        return M;
    }
    
    /** \brief Matrix multiplication
     *
     * \param k Real number
     * \param A Matrix
     * \return M Matrix, M = k * A
     *
     */
    Matrix mult_kM(double k, Matrix B)
    {
        int i, j;
        Matrix M;
        M.row = B.row;
        M.col = B.col;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
                M.M[i][j] = k * B.M[i][j];
    
        return M;
    }
    
    /** \brief Matrix transpose
     *
     * \param A Matrix
     * \return M Matrix, M = A^T
     *
     */
    Matrix T(Matrix A)
    {
        int i, j;
        Matrix M;
        M.row = A.col;
        M.col = A.row;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
                M.M[i][j] = A.M[j][i];
    
        return M;
    }
    
    /** \brief Matrix inversion
     *
     * \param A Matrix
     * \return M Inverse Matrix, M = A^-1
     *
     */
    Matrix inv(Matrix A)
    {
        if (A.row != A.col)
        {
            fprintf(stderr, "Error: The matrix must be square.\n");
            exit(-1);
        }
    
        int m = mode(A);
    
        if (m == 0)
        {
            fprintf(stderr, "Error: The inverse of the target matrix does not exist.\n");
            exit(-1);
        }
    
        int i, j, s;
        Matrix M, temp;
        M.row = A.row;
        M.col = A.col;
        M.M = getM(M.row, M.col);
    
        for (i = 0; i < M.row; i++)
            for (j = 0; j < M.col; j++)
            {
                temp = cof(A, i, j);
                s = (i + j) % 2 == 0 ? 1 : -1;
                M.M[j][i] = s * mode(temp) / m;
                clearM(&temp);
            }
    
        return M;
    }
    
    /** \brief Complementary minor, cofactor
     *
     * \param A Matrix
     * \param r The index of row
     * \param c The index of column
     * \return M The cofactor Matrix M[r][c]
     *
     */
    
    Matrix cof(Matrix A, int r, int c)
    {
        if (A.row != A.col)
        {
            fprintf(stderr, "Error: The matrix must be square.\n");
            exit(-1);
        }
    
        if (r < 0 || r > A.row)
        {
            fprintf(stderr, "Error: Out of matrix index range.(r)\n");
            exit(-1);
        }
    
        if (c < 0 || c > A.col)
        {
            fprintf(stderr, "Error: Out of matrix index range.(c)\n");
            exit(-1);
        }
    
        int i, j, m, n;
        Matrix M;
        M.row = A.row - 1;
        M.col = A.col - 1;
        M.M = getM(M.row, M.col);
    
        for (i = 0, m = 0; i < A.row; i++)
        {
            if (i == r)
                continue;
    
            for (j = 0, n = 0; j < A.col; j++)
            {
                if (j == c)
                    continue;
    
                M.M[m][n] = A.M[i][j];
                n++;
            }
    
            m++;
        }
    
        return M;
    }
    
    /** \brief Get the mode of Matrix
     *
     * \param A Matrix
     * \return result The mode, result = |A|
     *
     */
    double mode(Matrix A)
    {
        if (A.row != A.col)
        {
            fprintf(stderr, "Error: The matrix must be square.\n");
            exit(-1);
        }
    
        if (A.row == 1)
            return A.M[0][0];
    
        double result;
        int i, s;
        Matrix M;
    
        for (result = 0, i = 0; i < A.row; i++)
        {
            s = i % 2 == 0 ? 1 : -1;
            M = cof(A, i, 0);
            result += A.M[i][0] * s * mode(M);
            clearM(&M);
        }
    
        return result;
    }
    
    /** \brief Input a Matrix
     *
     * \param A Matrix pointer
     * \return void
     *
     */
    void scanM(Matrix* A)
    {
        int i, j;
    
        if (A->M == NULL)
        {
            printf("Enter the number of row&column, e.g. 5,5: ");
            scanf("%u,%u", &A->row, &A->col);
        }
    
        for (i = 0; i < A->row; i++)
            for (j = 0; j < A->col; j++)
            {
                printf("Enter M(%d,%d): ", i, j);
                scanf("%lf", &A->M[i][j]);
            }
    }
    
    /** \brief Print a Matrix
     *
     * \param A Matrix
     * \return void
     *
     */
    void printM(Matrix A)
    {
        int i, j;
    
        for (i = 0; i < A.row; i++)
        {
            for (j = 0; j < A.col; j++)
                printf("%-10.4g ", A.M[i][j]);
    
            printf("\n");
        }
    }
    
    /** \brief Clear a Matrix
     *
     * \param A Matrix pointer
     * \return void
     *
     * To release occupied memory
     */
    void clearM(Matrix* A)
    {
        int i;
    
        if (A->M != NULL)
        {
            for (i = 0; i < A->row; i++)
                free(A->M[i]);
    
            free(A->M);
        }
    
        A->M = NULL;
        A->row = 0;
        A->col = 0;
    }
    

    测试用test.c

    /**< IDE: Code::Blocks 20.03 64bit */
    #include <stdio.h>
    #include "matrix.h"
    
    int main()
    {
        Matrix M = {NULL, 0, 0};
        Matrix M1 = {NULL, 0, 0};
        Matrix M2 = {NULL, 0, 0};
    
        printf("/*****************************/\n");
    
        printf("\nM = zeros(2, 3)\n");
        M = zeros(2, 3);
        printM(M);
        clearM(&M);
    
        printf("\n/*****************************/\n");
    
        printf("\nM = ones(3, 2)\n");
        M = ones(3, 2);
        printM(M);
        clearM(&M);
    
        printf("\n/*****************************/\n");
    
        printf("\nM = iden(3)\n");
        M = iden(3);
        printM(M);
        clearM(&M);
    
        printf("\n/*****************************/\n");
    
        printf("\nM = diag(3, 1.0, 2.0, 3.1)\n");
        M = diag(3, 1.0, 2.0, 3.1);
        printM(M);
        clearM(&M);
    
        printf("\n/*****************************/\n");
    
        printf("\nM = randM(2, 2)\n");
        M = randM(2, 2);
        printM(M);
        clearM(&M);
    
        printf("\n/*****************************/\n");
    
        printf("\nM = from((double*)arr, 2, 3)\n");
        double arr[3][3] = {{1.0, 2.0, 3.0}, {2.0, 2.0, 1.0}, {3.0, 4.0, 3.0}};
        M = from((double*)arr, 3, 3);
        printM(M);
        M1 = T(M);
        printf("\nM1 = T(M)\n");
        printM(M1);
        printf("\nM2 = mult_MM(M1, M)\n");
        M2 = mult_MM(M1, M);
        printM(M2);
        clearM(&M1);
        clearM(&M2);
        printf("\nM1 = inv(M)\n");
        M1 = inv(M);
        printM(M1);
        printf("\nM1 = mult_MM(M, M1)\n");
        M2 = mult_MM(M, M1);
        printM(M2);
        clearM(&M);
        clearM(&M1);
        clearM(&M2);
    
        printf("\n/*****************************/\n");
    
        return 0;
    }
    

    展开全文
  • 工作学习上都需要用到C语言裸机下运算矩阵,找了一些库不是很理想; 浏览了上述博客中博主的程序,发现他 @shuoyueqishilove 写得很清晰, 简明易懂;不过原程序无法直接达到我想在stm32上运行的需求,安全性 也有很...
  • C语言实现矩阵运算

    万次阅读 多人点赞 2019-09-04 21:28:06
    最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之 一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵; 矩阵的结构体: typedef struct...

    最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之
    首先声明该代码在Ubuntu18.04下运行通过, 如若在windows下运行失败请考虑编译器版本问题

    一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的结构体变量来表示一个矩阵;
    矩阵的结构体:

    typedef struct 
    {
    	int row,line;			//line为行,row为列
    	double *data;
    }Matrix;
    

    这样在创建一个矩阵的时候只需要分配row,line和data的内存就好.
    然后…好像也没啥好说的… 直接根据所学矩阵的基本运算只是写代码就好…

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    double value[] = {1,2,3,4,5,6,7,8,9};
    double value2[] = {9,8,7,6,5,4,3,2,1};
    
    typedef struct 
    {
    	int row,line;		//line为行,row为列
    	double *data;
    }Matrix;
    
    Matrix* InitMatrix(Matrix *matrix,int row,int line);		//初始化矩阵
    void ValueMatrix(Matrix *matrix,double *array);				//给一个矩阵赋值
    int SizeMatrix(Matrix *matrix);								//获得一个矩阵的大小
    void FreeMatrix(Matrix *matrix);							//释放一个矩阵
    void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B);		//复制一个矩阵的值
    void PrintMatrix(Matrix *matrix);							//打印一个矩阵
    
    //矩阵的基本运算
    Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的加法
    Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B);		//矩阵的乘法
    void TransMatrix(Matrix *matrix);			//条件为方阵
    
    int main(int argc,char* argv[])
    {
    	Matrix *matrix1 = InitMatrix(matrix1,3,3);
    	Matrix *matrix2 = InitMatrix(matrix2,3,3);
    
    	ValueMatrix(matrix1,value);
    	// CopyMatrix(matrix1,matrix2);	//复制赋值
    	ValueMatrix(matrix2,value2);
    
    	printf("矩阵1 乘以 矩阵2: \n");
    	Matrix *matrix3 = MulMatrix(matrix1,matrix2);	//乘法
    	PrintMatrix(matrix3);	
    	printf("矩阵1 加上 矩阵2: \n");
    	Matrix *matrix4 = AddMatrix(matrix1,matrix2);	//加法
    	PrintMatrix(matrix4);
    	printf("矩阵1进行转置: \n");
    	TransMatrix(matrix1);					//转置
    	PrintMatrix(matrix1);
    	
    	return 0;
    }
    
    Matrix* InitMatrix(Matrix *matrix,int row,int line)				//初始化一个矩阵
    {
    	if (row>0 && line>0)
    	{
    		matrix = (Matrix*)malloc(sizeof(Matrix));
    		matrix->row = row;
    		matrix->line = line;
    		matrix->data = (double*)malloc(sizeof(double)*row*line);
    		memset(matrix->data,0,sizeof(double)*row*line);
    		return matrix;
    	}
    	else 
    		return NULL;
    } 
    
    void ValueMatrix(Matrix *matrix,double *array) 		//给矩阵赋值
    {
    	if (matrix->data != NULL)
    	{
    		memcpy(matrix->data, array, matrix->row*matrix->line*sizeof(double));
    	}
    }
    
    int SizeMatrix(Matrix *matrix)
    {
    	return matrix->row*matrix->line;
    }
    
    void FreeMatrix(Matrix *matrix)
    {
    	free(matrix->data);		//释放掉矩阵的data存储区
    	matrix->data = NULL;
    	printf("释放成功\n");
    }
    
    void CopyMatrix(Matrix *matrix_A, Matrix *matrix_B)
    {
    	matrix_B->row = matrix_A->row;
    	matrix_B->line = matrix_A->line;
    	memcpy(matrix_B->data, matrix_A->data, SizeMatrix(matrix_A)*sizeof(double));
    }
    
    void PrintMatrix(Matrix *matrix)
    {
    	for (int i=0;i<SizeMatrix(matrix);i++)
    	{
    		printf("%lf\t", matrix->data[i]);
    		if ((i+1)%matrix->line == 0)
    			printf("\n");
    	}
    			
    }
    //加法
    Matrix* AddMatrix(Matrix *matrix_A,Matrix *matrix_B)
    {
    	if (matrix_A->row == matrix_B->row && matrix_A->line == matrix_B->line)
    	{
    		Matrix *matrix_C = InitMatrix(matrix_C,matrix_A->row,matrix_A->line);
    		for (int i=0;i<matrix_A->line;i++)
    		{
    			for (int j=0;j<matrix_A->row;j++)
    			{
    				matrix_C->data[i*matrix_C->row + j] = \
    				matrix_A->data[i*matrix_A->row + j] + matrix_B->data[i*matrix_A->row + j];
    			}
    		}
    		return matrix_C;
    	}
    	else 
    	{
    		printf("不可相加\n");
    		return NULL;
    	}
    }
    
    //乘法
    Matrix* MulMatrix(Matrix *matrix_A,Matrix *matrix_B)
    {
    	if (matrix_A->row == matrix_B->line)		//列==行
    	{
    		Matrix *matrix_C = InitMatrix(matrix_C,matrix_B->row,matrix_A->line);
    		// matrix_C->line = matrix_A->line;		//A行
    		// matrix_C->row = matrix_B->row;			//B列
    		for (int i=0;i<matrix_A->row;i++)
    		{
    			for (int j=0;j<matrix_B->line;j++)
    			{
    				for (int k=0;k<matrix_A->line;k++)
    				{
    					matrix_C->data[i*matrix_C->line + j] += \
    					matrix_A->data[i*matrix_A->line + k] * matrix_B->data[k*matrix_B->row + j];
    				}
    			}
    		}
    		return matrix_C;
    	}
    	else
    	{
    		printf("不可相乘\n");
    		return NULL;
    	}
    }
    
    //矩阵转置
    void TransMatrix(Matrix *matrix)			//条件为方阵
    {
    	if (matrix->row == matrix->line)
    	{
    		Matrix *matrixTemp = InitMatrix(matrixTemp, matrix->row,matrix->line);       	//创建一个临时矩阵
    		CopyMatrix(matrix,matrixTemp);	//将目标矩阵的data复制给临时矩阵
    
    		for (int i=0;i<matrix->row;i++)
    		{
    			for (int j=0;j<matrix->line;j++)
    			{
    				matrix->data[i*matrix->row + j] = matrixTemp->data[j*matrix->row + i];
    			}
    		}
    	}
    	else
    	{
    		printf("转置的矩阵必须为方阵\n");
    	}
    }
    
    

    恩…都是代码…尽情享用吧!

    展开全文
  • 矩阵运算C语言实现

    2014-05-29 22:34:17
    C语言实现了常用的矩阵运算 包括加、减、乘法、求逆、转置等运算
  • c语言实现矩阵运算

    千次阅读 2020-06-12 20:08:49
    1.一个矩阵要有的信息包括它的行数列数以及每一个元素的信息,所以我们设置了一个结构体来包含这些信息,结构体的成员就是整型的行数和列数和一个表示元素内容的二级指针。其中二级指针比较难以理解,二级指针是指向...
  • PTA-矩阵运算C语言

    万次阅读 多人点赞 2018-11-11 20:27:20
    #include &lt;stdio.h&gt; int main(){ int n,sum=0; scanf("%d",&amp;n); int mov[n][n]; for(int i=0;i&lt;n;i++) for(int j=0;j&lt;n;j++) scanf("... ...
  • 本数学矩阵运算库采用C语言编写,可以实现基本的数学矩阵运算,如加减,相乘,求行列式的值,求矩阵的逆等,使用方便。
  • 鉴于c语言的广泛运用,本人在此自己编写了基本的矩阵运算C语言实现,希望与大家一起享用
  • 关于稀疏矩阵的加、减、乘的代码,数据结构中用的。写得感觉一般,但可以运行,仅供参考。
  • c语言实现矩阵及其运算,gcc编译器
  • 编写矩阵运算程序(C语言)

    千次阅读 多人点赞 2020-06-22 08:24:26
    a) 功能包括:矩阵加、矩阵减、矩阵乘、矩阵三角化 b) 实现方式1:函数的参数为:二维数组名、行数、列数
  • //任务二矩阵的基本运算 #include<stdio.h> #include<stdlib.h> #define R1 4//矩阵 MA 行数可以按具体情况修改 #define C1 4//矩阵 MA 列数可以按具体情况修改 #define R2 4//矩阵 MB 行数可以按具体情况修改 #...
  • 完全基于C语言的基础矩阵运算库(无稀疏矩阵和多线程支持) 头文件仅声明函数,函数体位于 src/*.c 中,如需简化include步骤,可将 src/*.c 文件中内容粘贴到headers/*.h 末尾。 basicCalculation.c & .h ...
  • C语言实现常见的矩阵运算函数

    万次阅读 多人点赞 2015-12-19 15:58:24
    C语言 矩阵转置函数 矩阵加(减)法函数 矩阵乘法函数 矩阵求逆函数 矩阵乔里斯基分解函数
  • 有关矩阵运算的大量C语言原代码,非常有参考价值的,值得使用。
  • c语言矩阵运算程序

    2012-09-14 22:37:22
    c语言矩阵运算程序,简单的加减乘除运算,用c语言实现
  • 矩阵运算——C语言实现PAGE2 / NUMPAGES53#include "stdafx.h"#include //结构体typedef struct{double ** mat;int row;int col;}Matrix;void InitialMatrix(Matrix *T, int row,int col); //只分配空间不初始化;...
  • 代码://矩阵计算器#include void getmatrix(int m, int n, double m1[][n], double m2[][m]);void calculate(int m, int n, double m1[][n], double m2[][m], double ansm[][m]);void display(int m, int n, double...
  • N*N内递矩阵算法 如图就是一个n*n内递矩阵,如何去创建他呢? 首先,我们知道如图的5*5(N*N)内递矩阵由外而内是有3(m)层,第一个圈圈都为1,内二圈圈都为2,内三圈圈都为3. 我们可以仔细观察 并 用笔把他对应的...
  • 设计最后得分优秀,而且免答辩。 代码清晰易懂,你绝对值得拥有。
  • 按照教科书《数据结构(C语言版)》(严蔚敏等)5.3.2节中描述的方法,以十字链表表示稀疏矩阵。一、需求分析稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进修学校储存和计算可以大大节省储存空间,提高计算...
  • 利用c语言实现的矩阵的加减乘除和求逆运算,具体参见附件,已经在vc++6.0上调试通过。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,480
精华内容 7,392
关键字:

矩阵运算c语言