C语言实现矩阵

已于 2022-08-19 12:15:06 修改
阅读量1.3w 收藏 126
点赞数 24
文章标签： c语言 线性代数 算法
于 2021-08-19 15:14:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hunhunee666/article/details/119802718
版权

概述

        加法、减法、乘法

        转置

        行变换

        行阶梯型

        矩阵的秩

        方阵的行列式

        逆矩阵

头文件

        注：当需要改变矩阵内容时使用指针，其他情况下不使用指针

#include<stdlib.h>
#include<stdio.h>
#include<math.h>

typedef struct{
    int row;            // 行
    int col;            // 列
    float **matrix;     // 元素
}matrix;

void create(matrix *m, int row, int col);                       // 创建
void free_matrix(matrix *m);                                           // 释放
void init_matrix(matrix *m);                                    // 初始化
matrix add(matrix A, matrix B);                                 // 加法
matrix sub(matrix A, matrix B);                                 // 减法
matrix multiply(matrix A, matrix B);                            // 乘法
void transpose(matrix *m);                                      // 转置
void row_trans_swap(matrix *m, int i, int j);                   // 交换两行(行和列从0开始)
void row_trans_sub(matrix *m, int i, int j, float multiple);    // 两行相减(第i行减去第j行的multiple倍)
void row_echelon(matrix *m);                                    // 将矩阵转换为行阶梯型
void col_trans_swap(matrix *m, int i, int j);                   // 交换两列(行和列从0开始)
void col_trans_sub(matrix *m, int i, int j, float multiple);    // 两列相减(第i列减去第j列的mutliple倍)
void col_echelon(matrix *m);                                    // 将矩阵转换为列阶梯型
int rank(matrix m);                                             // 求矩阵的秩
int inversion_number(int array[], int N);                       // 逆序数
float det(matrix m);                                            // 计算方阵的行列式
float confactor(matrix m, int i, int j);                        // 求余子式(行和列从0开始)
float algebraic_confactor(matrix m, int i, int j);              // 求代数余子式(行和列从0开始)
matrix inverse(matrix m);                                       // 求逆矩阵
void print_matrix(matrix m);                                    // 输出


void create(matrix *m, int row, int col){   
    // 声明一个矩阵
    m->row = row;
    m->col = col;
    m->matrix = (float **)malloc(sizeof(float *)*m->row);
    for(int i = 0; i < m->row; i++){
        m->matrix[i] = (float *)malloc(sizeof(float)*m->col);
    }  
    for(int i = 0; i < m->row; i++){
        for(int j = 0; j < m->col; j++){
            // 初始化为0
            m->matrix[i][j] = 0;
        }
    }  
}

void free_matrix(matrix *m){
    for(int i = 0; i < m->row; i++){
        free(m->matrix[i]);
        m->matrix[i] = NULL;
    }
    free(m->matrix);
    m->matrix = NULL;
}

void init_matrix(matrix *m){
    // 初始化矩阵
    printf("matrix(%d, %d)  input element:\n", m->row, m->col);
    for(int i = 0; i < m->row; i++){
        for(int j = 0; j < m->col; j++){
            scanf("%f", &m->matrix[i][j]);
        }
    } 
}

matrix add(matrix A, matrix B){
    // 判断矩阵A和矩阵B是否为同型矩阵
    if(A.row != B.row || A.col != B.col){
        printf("size error, matrix A's column(row) doesn't equal to matrix B's column(row)");
        exit(0);
    }
    // 计算结果并返回
    matrix result;
    create(&result, A.row, A.col);
    for(int i = 0; i < result.row; i++){
        for(int j = 0; j < result.col; j++){
            result.matrix[i][j] += A.matrix[i][j] + B.matrix[i][j]; 
        }
    }
    return result;
}

