矩阵表达式计算器

slimay

神奇的矩阵表达式运算工具
下载   http://cmd1152.ys168.com/  文件区  矩阵表达式计算器.zip
MAT.EXE
摘要：
=============================================================================
矩阵表达式计算器，支持矩阵四则运算,乘方运算计算。
=============================================================================

用法：
-----------------------------------------------------------------------------
mat "[expression1] [expression2] [expression3] [.] ..."
-----------------------------------------------------------------------------

示例:
-----------------------------------------------------------------------------
mat "[A=1,0;1,1] [B=A^(2)] [C=A^(-1)+B] [(A^(-1))-C] [det(A)]"
-----------------------------------------------------------------------------

输入格式：
    {E = en(2)}      <==>   [1   0]
                            [0   1]
    {A = 1,,2;3,8,7} <==>   [1   0   2]
                            [3   8   7]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
矩阵函数:
    +, -, *, ^, A^(-1), A^(n), cp(A), rot(A), en(A)
    gs(A), diag(A), lad(A), tri(A)
    tr(A), r(A), det(A)
    lf(n): 控制精度
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
常数类
        pi    3.1415926535897932
        e     2.7182818284590452       

通用类
        +     加
        -     减
        *     乘
        /     除
        %     取余数
        ^     次方
        rand  随机数
        round 四舍五入
        int   取整
        ceil  向上舍入
        floor 向下舍入
        sqrt  开方
        lg    常用对数，以10为底
        ln    自然对数
        exp   e的次幂
        deg   度转弧度

三角函数类
        sin、cos、tan   
        arcsin、arccos、arctan

双曲函数类
        sinh、cosh、tanh
        arcsinh、arccosh、arctanh

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

英译：
The matrix calculator, Copyright@2021~2023 Slimay
usage:
    mat "[expression1] [expression2] [expression3] [.] ..."
example:
    mat "[A=1,0;1,1] [B=A^(2)] [C=A^(-1)+B] [(A^(-1))-C] [det(A
    You can use the letters A to O to name the matrix
    {E = en(2)}      <==>   [1   0]
                            [0   1]
    {A = 1,,2;3,8,7} <==>   [1   0   2]
                            [3   8   7]
matrix functions:
    +, -, *, ^, A^(-1), A^(n), cp(A), rot(A), en(A)
    gs(A), diag(A), lad(A), tri(A)
    tr(A), r(A), det(A)
    lf(n): control print precision

mathematical function:
    pi = 3.1415, e = 2.7182, rand, abs, sqrt, lg, ln, exp
    sin, cos, tan, arcsin, arccos, arctan
version 1.0.5
COPYRIGHT@2021~2023 BY SLIMAY, VERSION 1.0
MAT.EXE

核心代码

1. //高斯若当主函数
   
2. Matrix* Gauss_Jordan_Elimination(Matrix* mat, int eliminateMode)
   
