java矩阵分解

‘壹’ 用java语言做矩阵运算，输入一个m×n的矩阵，再输入一个n×o的矩阵求其乘积。一定要可以运行的。

这应该是线性数学的矩阵
逻辑思路是：取A矩阵的每一行的各个项去乘以B矩阵每个列的各个项
为了测试，我现在假设A矩阵是4*3， B矩阵是3*2， 你要做的乘操作是4*3*2=24次

importjava.util.*;
importjava.lang.*;
importjava.io.*;
/*Nameoftheclasshastobe"Main"onlyiftheclassispublic.*/
classIdeone
{
publicstaticvoidmain(String[]args)throwsjava.lang.Exception
{
int[][]A=newint[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
int[][]B=newint[][]{{1,2},{3,4},{5,6}};
intlen_A=A[0].length;//a每行元素数，这里是3
intcol_A=A.length;//a每列元素数，这里是4
intlen_B=B[0].length;//b每行元素数，这里是2
intcol_B=B.length;//b每列元素数，这里是3
intlen_a=0;
intcol_a=0;
intlen_b=0;
intcol_b=0;
intsum=0;
while(len_b<len_B)//使B的下一列被A乘
{
col_a=0;
while(col_a<col_A)//使A可以移动至下一行
{
len_a=0;
col_b=0;
while(len_a<len_A)//使A的当前行乘以B的当前列
{
sum+=A[col_a][len_a]*B[col_b][len_b];
len_a++;
col_b++;
}
col_a++;
}
len_b++;
}
System.out.println(sum);
}
}

‘贰’ 用java 编写一个矩阵类Matrix，要求能利用该矩阵类生成任意行、列的矩阵对象，比如3╳5矩阵，10╳20矩阵

publicclassMatrix{

	//表示行和列
	privateintmRow,mColumn;

	//构造方法
	publicMatrix(introw,intcolumn){
		mRow=row;
		mColumn=column;
	}

	//获取0-20随机数
	privateintrandom(){
		doublerandom1=Math.random();//这个Math类的方法可以获取0.0-1.0之间的随机数
		doublerandom2=random1*20;//0.0-20.0
		return(int)random2;
	}

	//创建矩阵
	privatevoidcreateMatrix(){
		inttotalCount=mRow*mColumn;//总共有那么多
		for(intcount=1;count<=totalCount;count++){
			intnumber=random();//上面的方法

			System.out.print(number<10?"0"+number:number);//输出数字,如果数字小于10，前面加0补全两位
			System.out.print("");//分隔符，随便填
			if(count%mRow==0){
				System.out.println();//换行
			}

		}
	}

	publicstaticvoidmain(String[]args){
		Matrixmatrix=newMatrix(3,5);//几行几列传进去
		matrix.createMatrix();
	}
}

为了经验我也是蛮拼的了

‘叁’ 怎样用JAVA语言实现矩阵

public class A3 {
public static void main(String[] args) {
//矩形宽是5个*
for(int i=0;i<5;i++){
//矩形长是5个*
for(int j=0;j<5;j++){
System.out.print("*");
}
System.out.println();
}
}
}

‘肆’ 如何创建一个java程序使用二维数组来解线性方程组，急，请高手赐教！

这涉及到线性方程组的（数值）解法问题，建议看看相关书籍，比较《计算方法》之类。

最常用的做法就是进行矩阵分解，Cholesky分解、LU分解

也有用迭代法的

‘伍’ JAVA编程 声明一个矩阵类Matrix，有这样一些实例方法：将一个矩阵转置、求两个矩阵的和。

我简单的叙述下，matrix就一个二维数组，矩阵的转置就是对角上的折叠，说白了就是两个值的互换]。求和就非常简单了，必须是行和列都相同的才行，把对应位置的值加起来就ok。转置的具体方式可参考线性代数里的介绍

‘陆’ java构造一个矩阵

1、java构造函数--数组 在构造函数中初始化数组，如 public class array { private int [][] matrix; public array(int r,int c) { matrix=new matrix[r][c]; } }
matrix=new matrix[r][c];
2、这里是new int[][]; java中8个基本数据类型都是有默认值的，int默认值为0 ，
3、所以数组中默认都为0.
4、但是切记有默认值的变量必须是类的属性，方法中局部变量必须赋值才可以使用。

‘柒’ 速求 Strassen 矩阵算法 用Java写