matrix sub(matrix A, matrix B){
    // 判断矩阵A和矩阵B是否为同型矩阵
    if(A.row != B.row || A.col != B.col){
        printf("size error, matrix A's column(row) doesn't equal to matrix B's column(row)");
        exit(0);
    }
    // 计算结果并返回
    matrix result;
    create(&result, A.row, A.col);
    for(int i = 0; i < result.row; i++){
        for(int j = 0; j < result.col; j++){
            result.matrix[i][j] += A.matrix[i][j] - B.matrix[i][j]; 
        }
    }
    return result;
}

matrix multiply(matrix A, matrix B){
    // 判断矩阵A的行与矩阵B的列是否相等
    if(A.col != B.row){
        printf("size error, matrix A's column doesn't equal to matrix B's row");
        exit(0);
    }
    // 计算结果并返回
    matrix result;
    create(&result, A.row, B.col);
    for(int i = 0; i < result.row; i++){
        for(int j = 0; j < result.col; j++){
            for(int k = 0; k < A.col; k++){
                result.matrix[i][j] += A.matrix[i][k] * B.matrix[k][j];
            }
        }
    }
    return result;
}

void transpose(matrix *m){
    // 转置
    matrix temp = *m;
    create(m, m->col, m->row);
    for(int i = 0; i < m->row; i++){
        for(int j = 0; j < m->col; j++){
            m->matrix[i][j] = temp.matrix[j][i];
        }
    }
}

void row_trans_swap(matrix *m, int i, int j){
    // 交换两行
    float temp;
    for(int k = 0; k < m->col; k++){
        temp = m->matrix[i][k];
        m->matrix[i][k] = m->matrix[j][k];
        m->matrix[j][k] = temp;
    }
}

void row_trans_sub(matrix *m, int i, int j, float multiple){
    // 两行相减
    for(int k = 0; k < m->col; k++){
        m->matrix[i][k] -= m->matrix[j][k] * multiple;
        if(fabs(m->matrix[i][k]) < __FLT_EPSILON__){
            m->matrix[i][k] = 0;
        }
    }
}

void row_echelon(matrix *m){
    int i = 0;
    int j = 0;
    // if(m->row < m->col){
    //     transpose(m);
    // }
    while(i < m->row && j < m->col){
        // 情形1：如果matrix[i][j]不为0
        if(m->matrix[i][j] != 0){
            // 首元素置1
            float divisor = m->matrix[i][j];
            for(int k = j; k < m->col; k++){
                m->matrix[i][k] /= divisor;
                if(fabs(m->matrix[i][k]) < __FLT_EPSILON__){
                    m->matrix[i][k] = 0;
                }
            }
            // 同一列下方元素置0
            for(int k = i + 1; k < m->row; k++){
                row_trans_sub(m, k, i, m->matrix[k][j]);
            }
            i++;
            j++;
        }
        // 情形2：如果matrix[i][j]为0
        else{
            // 向下寻找matrix[k][j]不为0的行
            int k;
            for(k = i + 1; k < m->row; k++){
                if(m->matrix[k][j] != 0){
                    break;
                }
            }
            // 情形2.1：如果不存在这样的行，则继续循环，处理下一列
            if(k >= m->row){
                j++;
                continue;
            }
            // 情形2.2：如果存在这样的行k，交换第i行和第k行
            row_trans_swap(m, i, k);
            // 后续步骤与情形1相同
            float divisor = m->matrix[i][j];
            for(int t = j; t < m->col; t++){
                m->matrix[i][t] /= divisor;
                if(fabs(m->matrix[i][t]) < __FLT_EPSILON__){
                    m->matrix[i][t] = 0;
                }
            }
            for(int t = i + 1; t < m->row; t++){
                row_trans_sub(m, t, i, m->matrix[t][j]);
            }
            i++;
            j++;
        }
    }
}

void col_trans_swap(matrix *m, int i, int j){
    // 交换两列
    float temp;
    for(int k = 0; k < m->col; k++){
        temp = m->matrix[k][i];
        m->matrix[k][i] = m->matrix[k][j];
        m->matrix[k][j] = temp;
    }
}

