java 矩阵相乘，矩阵线性运算

矩阵的乘法运算：

这里有矩阵A,和矩阵B,求出他们的乘法运算的结果：C=AB

矩阵C的第一个元素C[0][0]是，矩阵A的第一行A[0][*]的每一个元素和矩阵B第一列B[*][0]的每一个对应元素的乘积，然后再对这些乘积累加求和，这个求和的结果就是矩阵C第一个元素的值.

即                C[0][0]=A[0][0]*B[0][0]+A[0][1]*B[1][0]+A[0][2]*B[2][0]+....A[0][k]B[k][0];以此类推。

展开公式：C[i][j]=A[i][0]*B[0][j]+A[i][1]*B[1][j]+A[i][2]*B[2][j]+....A[i][k]*B[k][j]。

也就是：     C[i][j]+=A[i][k]*B[k][j]。

下面是java代码：

package Maths;

public class Matrix
{
public static void main(String[] args)
{
int A[][]={{1,2,3},{4,5,6}};//a矩阵2X3
int B[][]={{1,2,3,4},{5,6,7,8},{1,2,3,4}};//b矩阵3X4
// int C[M][S];//结果矩阵2X4
System.out.println("A=");
printMatrix(A);
// System.out.println("}");
System.out.println("B=");
printMatrix(B);
// System.out.println("}");
System.out.println("C=A*B=");
int C[][]=Mul(A, B);
printMatrix(C);
// System.out.println("}");
}
static int[][] Mul(int A[][],int B[][])
{
//矩阵能相乘的条件：A的列数等于B的行数
for(int i=0;i<A.length;i++)
{
if(A[i].length!=B.length)
{
System.out.println("不能相乘");
return null;
}
}

// System.out.println("A[0].length="+A[0].length+" B.length"+B.length);
//生成相乘之后的数组
int[][] C=new int[A.length][B[0].length];

for(int i=0;i<C.length;i++)//遍历相乘之后的数组的行 ：2,等于A矩阵的行
{
for(int j=0;j<C[i].length;j++)//遍历相乘后的数组的列 等于B矩阵的列
{
for(int k=0;k<A[0].length;k++)//遍历 A矩阵的列，也是B矩阵的行
{
C[i][j]+=A[i][k]*B[k][j];
}
}
}
return C;
}
static void printMatrix(int Matrix[][])
{
for(int i=0;i<Matrix.length;i++)
{
for(int j=0;j<Matrix[i].length;j++)
{
System.out.print(" "+Matrix[i][j]);
}
System.out.println();
}
}
}
运行结果：

A=

1  2  3
4  5  6
B=
1  2  3  4
5  6  7  8
1  2  3  4
C=A*B=
14  20  26  32
35  50  65  80

其他运算：矩阵的加法，矩阵的减法，只要对应相同行列的元素相加减就行了。

加法：C[i][j]=A[i][j]+B[i][j].

加法：C[i][j]=A[i][j]-B[i][j].

数乘：C[i][j]=k*A[i][j];

矩阵的转置：行列交换就可：A[i][j]=A[j][i].

当然这样会出错,需要借助一个辅助的空间来交换，temp=A[i][j]; A[i][j]=A[j][i];A[j][i]=temp;

 

java代码：