package help;
import java.io.*;
import java.util.*;
class matrix //定义矩阵结构
{
public int[][] m = new int[10][10];
}
public class Strassen
{
public int IfIsEven(int n)//判断输入矩阵阶数是否为2^k
{
int a = 0,temp=n;
while(temp%2==0)
{
if(temp%2==0)
temp/=2;
else a=1;
}
if(temp==1)
a=0;
return a;
}
public void Divide(matrix d,matrix d11,matrix d12,matrix d21,matrix d22,int n)//分解矩阵
{
int i,j;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
d11.m[i][j]=d.m[i][j];
d12.m[i][j]=d.m[i][j+n];
d21.m[i][j]=d.m[i+n][j];
d22.m[i][j]=d.m[i+n][j+n];
}
}
public matrix Merge(matrix a11,matrix a12,matrix a21,matrix a22,int n)//合并矩阵
{
int i,j;
matrix a = new matrix();
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
a.m[i][j]=a11.m[i][j];
a.m[i][j+n]=a12.m[i][j];
a.m[i+n][j]=a21.m[i][j];
a.m[i+n][j+n]=a22.m[i][j];
}
return a;
}
public matrix TwoMatrixMultiply(matrix x,matrix y) //阶数为2的矩阵乘法
{
int m1,m2,m3,m4,m5,m6,m7;
matrix z = new matrix();

m1=(y.m[1][2] - y.m[2][2]) * x.m[1][1];
m2=y.m[2][2] * (x.m[1][1] + x.m[1][2]);
m3=(x.m[2][1] + x.m[2][2]) * y.m[1][1];
m4=x.m[2][2] * (y.m[2][1] - y.m[1][1]);
m5=(x.m[1][1] + x.m[2][2]) * (y.m[1][1]+y.m[2][2]);
m6=(x.m[1][2] - x.m[2][2]) * (y.m[2][1]+y.m[2][2]);
m7=(x.m[1][1] - x.m[2][1]) * (y.m[1][1]+y.m[1][2]);
z.m[1][1] = m5 + m4 - m2 + m6;
z.m[1][2] = m1 + m2;
z.m[2][1] = m3 + m4;
z.m[2][2] = m5 + m1 - m3 - m7;
return z;
}
public matrix MatrixPlus(matrix f,matrix g,int n) //矩阵加法
{
int i,j;
matrix h = new matrix();
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
h.m[i][j]=f.m[i][j]+g.m[i][j];
return h;
}
public matrix MatrixMinus(matrix f,matrix g,int n) //矩阵减法方法
{
int i,j;
matrix h = new matrix();
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
h.m[i][j]=f.m[i][j]-g.m[i][j];
return h;
}

public matrix MatrixMultiply(matrix a,matrix b,int n) //矩阵乘法方法
{
int k;
matrix a11,a12,a21,a22;
a11 = new matrix();
a12 = new matrix();
a21 = new matrix();
a22 = new matrix();
matrix b11,b12,b21,b22;
b11 = new matrix();
b12 = new matrix();
b21 = new matrix();
b22 = new matrix();
matrix c11,c12,c21,c22,c;
c11 = new matrix();
c12 = new matrix();
c21 = new matrix();
c22 = new matrix();
c = new matrix();
matrix m1,m2,m3,m4,m5,m6,m7;
k=n;
if(k==2)
{
c=TwoMatrixMultiply(a,b);
return c;
}
else
{
k=n/2;
Divide(a,a11,a12,a21,a22,k); //拆分A、B、C矩阵
Divide(b,b11,b12,b21,b22,k);
Divide(c,c11,c12,c21,c22,k);

m1=MatrixMultiply(a11,MatrixMinus(b12,b22,k),k);
m2=MatrixMultiply(MatrixPlus(a11,a12,k),b22,k);
m3=MatrixMultiply(MatrixPlus(a21,a22,k),b11,k);
m4=MatrixMultiply(a22,MatrixMinus(b21,b11,k),k);
m5=MatrixMultiply(MatrixPlus(a11,a22,k),MatrixPlus(b11,b22,k),k);
m6=MatrixMultiply(MatrixMinus(a12,a22,k),MatrixPlus(b21,b22,k),k);
m7=MatrixMultiply(MatrixMinus(a11,a21,k),MatrixPlus(b11,b12,k),k);
c11=MatrixPlus(MatrixMinus(MatrixPlus(m5,m4,k),m2,k),m6,k);
c12=MatrixPlus(m1,m2,k);
c21=MatrixPlus(m3,m4,k);
c22=MatrixMinus(MatrixMinus(MatrixPlus(m5,m1,k),m3,k),m7,k);

c=Merge(c11,c12,c21,c22,k); //合并C矩阵
return c;
}
}

public matrix GetMatrix(matrix X,int n)
{
int i,j;
X = new matrix();
Random random = new Random();
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
X.m[i][j] = (int)(Math.random()*10);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
System.out.print(X.m[i][j]+" ");
System.out.println();
}
return X;
}

public matrix UsualMatrixMultiply(matrix A,matrix B,matrix C,int n)
{
int i,j,t,k;
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
{
for (k=1,t=0;k<=n;k++)
t+=A.m[i][k]*B.m[k][j];
C.m[i][j]=t;
}
return C;
}

