（原创）一般矩阵 Matrix类

讨论矩阵的两种表示方法，一种用一维数组来存储矩阵元素，另一种用二维数组来存储矩阵元素。然后比较两种方法，并测试它们的性能，做出总结。

1.一维数组形式

主要代码：

public class Matrix implements CloneableObject{
int rows,cols;
Object [] element;

public Matrix(int theRows,int theCols){
rows=theRows;
cols=theCols;
element=new Object[rows*cols];
}
public Object clone(){
Matrix x=new Matrix(rows,cols);
for(int i=0;i<rows*cols;i++){
x.element[i]=((CloneableObject)element[i]).clone();
}
return x;
}
public void copy(Matrix m){
if(this!=m){
rows=m.rows;
cols=m.cols;
element=new Object[rows*cols];
for(int i=0;i<rows*cols;i++){
element[i]=((CloneableObject)m.element[i]).clone();
}
}
}
public Object get(int i,int j){
checkIndex(i,j);
return element[(i-1)*cols+(j-1)];
}
private void checkIndex(int i, int j) {
// TODO Auto-generated method stub
if(i<1||j<1||i>rows||j>cols){
throw new IndexOutOfBoundsException("");
}
}
public void set(int i,int j,Object newValue){
checkIndex(i,j);
element[(i-1)*cols+(j-1)]=((CloneableObject)newValue).clone();
}
public Matrix add(Matrix m){
if(rows!=m.rows||cols!=m.cols){
throw new IllegalArgumentException("can not add");
}
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).add(m.element[i]);
}
return w;
}
public Matrix sub(Matrix m){
if(rows!=m.rows||cols!=m.cols){
throw new IllegalArgumentException("can not subtract");
}
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).subtract(m.element[i]);
}
return w;
}
public Matrix multiply(Matrix m){
if(cols!=m.rows){
throw new IllegalArgumentException("can not multiply");
}
Matrix w=new Matrix(rows,m.cols);
int ct=0,cm=0,cw=0;
for(int i=1;i<=rows;i++){
for(int j=1;j<=m.cols;j++){
Computable sum=(Computable) (((Computable)element[ct]).multiply(m.element[cm]));
for(int k=2;k<=cols;k++){
ct++;
cm+=m.cols;
sum.increment(((Computable)element[ct]).multiply(m.element[cm]));
}
w.element[cw++]=sum;
ct-=cols-1;
cm=j;
}
ct+=cols;
cm=0;
}
return w;
}
public Matrix transpose(){
Matrix w=new Matrix(cols,rows);
for(int i=1;i<=rows;i++){
for(int j=1;j<=cols;j++){
w.element[(j-1)*cols+i-1]=element[(i-1)*rows+j-1];
}
}
return w;
}
public Matrix decrement(Object x){
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).decrement(x);
}
return w;
}
public Matrix increment(Object x){
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).increment(x);
}
return w;
}
public Matrix multiplyByConstant(Object x){
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).multiply(x);
}
return w;
}
public Matrix dividedByConstant(Object x){
Matrix w=new Matrix(rows,cols);
int n=rows*cols;
for(int i=0;i<n;i++){
w.element[i]=((Computable)element[i]).divide(x);
}
return w;
}
public String toString(){
StringBuilder s=new StringBuilder();
int n=rows*cols;
for(int i=0;i<n;i++){
s=s.append("\t"+element[i].toString()+" ");
if((i+1)%cols==0){
s.append("\n");
}
}
return s.toString();
}
}

这里的接口CloneableObject只有一个clone方法

public interface CloneableObject extends Cloneable

{public Object clone();}

Computable接口代码:

public interface Computable
{
/** @return this + x */
public Object add(Object x);

/** @return this - x */
public Object subtract(Object x);

/** @return this * x */
public Object multiply(Object x);

/** @return quotient of this / x */
public Object divide(Object x);

/** @return remainder of this / x */
public Object mod(Object x);

/** @return this incremented by x */
public Object increment(Object x);

/** @return this decremented by x */
public Object decrement(Object x);

/** @return the additive zero element */
public Object zero();

/** @return the multiplicative identity element */
public Object identity();
}

这里的Matrix类有三个数据成员rows，cols，element[],分别表示矩阵的行数，列数和矩阵的内容。并定义了构造方法public Matrix(int theRows,int theCols)，矩阵构造函数的复杂度是O(rows*cols),如果我们假设复制一个矩阵项，两个矩阵项想家以及将一个矩阵项转换为字符串的时间为θ(1)，那么方法clone，copy，add，toString的渐进复杂度也都是O(rows*cols)。矩阵乘法的复杂度是O(rows*cols*m.cols)。

