（原创）一般矩阵 Matrix类

最新推荐文章于 2024-08-15 13:59:24 发布
最新推荐文章于 2024-08-15 13:59:24 发布
阅读量1.8k 收藏 2
点赞数 1
文章标签： java matrix 存储 效率比较
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jecode/article/details/49871577
版权

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

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][n])来存储要占用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
测试结束

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

JeCode
关注
python：实现spiral matrix螺旋矩阵(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-17 245
python：实现spiral matrix螺旋矩阵(附完整源码)
Matrix矩阵类
Beronhider的博客
04-16 2260
题目描述 编写矩阵类Matrix，包含以下成员变量：整数变量 row_size, col_size, 分别表示矩阵的行数与列数，整数的二维数组 values[][]，表示一个整数矩阵. 包含以下成员方法：void setMatrix(int m, int n)方法： 参变量 m，n分别赋值给成员变量 row_size, col_size, 并由键盘输入，完成 values 数组元素的赋值。
EmguCV学习笔记 C# 2.2 Matrix类
最新发布
UruseiBest 的技术专栏
08-15 990
Matrix类是EmguCV中的一个矩阵类，它可以用来存储和处理矩阵数据，可以处理任意维度的矩阵。与Mat类相比，Matrix类提供了更多的矩阵运算方法，如矩阵加减、乘法、逆矩阵等，也更加灵活，而且底层实现也更加高效。例如，当均值为0，标准差为1时，生成的随机矩阵的像素值符合标准正态分布。当均值为0，标准差为0.5时，生成的随机矩阵的像素值分布更加集中，更接近于均值。该控件位于【工具箱】|【Emgu.CV】下面。SetRandNormal方法只能生成正态分布的随机矩阵，不能生成其他分布的随机矩阵。
关于矩阵类Matrix
weixin_30846599的博客
10-30 722
将matlab程序转换成C++的时候，矩阵运算真让人头疼，分享一下矩阵类的C++实现。 头文件Matrix.h 1 //Matrix.h 2 //矩阵类定义 3 4 #ifndef MATRIX_H 5 #define MATRIX_H 6 #include <iostream> 7 #include <string> 8 //u...
矩阵类 Matrix
GIS_Master的专栏
04-18 1659
最近和张同学一起了用C++写了一个矩阵类，类中包括矩阵的求逆、相乘、转置类的实现并不难，其中网上找了一些资料，通过测试该类运行良好。希望能和大家一起分享，如有错误或更好的建议，请联系我！ 测试代码 #pragma once#include #include using namespace std;class Matrix{public: Matrix(int i,i
矩阵类(matrix class)
07-03
一个矩阵处理类,matrix.h,包括几个示例
原创CODESYS操作Matrix33矩阵运算的功能块库文件
05-22
内容概要：原创的CODESYS操作Matrix3阶方阵矩阵运算的功能块的编译库。调用库内功能块可便捷实现对Matrix3阶方矩矩阵运算。 1，3阶方矩加法，减法，点乘，叉乘，左乘常数，右乘1列。 2，3阶方矩的求行列式，转置，...
C++：实现量化相关的Matrix矩阵测试实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-18 358
C++：实现量化相关的Matrix矩阵测试实例
java matrix_[Java]编写自己的Matrix矩阵类
weixin_42356811的博客
02-12 1812
用java实现一个简单的矩阵类，可以实现简单的矩阵计算功能。class Matrix1.向量点乘public static double dot(double[] x,double[] y)2.矩阵和向量之积public static double[] mult(double[][] a,double[] x)3.向量和矩阵之积public static double[] mult(double[...
Go：matrix chain multiplication矩阵链乘法算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-19 298
Go：matrix chain multiplication矩阵链乘法算法(附完整源码)
matrix类c#实现
03-22
实现了矩阵的加减乘除及转置，求逆等的一个类，，可以直接调用
CMatrix2.0版本
10-07
通过重载运算符实现矩阵运算，比上一个版本更方便.... 实现常见的各种运算....
CMatrix 类的相关操作
07-25
代码里面包含设置矩阵，矩阵的加、减、乘、除等重载运算
声明一个矩阵类Matrix，有这样一些实例方法：将一个矩阵转置、求两个矩阵的和。
常程序员
11-12 6048
 声明一个矩阵类Matrix，有这样一些实例方法：将一个矩阵转置、求两个矩阵的和。public class Matrix{private int mx[][],m,n;  public Matrix(int r,int c) {m=r;   n=c;   mx=new int[m][n];   iniMatrix();} public Matrix()  {m=
Matrix矩阵类的学习总结
Mis_wenwen的博客
05-26 958
(1)Matrix矩阵类的学习总结 实例： MatrixmMatrix=new Matrix(); mMatrix.postTranslate(intx,int y); ImageViewmImageView=(ImageView)findViewById(R.id.xxx); mImageView.setImageMatrix(mMatrix); 上例实现在图片在所在
定义Matrix类，为该类提供各种功能
suxuanxuan的博客
11-08 1657
定义Matrix类，为该类提供各种功能 定义Matrix类需要用到动态开辟二维数组 //动态开辟数组 element = new int *[row]; for (int i = 0; i < row; i++) { element[i] = new int[col]; } Matrix类的定义 class Matrix { > private: > int row, col; > int **element =
矩阵类C++实现
热门推荐
yangalbert的专栏
03-23 3万+
（1） Matrix.h 文件 #ifndef __MATRIX_H__ #define __MATRIX_H__ #include #include #include #include #include using std::vector; using std::string; using std::cout; using std::cin; using std::istream
【C#】2. Matrix 数据
huiwuhuiwu的专栏
02-28 994
Matrix部分，下面有篇关于NumericMatrix会继承它！原创~
Matrix Cookbook：矩阵公式宝典
"matrix cookbook—矩阵公式大全" 《矩阵食谱》(The Matrix Cookbook) 是一本由Kaare Brandt Petersen和Michael Syskind Pedersen编写的矩阵理论参考手册，旨在为需要快速查阅矩阵相关公式和性质的读者提供便利。这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值