public static void main(String[] args)throws IOException
{
Strassen instance = new Strassen();
int i,j,n;
matrix A,B,C,D;
A = new matrix();
B = new matrix();
C = new matrix();
D = new matrix();
Scanner in = new Scanner(System.in);
System.out.print("输入矩阵的阶数: ");
n = in.nextInt();
if(instance.IfIsEven(n)==0)
{
System.out.println("矩阵A:");
A=instance.GetMatrix(A,n);
System.out.println("矩阵B:");
B=instance.GetMatrix(B,n);
if(n==1)
C.m[1][1]=A.m[1][1]*B.m[1][1]; //矩阵阶数为1时的特殊处理
else
C=instance.MatrixMultiply(A,B,n);
System.out.println("Strassen矩阵C为:");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
System.out.print(C.m[i][j] + " ");
System.out.println();
}
D = instance.UsualMatrixMultiply(A,B,D,n);
System.out.println("普通乘法矩阵D为:");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
System.out.print(D.m[i][j] + " ");
System.out.println();
}
}
else
System.out.println("输入的阶数不是2的N次方");
}
}

‘捌’ JAVA 矩阵运算 （就剩20分了，豁出去了！）

用二维数组分别定义A和B，
数组中的元素分别初始化为两个矩阵中的元素。
然后矩阵运算就是元素之间的乘积、加和，通过循环控制，最终得到解X

‘玖’ Java编写一个程序实现矩阵的运算加减乘除，（并对其中的异常进行处理）

/**
*矩阵：由m×n个数Aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵
*说白了就是一个二维数组，下面的程序用整形作为数据类型，其他类型运算大同小异
*
*/

publicclassMatrixUtils{

/**
*矩阵运算：加(减法与之类似)
*/
publicstaticint[][]matrixAdd(int[][]addend,int[][]summand){
if(addend==null||addend.length==0){
("addendmatrixisempty!");
}
if(summand==null||summand.length==0){
("summandmatrixisempty!");
}
//矩阵加减要求两个矩阵类型一致，即行列数相同
introw=addend.length;
intcol=addend[0].length;
if(row!=summand.length||col!=summand[0].length){
("!");
}
int[][]sum=newint[row][col];
for(inti=0;i<row;i++){
for(intj=0;j<col;j++){
sum[i][j]=addend[i][j]+summand[i][j];
//sum[i][j]=addend[i][j]-summand[i][j];//减法
}
}
returnsum;
}

/**
*矩阵运算：乘法,没找到除法的运算规则
*/
publicstaticint[][]matrixMultiply(int[][]addend,int[][]summand){
if(addend==null||addend.length==0){
("addendmatrixisempty!");
}
if(summand==null||summand.length==0){
("summandmatrixisempty!");
}
//两个矩阵的乘法仅当第一个矩阵A的列数和另一个矩阵B的行数相等时才能定义。如A是m×n矩阵和B是n×p矩阵，它们的乘积C是一个m×p矩阵
introw=addend.length;
intcol=summand[0].length;
if(addend[0].length!=summand.length){
("!");
}
int[][]sum=newint[row][col];
for(inti=0;i<row;i++){
for(intj=0;j<col;j++){
for(intz=0;z<addend[0].length;z++){
sum[i][j]+=addend[i][z]*summand[z][j];
System.out.println("sum["+i+"]["+j+"]="+sum[i][j]);
}
}
}
returnsum;
}
}

‘拾’ 用java语言做矩阵运算，输入一个m×n的矩阵，再输入一个n×o的矩阵，求其乘积。

这应该是线性数学的矩阵
逻辑思路是：取A矩阵的每一行的各个项去乘以B矩阵每个列的各个项
为了测试，我现在假设A矩阵是4*3， B矩阵是3*2， 你要做的乘操作是4*3*2=24次
import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
int[][]A=new int[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
int[][]B=new int[][]{{1,2},{3,4},{5,6}};
int len_A=A[0].length;//a每行元素数，这里是3
int col_A=A.length;//a每列元素数，这里是4
int len_B=B[0].length;//b每行元素数，这里是2
int col_B=B.length;//b每列元素数，这里是3

int len_a=0;
int col_a=0;
int len_b=0;
int col_b=0;
int sum=0;
while(len_b<len_B)//使B的下一列被A乘
{
col_a=0;
while(col_a<col_A)//使A可以移动至下一行
{
len_a=0;
col_b=0;
while(len_a<len_A)//使A的当前行乘以B的当前列
{
sum+=A[col_a][len_a]*B[col_b][len_b];
len_a++;
col_b++;

}
col_a++;
}
len_b++;
}

System.out.println(sum);
}
}