2.二维数组形式

主要代码

public class MatrixAs2DArray implements CloneableObject{

Object [][] element;
int rows,cols;

public MatrixAs2DArray(int rows,int cols){
element=new Object[rows][cols];
this.rows=rows;
this.cols=cols;
}

public Object clone(){
MatrixAs2DArray w=new MatrixAs2DArray(rows,cols);
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
w.element[i][j]=((CloneableObject)element[i][j]).clone();
}
}
return w;
}
public void copy(MatrixAs2DArray m){
rows=m.rows;
cols=m.cols;
element=new Object[rows][cols];
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
element[i][j]=((CloneableObject)m.element[i][j]).clone();
}
}
}
public Object get(int i,int j){
checkIndex(i,j);
return element[i-1][j-1];
}
private void checkIndex(int i, int j) {
// TODO Auto-generated method stub
if(i<1||j<1||i>rows||j>cols){
throw new IndexOutOfBoundsException("");
}
}
public void set(int i,int j,Object newValue){
checkIndex(i,j);
element[i-1][j-1]=((CloneableObject)newValue).clone();
}
public MatrixAs2DArray add(MatrixAs2DArray m){
if(rows!=m.rows||cols!=m.cols){
throw new IllegalArgumentException("can not add");
}
MatrixAs2DArray w=new MatrixAs2DArray(rows,cols);
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
w.element[i][j]=((Computable)element[i][j]).add(m.element[i][j]);
}
}
return w;
}
public MatrixAs2DArray subtract(MatrixAs2DArray m){
if(rows!=m.rows||cols!=m.cols){
throw new IllegalArgumentException("can not add");
}
MatrixAs2DArray w=new MatrixAs2DArray(rows,cols);
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
w.element[i][j]=((Computable)element[i][j]).subtract(m.element[i][j]);
}
}
return w;
}
public MatrixAs2DArray multiply(MatrixAs2DArray m){
if(cols!=m.rows){
throw new IllegalArgumentException("can not multiply");
}
MatrixAs2DArray w=new MatrixAs2DArray(rows,m.cols);
for (int i = 0; i < rows; i++)
for (int j = 0; j < w.cols; j++)
{// compute [i][j] term of result

// compute first term of w(i,j)
Computable sum =  (Computable) ((Computable)element[i][0])
.multiply(m.element[0][j]);

// add in remaining terms
for (int k = 1; k < cols; k++)
sum.increment(((Computable) element[i][k]).multiply
(m.element[k][j]));

w.element[i][j] = sum;
}
return w;
}
public String toString(){
StringBuilder s=new StringBuilder();
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
s.append("\t"+element[i][j].toString()+" ");
}
s.append("\n");
}
return s.toString();
}
}

这里为了以示区别类名称用的是MatrixAs2DArray，依然是三个数据成员rows，cols，element[][],只是这里element变成二维数组了。其各个方法的复杂度与Matrix类是一样的。

3.比较

设要表示的矩阵大小为m*n的，假设元素都是int类型的，如果用一维数组(x[mn])存储要占用4mn+4个字节，其中4mn个字节用来存储数据，4个字节用来存储数组长度。如果用二维数组(x[m]
)来存储要占用4mn+8m+4个字节，其中4m个字节用来存储x[]指针，4个字节用来存储x[]指针长度，每一个x[]数组要4n+4个字节来存储，共有m个。从内存角度上来说，一维数组形式所占内存较少更有优势。

接下来对矩阵加法操作和乘法操作进行试验来比较性能。

代码：