3. {
   
4.         int eliminateModeBak =  eliminateMode;
   
5.        
   
6.         if(eliminateMode == ELIMINATE_INVERSE2)
   
7.         {
   
8.                 eliminateMode = ELIMINATE_INVERSE;
   
9.         }
   
10. 
    
11.         if(eliminateMode == ELIMINATE_GET_DET)
    
12.         {
    
13.                 eliminateMode = ELIMINATE_TRIANGLE;
    
14.         }
    
15.        
    
16.         //获取第一个矩阵列数
    
17.         int n1 = ( *(mat + 0) );
    
18.         //获取第一个矩阵行数
    
19.         int m1 = ( *(mat + 1) );
    
20. 
    
21. 
    
22.         //低于二阶的矩阵没法阶梯化
    
23.         if(n1 <2 || m1 < 2)
    
24.         {
    
25.                 PRINTF_ERROR("The 1-order matrix can't run this.\n", "");
    
26.                 exit(1);
    
27.                 return real_matrix(1.0f / (*(mat + 2)));
    
28.         }
    
29. 
    
30.         //用传入矩阵的备份做 高斯若当处理
    
31.         Matrix* mat1 = (Matrix *)calloc(n1 * m1 + MAT_PRELEN, sizeof(double));
    
32.         memcpy(mat1, mat, sizeof(double) * (n1 * m1 + MAT_PRELEN) );
    
33. 
    
34.         //行交换存储器
    
35.         double exChangeLineTmp[MAX_LEN];
    
36.        
    
37.         Matrix* matInverse = NULL;
    
38.        
    
39.         if(eliminateMode == ELIMINATE_INVERSE)
    
40.         {
    
41.                 //动态分配一个存放逆矩阵的空间
    
42.                 matInverse = (Matrix *)calloc(n1 * m1 + MAT_PRELEN, sizeof(double));
    
43.                 //写入列行数
    
44.                 *(matInverse + 0) =  (double)n1;
    
45.                 *(matInverse + 1) =  (double)m1;
    
46.                 // 先置一同阶单位矩阵
    
47.                 for(int i = 0; i < GET_MIN(n1, m1); i++)
    
48.                 {
    
49.                         *(matInverse + MAT_PRELEN + i + i * n1) = 1.0f;
    
50.                 }
    
51.         }
    
52.        
    
53.         //行交换的次数
    
54.         int exChangeTimes = 0;
    
55.         //高斯若当消去法置换成上三角型矩阵
    
56.         int i = 0, j = 0, j_start = 0;
    
57.         for(i = 0; i < GET_MIN(n1, m1); i++)
    
58.         {       
    
59.                 for(j = j_start; (j < m1) && (i < n1); j++)
    
60.                 {
    
61.                         //找到主元直接中断内循环
    
62.                         if( (*(mat1 + MAT_PRELEN  + i + j_start * n1)) != 0)
    
63.                         {
    
64.                                 break;
    
65.                         }
    
66.                         //找到主元为0，则通过行交换使得主元不为0
    
67.                         if( (*(mat1 + MAT_PRELEN  + i + j*n1) != 0) && (j != j_start))
    
68.                         {
    
69.                                
    
70.                                 memcpy(exChangeLineTmp, mat1 + MAT_PRELEN + j*n1, n1 * sizeof(double));                       
    
71.                                 // i行与j行互换
    
72.                                 memcpy(mat1 + MAT_PRELEN + j * n1,    mat1 + MAT_PRELEN + i * n1,            n1 * sizeof(double));
    
73.                                 memcpy(mat1 + MAT_PRELEN + i * n1,    exChangeLineTmp,                       n1 * sizeof(double));
    
74.                                
    
75.                                 // 如果是求逆矩阵模式
    
76.                                 if(eliminateMode == ELIMINATE_INVERSE)
    
77.                                 {
    
78.                                         memcpy(exChangeLineTmp, matInverse + MAT_PRELEN + j*n1, n1 * sizeof(double));                       
    
79.                                         // i行与j行互换
    
80.                                         memcpy(matInverse + MAT_PRELEN + j * n1,    matInverse + MAT_PRELEN + i * n1,            n1 * sizeof(double));
    
81.                                         memcpy(matInverse + MAT_PRELEN + i * n1,    exChangeLineTmp,                             n1 * sizeof(double));
    
82.                                 }
    
83.                                                
    
84.                                 exChangeTimes ++;
    
85.                                 break;
    
86.                         }
    
87.                 }
    
88. 
    
89.                 //如果该列主元都为0，直接跳过，处理下一列
    
90.                 if((j == m1) && (*(mat1 + MAT_PRELEN  + i + j_start * n1) == 0))
    
91.                 {
    
92.                         // 这里根据开关选择是否采用阶梯消去法，阶梯消去用于非方阵的m*n型矩阵秩计算
    
93.                         if((eliminateModeBak != ELIMINATE_LADDER))
    
94.                         {
    
95.                                 j_start ++;
    
96.                         }
    
97.                         continue;
    
98.                 }
    
99. 
    
100.                 //如果该列主元不为0，则本行除以主元
     
101.                 if( (*(mat1 + MAT_PRELEN  + i + j_start * n1)) != 0)
     
102.                 {
     
103.                         // 这里根据开关选择是否采用主元归一，
     
104.                         if((eliminateMode == ELIMINATE_INVERSE))
     
105.                         {
     
106.                                 // 主元归一, 避免误差
     
107.                                 double mainPara = (*(mat1 + MAT_PRELEN  + i + j_start*n1));
     
108.                                 for(int k = i; k < n1; k++)
     
109.                                 {
     
110.                                         (*(mat1 + MAT_PRELEN  + k + j_start*n1)) /= mainPara;
     
111.                                        
     
112.                                         // 精度处理
     
113.                                         _ZERO_( *(mat1 + MAT_PRELEN  + k + j_start*n1) );
     
114.                                 }
     
115.                                
     
116.                                 if(eliminateMode == ELIMINATE_INVERSE)
     
117.                                 {
     
118.                                         for(int k = 0; k < n1; k++)
     
119.                                         {
     
120.                                                 (*(matInverse + MAT_PRELEN  + k + j_start*n1)) /= mainPara;
     
121. 
     
122.                                                 // 精度处理
     
123.                                                 _ZERO_( *(matInverse + MAT_PRELEN  + k + j_start*n1) );       
     
124.                                         }
     
125.                                 }
     
126.                         }
     
127.                 }
     
128. 
     
129.                 //开始消元
     
130.                 for(j = ( (eliminateMode==ELIMINATE_DIAG) || (eliminateMode==ELIMINATE_INVERSE) )?0 :(j_start + 1); (j < m1) && (i < n1); j++)
     
131.                 {
     
132.                         // 主元不消去自己
     
133.                         if(j == j_start)
     
134.                         {
     
135.                                 continue;
     
136.                         }
     
137.                        
     
138.                         //计算消去系数
     
139.                         double disLinePara =  - (*(mat1 + MAT_PRELEN  + i + j*n1)) / (*(mat1 + MAT_PRELEN  + i + j_start*n1));
     
140.                                
     
141.                         //用主元行消去其他行
     
142.                         for(int k = i; k < n1; k++)
     
143.                         {
     
144.                                 (*(mat1 + MAT_PRELEN  + k + j*n1))  +=  disLinePara * (*(mat1 + MAT_PRELEN  + k + j_start*n1));
     
145.                                        
     
146.                                 // 精度处理
     
147.                                 _ZERO_(*(mat1 + MAT_PRELEN  + k + j*n1));
     
148.                         }
     
149.                        
     
150.                         // 如果是求逆矩阵模式
     
151.                         if(eliminateMode == ELIMINATE_INVERSE)
     
152.                         {
     
153.                                 //计算消去系数 (这里沿用左边的消去系数，因为 AE -> EA^(-1),故两边乘以的消去系数一致
     
154.                                 double disLineParaInverse = disLinePara ;
     
155.                                        
     
156.                                 //用主元行消去其他行
     
157.                                 for(int k = ((eliminateMode==ELIMINATE_DIAG) || (eliminateMode==ELIMINATE_INVERSE) ?0 :i); k < n1; k++)
     
158.                                 {
     
159.                                         (*(matInverse + MAT_PRELEN  + k + j*n1))  += disLineParaInverse * (*(matInverse + MAT_PRELEN  + k + j_start*n1));
     
160.                                         // 精度控制
     
161.                                         _ZERO_( *(matInverse + MAT_PRELEN  + k + j*n1) );
     
162.                                 }
     
163.                         }
     
164.                 }
     
165. 
     
166.                 //下沉一行
     
167.                 j_start ++;       
     
168.         }
     
169.        
     
170.         // 如果是det求值模式
     
171.         if(eliminateModeBak == ELIMINATE_GET_DET)
     
172.         {       
     
173.                 double detValue = 1.0f;       
     
174.                 for(int j = 0; j < m1; j++)
     
175.                 {
     
176.                          detValue  *=  (*(mat1 + MAT_PRELEN  + j + j*m1));
     
177.                 }
     
178.                
     
179.                 // 精度控制
     
180.                 _ZERO_(detValue);
     
181.                                
     
182.                 //释放备份矩阵内存
     
183.                 free(mat1);
     
184.                        
     
185.                 //返回det值 1阶矩阵
     
186.                 return  real_matrix(detValue);
     
187.         }
     
188.        
     
189.         //如果是求逆矩阵模式
     
190.         if(eliminateModeBak == ELIMINATE_INVERSE)
     
191.         {
     
192.                 //获取首非零行个数
     
193.                 for(int j = 0; j < n1; j++)
     
194.                 {
     
195.                         double mPara = (*(mat1 + MAT_PRELEN  + j + j*n1));
     
196.                         if( mPara == 0.0f )
     
197.                         {
     
198.                                 PRINTF_ERROR("The matrix has no inverse mat.\n", "");
     
199.                                 exit(1);
     
200.                         }
     
201.                 }
     
202.                
     
203.                 //释放备份矩阵内存
     
204.                 free(mat1);       
     
205.                 return  matInverse;
     
206.         }
     
207. 
     
208.         //如果是解方程组模式
     
209.         if(eliminateModeBak == ELIMINATE_INVERSE2)
     
210.         {
     
211.                 free(matInverse);
     
212.                 return mat1;
     
213.         }
     
214. 
     
215.         //返回行交换次数
     
216.         return mat1;
     
217. }
     

复制代码