void col_trans_sub(matrix *m, int i, int j, float multiple){
    // 两列相减
    for(int k = 0; k < m->col; k++){
        m->matrix[k][i] -= m->matrix[k][j] * multiple;
        if(fabs(m->matrix[k][i]) < __FLT_EPSILON__){
            m->matrix[k][i] = 0;
        }
    }
}

void col_echelon(matrix *m){
    int i = 0;
    int j = 0;
    while(i < m->row && j < m->col){
        // // 情形1：如果matrix[i][j]不为0
        // if(m->matrix[i][j] != 0){
        //     // 首元素置1
        //     float divisor = m->matrix[i][j];
        //     for(int k = i; k < m->row; k++){
        //         m->matrix[k][j] /= divisor;
        //         if(fabs(m->matrix[k][j]) < __FLT_EPSILON__){
        //             m->matrix[k][j] = 0;
        //         }
        //     }
        //     // 同一行右方元素置0
        //     for(int k = j + 1; k < m->col; k++){
        //         col_trans_sub(m, k, j, m->matrix[i][k]);
        //     }
        //     i++;
        //     j++;
        // }
        // // 情形2：如果matrix[i][j]为0
        // else{
        //     // 向右寻找matrix[i][k]不为0的列
        //     int k;
        //     for(k = j + 1; k < m->col; k++){
        //         if(m->matrix[i][k] != 0){
        //             break;
        //         }
        //     }
        //     // 情形2.1：如果不存在这样的列，则继续循环，处理下一行
        //     if(k >= m->col){
        //         i++;
        //         continue;
        //     }
        //     // 情形2.2：如果存在这样的列k，交换第j列和第k列
        //     col_trans_swap(m, j, k);
        //     // 后续步骤与情形1相同
        //     float divisor = m->matrix[i][j];
        //     for(int t = i; t < m->row; t++){
        //         m->matrix[t][j] /= divisor;
        //         if(fabs(m->matrix[t][j]) < __FLT_EPSILON__){
        //             m->matrix[t][j] = 0;
        //         }
        //     }
        //     for(int t = j + 1; t < m->col; t++){
        //         col_trans_sub(m, t, j, m->matrix[i][t]);
        //     }
        //     i++;
        //     j++;
        // }

        // 情形2：如果matrix[i][j]为0
        if(m->matrix[i][j] == 0){
            // 向右寻找matrix[i][k]不为0的列
            int k;
            for(k = j + 1; k < m->col; k++){
                if(m->matrix[i][k] != 0){
                    break;
                }
            }
            // 情形2.1：如果不存在这样的列，则继续循环，处理下一行
            if(k >= m->col){
                i++;
                continue;
            }
            // 情形2.2：如果存在这样的列k，交换第j列和第k列
            col_trans_swap(m, j, k);
        }
        // 情形1和2共有的步骤
        // 首元素置1
        float divisor = m->matrix[i][j];
        for(int k = i; k < m->row; k++){
            m->matrix[k][j] /= divisor;
            if(fabs(m->matrix[k][j]) < __FLT_EPSILON__){
                m->matrix[k][j] = 0;
            }
        }
        // 同一行右方元素置0
        for(int k = j + 1; k < m->col; k++){
            col_trans_sub(m, k, j, m->matrix[i][k]);
        }
        i++;
        j++;
    }
}

int rank(matrix m){
    // 将矩阵转换为行阶梯型
    row_echelon(&m);
    // print_matrix(m);
    // 计算矩阵的秩-->寻找对角线有多少不为0的元素
    int i = 0; 
    int j = 0; 
    while(i < m.row && j < m.col){
        if(m.matrix[i][j] == 0){
            break;
        }
        i++;
        j++;
    }
    return i;
}