package Maths;
public class Matrix
{
public static void main(String[] args)
{
int[][] A={{1,2},
{3,4}};
int[][] B={{1,2},
{3,4}};
printMatrix("A",A);
printMatrix("B",B);
int[][] C=add(A, B);
printMatrix("A+B",C);
C=sub(A, B);
printMatrix("A-B",C);
C=mul(A, B);
printMatrix("A*B",C);
C=kMul(A, 2);
printMatrix(2+"*A",C);
C=Transpose(A);
printMatrix("(A)T", C);
}
//判断是不是矩阵
static boolean isMatrix(int A[][])
{
if(A==null)
return false;
//如果二维只有一行，那肯定是矩阵了
if(A.length==1)
return true;
//如果有两行以上
final int cols=A[0].length;
int i=0;
for(i=1;i<A.length;i++)
{
if(A[i].length!=cols)//如果找到了一行中元素个数和第一行不一样，那就不是矩阵了。
return false;
}
return true;

}
//打印矩阵
static void printMatrix(String name,int Matrix[][])
{
if(isMatrix(Matrix))
{
System.out.print(name+"= ");
for(int i=0;i<Matrix.length;i++)
{
//打印控制，只是为了看起来好看点
if(i!=0)
{
for(int j=0;j<name.length()+2;j++)
{
System.out.print(" ");
}
}

for(int j=0;j<Matrix[i].length;j++)
{
System.out.printf("%-4d",Matrix[i][j]);
}
System.out.println();
}
}
else
System.out.println(name+"不是矩阵");

}
//	矩阵相加
static int[][] add(int A[][],int B[][])
{
//先判断是不是矩阵不是矩阵，不能进行矩阵的加法
if(isMatrix(A)&&isMatrix(B))
{
/*两个矩阵只有在行数和列数相等的情况下才能相加减*/
if(A.length!=B.length||A[0].length!=B[0].length)
{
return null;//如果说行数不相等
}
int[][] C=new int[A.length][A[0].length];
for(int i=0;i<A.length;i++)
{
for(int j=0;j<A[0].length;j++)
{
C[i][j]=A[i][j]+B[i][j];
}
}
return C;

}
return null;
}
//	矩阵加上0等于他自己
static int[][] add(int A[][],int k)
{
if(k==0)
{
return A;
}
return null;
}
//	矩阵相减
static int[][] sub(int A[][],int B[][])
{
//先判断是不是矩阵不是矩阵，不能进行矩阵的加法
if(isMatrix(A)&&isMatrix(B))
{
/*两个矩阵只有在行数和列数相等的情况下才能相加减*/
if(A.length!=B.length||A[0].length!=B[0].length)
{
return null;//如果说行数不相等
}
int[][] C=new int[A.length][A[0].length];
for(int i=0;i<A.length;i++)
{
for(int j=0;j<A[0].length;j++)
{
C[i][j]=A[i][j]-B[i][j];
}
}
return C;

}
return null;
}
//矩阵数乘
static int[][] kMul(int[][] A,int k)
{
if(isMatrix(A))
{
int[][] AA=new int[A.length][A[0].length];
for(int i=0;i<A.length;i++)
{
for(int j=0;j<A[0].length;j++)
{
AA[i][j]=k*A[i][j];
}
}
return AA;
}
return null;
}
//矩阵相乘
static int[][] mul(int A[][],int B[][])
{
if (isMatrix(A)&&isMatrix(B))
{
//矩阵能相乘的条件：A的列数等于B的行数
if(A[0].length!=B.length)
return null;

int[][] C=new int[A.length][B[0].length];

for(int i=0;i<C.length;i++)//遍历相乘之后的数组的行 ：2,等于A矩阵的行
{
for(int j=0;j<C[i].length;j++)//遍历相乘后的数组的列 等于B矩阵的列
{
for(int k=0;k<A[0].length;k++)//遍历 A矩阵的列，也是B矩阵的行
{
C[i][j]+=A[i][k]*B[k][j];
}
}
}
return C;
}
return null;
}
//矩阵转置
static int[][] Transpose(int A[][])
{
if(isMatrix(A))
{
//			int A_T[][]=new int[A.length][A[0].length];
int temp;
for (int i = 0; i < A.length; i++)
{
for (int j = 0; j < A[0].length; j++)
{
temp=A[j][i];
A[j][i]=A[i][j];
A[i][j]=temp;
}
}
return A;
}
return null;
}
}

C语言矩阵相乘：C语言不能向函数传递，可以通过指针来访问数组，通过计算便宜量来遍历二维数组，C语言也不能返回一个数组，在函数中通过传入指向数组的指针来修改外部的数组

#include<stdio.h>

void arymul(int* a, int* b, int* c,int row,int cols,int end);
int main()
{

int A[2][2]={{1,2},
{3,4}};

int B[2][3]={{2,2,2},
{2,2,2}};
int C[2][3];
int i,j;
arymul((int*)A,(int*)B,(int*)C,2,2,3);
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("%-4d",C[i][j]);
}
printf("\n");
}
return 0;
}
void arymul(int* a, int* b, int* c,int row,int cols,int end)
{
int i, j, k;
int temp;
for(i = 0; i < row; i++){ //2
for(j = 0; j < end; j++){  //4
temp = 0;
for(k = 0; k < cols; k++){  //3
//  temp += a[i][k] * b[k][j];
//A[row][cols]*B[cols][end]
temp+=*(a+i*cols+k)*(*(b+k*end+j));
}
// c[i][j] = temp;
*(c+i*end+j)=temp;
}

}
}