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);
}
}