int inversion_number(int *array, int N){
    int res = 0;
    for(int i = 0; i < N - 1; i++){
        for(int j = i + 1; j < N; j++){
            if(array[i] > array[j]){
                res++;
            }
        }
    }
    return res;
}

// 计算行列式的辅助函数
int find(int *array, int N, int value){
    // 如果在数组中查找到指定元素，返回true，否则返回false
    for(int i = 0; i < N; i++){
        if(value == array[i]){
            return 1;
        }
    }
    return 0;
}

// 计算行列式的辅助函数
void dfs(float *res, matrix m, int i, int j, int *cols){
    // res用于保存行列式的值，m保存矩阵，i记录当前行，j记录当前列，cols记录哪些列已被选择
    // 终止条件
    if(i == m.row){
        float temp = 1;
        for(int k = 0; k < m.row; k++){
            temp = temp * m.matrix[k][cols[k]];
        }
        *res = *res + pow(-1, inversion_number(cols, m.row)) * temp;
    }
    // 递归
    for(int p = 0; p < m.col; p++){
        // 如果第p列未被选择，则选择第p列，然后递归处理下一行
        if(!find(cols, i, p)){
            cols[i] = p;
            dfs(res, m, i + 1, 0, cols);
            // 回溯
            // do nothing
        }  
    }
}

float det(matrix m){
    // 矩阵必须是方阵
    if(m.row != m.col){
        printf("The matrix is not square matrix(row doesn't equals to column)");
        exit(0);
    }
    // 计算矩阵的行列式
    float res = 0;
    int *cols = (int *)malloc(sizeof(int)*m.row);  //记录哪些列已被选择
    for(int k = 0; k < m.row; k++){
        cols[k] = 0;
    }
    // 递归
    for(int k = 0; k < m.col; k++){
        // 首行选择第k列，然后递归处理下一行
        cols[0] = k; 
        dfs(&res, m, 1, 0, cols);       
        // 回溯
        // do nothing
    }
    return res;
}

float confactor(matrix m, int i, int j){
    // 矩阵必须是方阵
    if(m.row != m.col){
        printf("The matrix is not square matrix(row doesn't equals to column)");
        exit(0);
    }
    matrix remains;
    create(&remains, m.row - 1, m.col - 1);
    for(int p = 0; p < remains.row; p++){
        for(int q = 0; q < remains.col; q++){
            if(p < i && q < j){
                remains.matrix[p][q] = m.matrix[p][q];
            }
            else if(p < i && q >= j){
                remains.matrix[p][q] = m.matrix[p][q + 1];
            }
            else if(p >= i && q < j){
                remains.matrix[p][q] = m.matrix[p + 1][q];
            }
            else if(p >= i && q >= j){
                remains.matrix[p][q] = m.matrix[p + 1][q + 1];
            }
        }
    }
    return det(remains);
}

float algebraic_confactor(matrix m, int i, int j){  
    return confactor(m, i, j)*pow(-1, i+j);
}

matrix inverse(matrix m){
    matrix res;
    create(&res, m.row, m.col);
    for(int i = 0; i < res.row; i++){
        for(int j = 0; j < res.col; j++){
            res.matrix[i][j] = algebraic_confactor(m, j, i) / det(m);
        }
    }
    return res;
}

void print_matrix(matrix m){
    // 输出矩阵
    for(int i = 0; i < m.row; i++){
        for(int j = 0; j < m.col; j++){
            printf("%f ", m.matrix[i][j]);
        }
        printf("\n");
    }
}

测试代码

#include"../exercises/matrix.h"