public class MatrixPerformanceTest {

public static void main(String args[]){
for(int n=30;n<1000;n=n*2){
Matrix m1=new Matrix(n,n);
Matrix m2=new Matrix(n,n);
MatrixAs2DArray ma1=new MatrixAs2DArray(n,n);
MatrixAs2DArray ma2=new MatrixAs2DArray(n,n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
{
MyInteger q1 = new MyInteger(2 * i + j);
MyInteger q2 = new MyInteger(2 *j+3*i);
m1.set(i, j, q1);
m2.set(i, j, q2);
ma1.set(i, j, q1);
ma2.set(i, j, q2);
}
long startTime1=System.currentTimeMillis();
int count1=0;
do{
m1.add(m2);
count1++;
}while((System.currentTimeMillis()-startTime1)<1000);
long elapsedTime1=(System.currentTimeMillis()-startTime1)/count1;
System.out.print("n="+n+"时:1方法加法耗时:"+elapsedTime1+"  ");

long startTime2=System.currentTimeMillis();
int count2=0;
do{
ma1.add(ma2);
count2++;
}while((System.currentTimeMillis()-startTime2)<1000);
long elapsedTime2=(System.currentTimeMillis()-startTime2)/count2;
System.out.println("n="+n+"时:2方法加法耗时:"+elapsedTime2);

long startTime3=System.currentTimeMillis();
int count3=0;
do{
m1.multiply(m2);
count3++;
}while((System.currentTimeMillis()-startTime3)<1000);
long elapsedTime3=(System.currentTimeMillis()-startTime3)/count3;
System.out.print("n="+n+"时:1方法乘法耗时:"+elapsedTime3+"  ");

long startTime4=System.currentTimeMillis();
int count4=0;
do{
ma1.multiply(ma2);
count4++;
}while((System.currentTimeMillis()-startTime4)<1000);
long elapsedTime4=(System.currentTimeMillis()-startTime4)/count4;
System.out.println("n="+n+"时:2方法乘法耗时:"+elapsedTime4);
}
System.out.println("测试结束");
}
}

结果:

n=30时:1方法加法耗时:0 n=30时:2方法加法耗时:0

n=30时:1方法乘法耗时:0 n=30时:2方法乘法耗时:0

n=60时:1方法加法耗时:0 n=60时:2方法加法耗时:0

n=60时:1方法乘法耗时:4 n=60时:2方法乘法耗时:3

n=120时:1方法加法耗时:0 n=120时:2方法加法耗时:0

n=120时:1方法乘法耗时:35 n=120时:2方法乘法耗时:35

n=240时:1方法加法耗时:1 n=240时:2方法加法耗时:2

n=240时:1方法乘法耗时:362 n=240时:2方法乘法耗时:378

n=480时:1方法加法耗时:5 n=480时:2方法加法耗时:8

n=480时:1方法乘法耗时:3752 n=480时:2方法乘法耗时:3952

n=960时:1方法加法耗时:44 n=960时:2方法加法耗时:34

n=960时:1方法乘法耗时:37277 n=960时:2方法乘法耗时:39904

测试结束

从结果可以看到对于加法，二维数组形式表现更好，但差别不大，对于乘法一维数组形式表现更好。

4.总结

实际上以上两种方法矩阵的乘法还可以进一步改进。这里以对二维形式表示的矩阵类的乘法为例进行改进（一维数组形式可以类似进行修改)

代码:

public MatrixAs2DArray multiply(MatrixAs2DArray m){
if(cols!=m.rows){
throw new IllegalArgumentException("can not multiply");
}
MatrixAs2DArray w=new MatrixAs2DArray(rows,m.cols);
for(int i=0;i<rows;i++){
for(int j=0;j<m.cols;j++){
w.element[i][j]=((Computable)element[i][0]).multiply(m.element[0][j]);
}
}
for(int i=0;i<rows;i++){
for(int k=1;k<cols;k++){
for(int j=0;j<m.cols;j++){
Object temp=((Computable)element[i][k]).multiply(m.element[k][j]);
w.element[i][j]=((Computable) w.element[i][j]).add(temp);
}
}
}
}

实际上这里只是对乘法里面的三个嵌套的for循环顺序做了修改，但是由于将相乘的两个矩阵都行优先进行读取计算，使得缓存遗漏减少，增加了运算效率。下面是用改进后的二维数组形式进行的与之前一样的测试。

结果：

n=30时:1方法加法耗时:0 n=30时:2方法加法耗时:0

n=30时:1方法乘法耗时:0 n=30时:2方法乘法耗时:1

n=60时:1方法加法耗时:0 n=60时:2方法加法耗时:0

n=60时:1方法乘法耗时:3 n=60时:2方法乘法耗时:8

n=120时:1方法加法耗时:0 n=120时:2方法加法耗时:0

n=120时:1方法乘法耗时:34 n=120时:2方法乘法耗时:71

n=240时:1方法加法耗时:1 n=240时:2方法加法耗时:1

n=240时:1方法乘法耗时:331 n=240时:2方法乘法耗时:568

n=480时:1方法加法耗时:5 n=480时:2方法加法耗时:8

n=480时:1方法乘法耗时:3827 n=480时:2方法乘法耗时:4051

n=960时:1方法加法耗时:31 n=960时:2方法加法耗时:20

n=960时:1方法乘法耗时:36809 n=960时:2方法乘法耗时:31258

测试结束

可以看到乘法明显比修改之前更快，甚至超过了一维数组形式的乘法。不过如果对一维数组形式的乘法也进行改进，其乘法运算速度还是会超过二维数组形式的。