int main(){
    // 乘法
    // matrix A, B;
    // create(&A, 2, 3);
    // create(&B, 3, 2);
    // init_matrix(&A);
    // init_matrix(&B);
    // matrix result = multiply(A, B);
    // free_matrix(&A);
    // free_matrix(&B);
    // free_matrix(&result);

    // 加法
    matrix A, B;
    create(&A, 2, 2);
    create(&B, 2, 2);
    init_matrix(&A);
    init_matrix(&B);
    matrix result = add(A, B);
    free_matrix(&A);
    free_matrix(&B);
    free_matrix(&result);

    // 减法
    // matrix A, B;
    // create(&A, 2, 2);
    // create(&B, 2, 2);
    // init_matrix(&A);
    // init_matrix(&B);
    // matrix result = sub(A, B);
    // free_matrix(&A);
    // free_matrix(&B);
    // free_matrix(&result);

    // 行阶梯形
    // matrix A;
    // create(&A, 3, 4);
    // init_matrix(&A);
    // row_echelon(&A);
    // free_matrix(&A);

    // 矩阵的秩
    // matrix A;
    // create(&A, 3, 4);
    // init_matrix(&A);
    // int r = rank(A);
    // printf("the rank of matrix is %d", r);
    // free_matrix(&A);

    // 矩阵的行列式
    // matrix A;
    // create(&A, 3, 3);
    // init_matrix(&A);
    // float res = det(A);
    // printf("the determinant of the matrix is %f", res);
    // free_matrix(&A);

    // 代数余子式
    // matrix A;
    // create(&A, 4, 4);
    // init_matrix(&A);
    // // float res = confactor(A, 0, 0);
    // float res = algebraic_confactor(A, 1, 1);
    // printf("the factor of the matrix(determinant) is %f", res);
    // free_matrix(&A);

    // 逆矩阵
    // matrix A;
    // create(&A, 3, 3);
    // init_matrix(&A);
    // matrix inv = inverse(A);
    // print_matrix(inv);
    // free_matrix(&A);

    // 矩阵的行阶梯型
    // matrix A;
    // create(&A, 3, 4);
    // init_matrix(&A);
    // row_echelon(&A);
    // print_matrix(A);
    // free_matrix(&A);

    // 矩阵的列阶梯型
    // matrix A;
    // create(&A, 4, 4);
    // init_matrix(&A);
    // col_echelon(&A);
    // print_matrix(A);
    // free_matrix(&A);

    return 0;
}

2021/8/23修改

今天在做线性代数的习题时，发现了一处问题，就是浮点数的精度问题。由于浮点数编码是近似表示，所以会出现-0.0000的情况。

例如，在某一时刻，矩阵的某两行相同，对其中一行做了除法，另一行减去第一行的倍数，结果不等于0，而等于-0.0000。

对此，在每次对矩阵进行行变换时，增加了以下代码：

if(fabs(m->matrix[i][k]) < __FLT_EPSILON__){
    m->matrix[i][k] = 0;
}

感兴趣的小伙伴可以用如下所示的矩阵进行测试，输出矩阵的行阶梯形，对比修改前后的变化：

1 3 2 0
7 0 14 3
2 -1 0 1
5 1 6 2
2 -1 4 1

2021/8/29修改

今天在解非齐次线性方程组时发现了一个问题，那就是把行阶梯型和列阶梯型混合在一起实现。

在求增广矩阵的行阶梯型时，如果列数大于行数，我先进行了转置，再求行阶梯型，那么问题产生了。由于我先进行了转置，无法判断原矩阵的系数矩阵与增广矩阵的秩的关系，也就无法判断非齐次线性方程组是否有解。

对此，把行阶梯型和列阶梯型分开实现。

在实现列阶梯型时，发现代码有冗余，于是进行了精简，但代码的可读性降低了，所以仍然保留了之前的代码作为参考。

2022/8/19修改

增加了释放内存的代码

浑浑噩噩666
关注
  • 24
    点赞
  • 踩
  • 126
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
c语言实现矩阵运算
weixin_45193247的博客
06-12 5537
前言：我知道一定会有郫县男子职业技术学院的同学看到这个，之前我一直在想要不要直接把程序放在这，因为有些课程确实操蛋，但后来想了想，或许这就是痛苦学习法吧。所以我决定写一写自己的编程过程，希望能有些帮助。 1.一个矩阵要有的信息包括它的行数列数以及每一个元素的信息，所以我们设置了一个结构体来包含这些信息，结构体的成员就是整型的行数和列数和一个表示元素内容的二级指针。其中二级指针比较难以理解，二级指针是指向一级指针的，一级指针指向具体的值，这里我们可以认为这个值就是具体的元素内容。我同学璐璐给我打了个比喻：甲是
C语言实现矩阵求逆
06-08
本人使用C语言编写使用初等行变换的方法，求出矩阵的逆矩阵。
C语言实现常用的矩阵运算
12-28
C语言实现常用的矩阵运算，其中矩阵的求逆运算提供了两种方法，伴随矩阵法和高斯消元法，随着矩阵的变大，高斯消元法比伴随矩阵的效率越来越高。
用C语言实现一个矩阵
微小冷的学习笔记
10-06 1万+
C语言实现矩阵 矩阵作为一个结构体而言，至少要包含行数、列数以及数据。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct{ int row, col, size; double *data; } Matrix; 特殊矩阵 接下来通过这个结构体实现一些特殊的矩阵，例如包括相同元素的矩阵、对角矩阵等。 #define SetBase(mat) \ (M
L2-052 吉利矩阵(奇异搞笑暴力+猜样例打表AC)
2301_80113365的博客
04-21 686
本文写了很多的图片
C语言实现矩阵的乘法
热门推荐
niannianxi的博客
01-18 2万+
矩阵乘法作为算法题我觉得对我来说是比较难想的，而且作为没学线性代数的我来说，这简直就是场灾难，在我研究了书上及网上的有关资料后，我觉得自己应该差不多可以理解矩阵乘法的要领了，希望可以帮助大家：其实矩阵的运算包括许多种，有加减乘除法等等。矩阵加法就是相同位置的数字加一下。 矩阵减法也类似。矩阵乘以一个常数，就是所有位置都乘以这个数。但是，等到矩阵乘以矩阵的时候，一切就不一样了。首先让我们了解下矩阵乘...
使用C语言实现矩阵转置（稀疏矩阵）
Keep_Trying_Go的博客
08-15 1万+
使用C语言实现矩阵转置（稀疏矩阵）
C语言实现矩阵乘法
weixin_35755823的博客
01-01 769
在 C 语言中实现矩阵乘法的一种方法是使用三重循环，这样可以遍历矩阵的每个元素，并使用矩阵乘法的通用公式计算结果矩阵的每个元素。 具体来说，假设我们有两个矩阵 A 和 B，矩阵 A 有 m 行 n 列，矩阵 B 有 n 行 p 列，矩阵乘法的结果是一个 m 行 p 列的矩阵 C。那么，我们可以使用以下代码来实现矩阵乘法： for (int i = 0; i < m; i++) { for...
用C语言实现矩阵运算.doc
11-29
本文将详细介绍如何使用C语言实现矩阵运算，并提供了一个完整的示例程序，以便读者更好地理解和掌握矩阵运算的实现。 一、矩阵数乘 矩阵数乘是指将矩阵的每个元素乘以一个实数。该操作可以用于矩阵的缩放、平移和...
用C语言实现矩阵的转置
11-09
以下是对如何在 C 语言中实现矩阵转置的详细解释： 首先，了解矩阵转置的基本概念。对于一个 m×n 矩阵 A，其转置矩阵 A^T 是一个 n×m 矩阵，其中 A^T(i,j) = A(j,i)，即原矩阵的第 i 行第 j 列的元素变为转置矩阵...
使用C语言实现矩阵转置.pdf
11-09
在程序中，我们定义了一个`transposeMatrix`函数来实现矩阵转置操作。这个函数接收两个参数：原始矩阵`mat`和存储转置结果的矩阵`transposed`。通过双重循环遍历原始矩阵的每一个元素，并将其互换位置存入转置矩阵中...
大话C语言：第28篇 内存分配与释放
whccf的博客
07-05 306
C语言内存分配与释放
Linux C轻量级白盒测试方法 (shell + c + signal)
AntigravityC的博客
07-08 281
linux C轻量级白盒测试方法（shell + c +signal）
Windows图形界面(GUI)-SDK-C/C++ - 按钮(button)
最新发布
0xCC说逆向
07-10 357
【代码】Windows图形界面(GUI)-SDK-C/C++ - 按钮(button)
c小红的图上划分（牛客127）
m0_74310050的博客
07-06 341
用并查集，如果新增边的点没有共同祖先，连通块就减1，只要判断连通块<=r即可满足条件，不用管l的值，因为减少一个连通块，也就是多增一条边，这条边一定会小于原来的值的，答案要的是最大值，所有不用管。有一个无向图，有 n 个点 m 条边，q 个询问，每次给出 L,R，求将图划分为至少 L 个连通块，最多 R个连通块的最大划分价值，若不可划分输出 "NO ANSWER"。图的划分定义为将图划分为一个或多个连通块，对于每个连通块，其点集为其边集中每一条边的两端点的集合，且点集内任意两点均可通过边集里的边互相到达。
【C语言】C语言可以做什么？
EleganceJiaBao的博客
07-06 989
C语言作为一种高效、灵活且具有底层控制能力的编程语言，在软件开发的多个领域中得到了广泛应用。以下是C语言在主要应用领域中的总结：
c与c++ 常用的字符与字符串处理的接口介绍：
jjjxxxhhh123的博客
07-06 683
字符拷贝：char* strncpy(char* dest, const char* src, size_t n) 将源字符串的前 n 个字符拷贝到目标字符串。字符比较：int strncmp(const char* str1, const char* str2, size_t n) 比较两个字符串的前 n 个字符。字符串连接：strcat(char* dest, const char* src) 将源字符串连接到目标字符串的末尾。字符串长度：size() 返回字符串的长度。
C/AC电源模块在工业科技中的重要作用
duxi222333的博客
07-10 166
同时，电源模块还可以实现能源的存储和管理，例如将多余的电能存储在电池中以备用，或者将电能供应给其他设备和系统。二，DC/AC电源模块在科技创新中也起着重要作用。此外，电源模块还能够监测和控制电力系统的状态，及时响应变化和故障，并提供保护机制，确保电力系统的安全和可靠性。电源模块的设计和使用不仅能够改善产品性能、提高能源利用效率，并推动科技创新的进一步发展，还在能源管理和电力系统稳定性方面发挥着重要作用。因此，DC/AC电源模块在工业科技中的重要性不可忽视，其持续发展和创新将促进工业科技的进步和可持续发展。
用C语言实现矩阵乘法
12-28
以下是用C语言实现矩阵乘法的代码示例： ```c #include <stdio.h> #define ROW1 2 #define COL1 3 #define ROW2 3 #define COL2 2 void matrix_multiply(int mat1[][COL1], int mat2[][COL2], int result[][COL2]) { int i, j, k; for (i = 0; i < ROW1; i++) { for (j = 0; j < COL2; j++) { result[i][j] = 0; for (k = 0; k < COL1; k++) { result[i][j] += mat1[i][k] * mat2[k][j]; } } } } int main() { int mat1[ROW1][COL1] = {{1, 2, 3}, {4, 5, 6}}; int mat2[ROW2][COL2] = {{7, 8}, {9, 10}, {11, 12}}; int result[ROW1][COL2]; matrix_multiply(mat1, mat2, result); printf("Result:\n"); for (int i = 0; i < ROW1; i++) { for (int j = 0; j < COL2; j++) { printf("%d ", result[i][j]); } printf("\n"); } return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值