楼主: zhukovasky
2768 2

[程序分享] java版本的矩阵计算基础类 [推广有奖]

marshal

教授

61%

还不是VIP/贵宾

-

0%
威望
0 级
论坛币
551 个
通用积分
5.3790
学术水平
46 点
热心指数
49 点
信用等级
30 点
经验
18744 点
帖子
1113
精华
0
在线时间
1805 小时
注册时间
2008-7-27
最后登录
2022-6-18
楼主
zhukovasky 发表于 2013-11-30 14:52:30 |只看作者 |坛友微信交流群|倒序 |AI写论文

+2 论坛币
k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群
赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币
  1. /**
  2. * java的矩阵类以及相关性质
  3. * */
  4. import java.util.Arrays;

  6. public final class Matrix {
  7.         private int rownums;
  8.         private int colnums;
  9.         private Vector[] vectorArrays=null;
  10. //        private double MatrixElements;
  11.        
  12.         /***
  13.          * basic initialization...
  14.          * */
  15.         public Matrix(){}
  16.         /**
  17.          * initialization....
  18.          * */
  19.         public Matrix(int rownums,int colnums){
  20.                 if(isInit(rownums,colnums)){       
  21.                         this.rownums=rownums;
  22.                         this.colnums=colnums;
  23.                         vectorArrays=new Vector[rownums];
  24.                         init();
  25.                         System.out.println(" Matrix initilized succeed!");
  26.                 }else{
  27.                         try{
  28.                                 throw new Exception("Error,please check this matrix");
  29.                         }catch(Exception e){
  30.                                 e.printStackTrace();
  31.                         }
  32.                 }
  33.         }
  34.        
  35.         /**
  36.          * initializing the value of specified position in this matrix...
  37.          * */
  38.         public double setMatrixValue(int rows,int cols,double MatrixElements){

  40.                 if(isOutofBounds(rows,cols)){
  41.                         try{
  42.                                 throw new Exception("Error,please check the Matrix");
  43.                         }catch(Exception e){
  44.                                 e.printStackTrace();
  45.                         }
  46.                 }
  47.        
  48.                 return        setValue(rows,cols,MatrixElements);
  49.                        
  50.                
  51.         }
  52.         /**
  53.          * get the specified position of the matrix
  54.          * */
  55.         public double getMatrixValue(int rows,int cols){
  56.                 if(isOutofBounds(rows,cols)){
  57.                         try{
  58.                                 throw new Exception("Error,please check the Matrix");
  59.                         }catch(Exception e){
  60.                                 e.printStackTrace();
  61.                         }
  62.                 }
  63.                 return vectorArrays[rows-1].peek(cols-1);
  64.                
  65.         }
  66.         /**
  67.          * construct the Matrix contains the value
  68.          * */
  69.         private double setValue(int rows,int cols,double MatrixElements){       
  70.                 return vectorArrays[rows-1].add(cols-1,MatrixElements);
  71.         }
  72.         /**
  73.          * the default value in each cell of this Matrix is 0;
  74.          * */
  75.         public Vector[] init(){
  76.                 for(int i=1;i<=this.rownums;i++){
  77.                         vectorArrays[i-1]=new Vector(colnums);
  78.                         for(int j=1;j<=this.colnums;j++){
  79.                                 vectorArrays[i-1].add(j-1, 0);
  80.                         }
  81.                 }
  82.                 return vectorArrays ;
  83.         }
  84.         /**
  85.          * toString
  86.          * */
  87.         public String toString(){

  89.                 return Arrays.toString(vectorArrays);
  90.         }

  92.         public boolean isInit(int rows,int cols){
  93.                 if(rows*cols<=0){
  94.                         return false;
  95.                 }else{
  96.                         return true;
  97.                 }
  98.         }
  99.         public boolean isOutofBounds(int rows,int cols){
  100.                 if(rows<=0||rows>this.rownums&&cols<=0||cols>this.colnums){
  101.                         return true;
  102.                 }else{
  103.                         return false;
  104.                 }
  105.                        
  106.         }
  107.        
  108.         /**
  109.          * transpose the matrix
  110.          * */
  111.         public Matrix tranposeMatrix(){
  112.                 int rowsT=colnums;
  113.                 int colsT=rownums;
  114.                 Matrix matrixTranspose=new Matrix(rowsT,colsT);
  115.                 for(int i=1;i<=rowsT;i++){
  116.                         for(int j=1;j<=colsT;j++){
  117.                                 matrixTranspose.setMatrixValue(i, j, getMatrixValue(j,i));
  118.                         }
  119.                 }
  120.                 return matrixTranspose;
  121.         }
  122.         /**
  123.          * the multiple of the matrix
  124.          * */
  125.         public Matrix mutiple(Matrix matrix){
  126.                 int rows=matrix.getRownums();
  127.                 int cols=matrix.getColnums();
  128.                 Matrix matrixA=null;
  129.                 if(this.colnums==rows){
  130. //                        matrixA.setRownums(rownums);
  131. //                        matrixA.setColnums(cols);
  132.                         matrixA=new Matrix(rownums,cols);
  133.                         for(int i=1;i<=rownums;i++){
  134.                                 double d=0;
  135.                                 for(int j=1;j<=colnums;j++){
  136.                                         d+=this.getMatrixValue(i, j)*matrix.getMatrixValue(j, i);
  137.                                 }
  138.                                 for(int j=1;j<=cols;j++){
  139.                                         matrixA.setMatrixValue(i, j, d);
  140.                                 }               
  141.                         }
  142.                 }else{
  143.                         try{
  144.                                 throw new Exception("计算失败，请确认该矩阵是否正确");
  145.                         }catch(Exception e){
  146.                                 e.printStackTrace();
  147.                         }
  148.                 }
  149.                 return matrixA;
  150.         }
  151. //        /**
  152. //         * two matrix multiply
  153. //         * */
  154. //        public Matrix mutiple(Matrix matrixA,Matrix matrixB){
  155. //                Matrix matrix=null;
  156. //                if(isMultiple(matrixA,matrixB)){
  157. //                        matrix=new Matrix(matrixA.getRownums(),matrixB.getColnums());
  158. //                        for(int i=1;i<=matrixA.getRownums();i++){
  159. //                                double d=0;
  160. //                                for(int j=1;j<=matrixA.getColnums();j++){
  161. //                                        d+=matrixA.getMatrixValue(i, j)*matrixB.getMatrixValue(j, i);
  162. //                                }
  163. //                                for(int j=1;j<=matrixB.getColnums();j++){
  164. //                                        matrix.setMatrixValue(i, j, d);
  165. //                                }
  166. //                        }
  167. //                }else{
  168. //                        try{
  169. //                                throw new Exception("计算失败，请确认矩阵是否正确");
  170. //                        }catch(Exception e){
  171. //                                e.printStackTrace();
  172. //                        }
  173. //                }
  174. //                return matrix;
  175. //        }
  176.         /**
  177.          * the matrix equals
  178.          * @param precisions
  179.          * */
  180.         public boolean isEqual(Matrix matrix,double eps){
  181.                 if(this.rownums==matrix.getRownums()&&this.colnums==matrix.getColnums()){
  182.                         for(int i=1;i<=rownums;i++){
  183.                                 for(int j=1;j<=colnums;j++){
  184.                                         if((this.getMatrixValue(i, j)-matrix.getMatrixValue(i, j))<=eps){
  185.                                                 return true;
  186.                                         }else{
  187.                                                 return false;
  188.                                         }
  189.                                 }
  190.                         }
  191.                 }
  192.                 return false;
  193.         }
  194.         /**
  195.          * the plus of matrix
  196.          *
  197.          * */
  198.         public Matrix plusMatrix(Matrix matrix){
  199.                 Matrix matrixSum=new Matrix(this.rownums,this.colnums);
  200.                 if(this.rownums==matrix.rownums&&this.colnums==matrix.colnums){
  201.                         for(int i=1;i<=this.rownums;i++){
  202.                                 for(int j=1;j<this.colnums;j++){
  203.                                         matrixSum.setMatrixValue(i, j, this.getMatrixValue(i, j)+matrix.getMatrixValue(i, j));
  204.                                 }
  205.                         }       
  206.                 }else{
  207.                         try{
  208.                                 throw new Exception("请注意，该矩阵无法相加");
  209.                         }catch(Exception e){
  210.                                 e.printStackTrace();
  211.                         }
  212.                 }
  213.                 return matrixSum;
  214.         }
  215.         public Matrix minusMatrix(Matrix matrix){
  216.                 Matrix matrixminus=new Matrix(this.rownums,this.colnums);
  217.                 if(this.rownums==matrix.rownums&&this.colnums==matrix.colnums){
  218.                         for(int i=1;i<=this.rownums;i++){
  219.                                 for(int j=1;j<this.colnums;j++){
  220.                                         matrixminus.setMatrixValue(i, j, this.getMatrixValue(i, j)-matrix.getMatrixValue(i, j));
  221.                                 }
  222.                         }       
  223.                 }else{
  224.                         try{
  225.                                 throw new Exception("请注意，该矩阵无法相加");
  226.                         }catch(Exception e){
  227.                                 e.printStackTrace();
  228.                         }
  229.                 }
  230.                 return matrixminus;
  231.         }

  233. //        /***
  234. //         * @param eps the precisions
  235. //         * */
  236. //        public boolean isEqual(Matrix matrixA,Matrix matrixB,double eps){
  237. //                if(matrixA.isEqual(matrixB, eps)){
  238. //                        return true;
  239. //                }else{
  240. //                        return false;
  241. //                }
  242. //               
  243. //        }
  244.         /**
  245.          * return the boolean of two matrix,multiply by each matrix
  246.          * */
  247.         private boolean isMultiple(Matrix matrix){
  248.                 int rows=matrix.getRownums();
  249.                 int cols=matrix.getColnums();
  250.                 if(this.colnums==rows){
  251.                         return true;
  252.                 }else{
  253.                         return false;
  254.                 }
  255.         }
  256. //        private boolean isMultiple(Matrix matrixA,Matrix matrixB){
  257. //                if(matrixA.isMultiple(matrixB)){
  258. //                        return true;
  259. //                }else{
  260. //                        return false;
  261. //                }
  262. //        }
  263.         /**
  264.          * multiple the constant
  265.          * */
  266.         public Matrix multipleConstant(double K){
  267.                 for(int i=1;i<=this.rownums;i++){
  268.                         for(int j=1;j<=this.colnums;j++){
  269.                                 double d=this.getMatrixValue(i, j)*K;
  270.                                 this.setMatrixValue(i, j, d);
  271.                         }
  272.                 }
  273.                 return this;
  274.         }
  275.         /**
  276.          * vector mutiple by the constant
  277.          * */
  278.         public Vector mutipleConstantV(double K,int cols){
  279.                 if(cols>colnums||cols<=0){
  280.                         try{
  281.                                 throw new Exception("请确认是否有误");
  282.                         }catch(Exception e){
  283.                                 e.printStackTrace();
  284.                         }
  285.                 }
  286.                 for(int i=1;i<=rownums;i++){
  287.                         this.setMatrixValue(i, cols, K*this.getMatrixValue(i, cols));
  288.                 }
  289.                 return this.getVerticalVector(cols);
  290.         }
  291.         /**
  292.          * vector mutiple by the constant
  293.          * */
  294.         public Vector mutipleConstantH(double K,int rows){
  295.                 if(rows>rownums||rows<=0){
  296.                         try{
  297.                                 throw new Exception("请确认是否有误");
  298.                         }catch(Exception e){
  299.                                 e.printStackTrace();
  300.                         }
  301.                 }
  302.                 for(int i=1;i<=colnums;i++){
  303.                         this.setMatrixValue(rows, i, K*this.getMatrixValue(rows, i));
  304.                 }
  305.                 return this.getHorizontalVector(rows);
  306.         }
  307.         /**
  308.          * get the egenValue of this Matrix
  309.          * how? Gaussian 消元法
  310.          * */
  311.         public double egenValue(){
  312.                 double value=1;
  313.                
  314.                 if(this.rownums==this.colnums){
  315.                         for(int j=1;j<=colnums;j++){
  316.                                 double max=this.getMaxAllRowValue(j);
  317.                                 if(Math.abs(max)!=0){
  318.                                         int rows=this.getMaxValueRow(max, j);
  319.                                         for(int i=1;i<this.getRownums();i++){
  320.                                                 this.SwapMatrixValue(i, j, rows, j);
  321.                                                 Vector vector=this.getHorizontalVector(i+1);
  322.                                                 Vector vectorH=mutipleConstantH((1/max),i);                //归一化
  323.                                                 Vector vectorU=vector.vecMinus(vectorH.vecMutipleConstant(vectorH.peek(j-1)));
  324.                                                 this.setMatrixHVector(i, vectorU);
  325.                                         }
  326.                                 }
  327.                         }
  328.                         for(int i=1;i<=rownums;i++){
  329.                                 value*=this.getMatrixValue(i, i);
  330.                         }

  332.                 }else{
  333.                         try{
  334.                                 throw new Exception("不是行列式，请确认");
  335.                         }catch(Exception e){
  336.                                 e.printStackTrace();
  337.                         }
  338.                 }
  339.                 return value;

  341.         }
  342.         /**
  343.          * return the max of the specified cols given the rows
  344.          *
  345.          * @param cols指定列的所有行的最大值
  346.          * */
  347.        
  348.         public double getMaxAllRowValue(int cols){
  349.                 double max=this.getMatrixValue(1, cols);
  350.                 for(int i=1;i<=this.rownums;i++){
  351.                         if(this.getMatrixValue(i, cols)>max){
  352.                                 max=this.getMatrixValue(i, cols);
  353.                         }
  354.                 }
  355.                
  356.                 return max;
  357.         }
  358.         /**
  359.          * 获取指定列最大值的行值
  360.          * */
  361.         public int getMaxValueRow(double max,int cols){
  362.                 int positions=1;
  363.                 for(int i=1;i<=this.rownums;i++){
  364.                         if(this.getMatrixValue(i, cols)==max){
  365.                                 positions=i;
  366.                                 break;
  367.                         }
  368.                 }
  369.                 return positions;
  370.         }
  371.         /**
  372.          *the following method is to Swap the values of the specified positions
  373.          * */
  374.         public Matrix SwapMatrixValue(int rows1,int cols1,int row2,int cols2){
  375.                 double a=this.getMatrixValue(rows1, cols1);
  376.                 double b=this.getMatrixValue(row2, cols2);
  377.                 this.setMatrixValue(rows1, cols1, b);
  378.                 this.setMatrixValue(row2, cols2, a);
  379.                 return this;
  380.         }
  381.         /**
  382.          * the following method is to get the horizontal vectors;
  383.          * */
  384.         public Vector getHorizontalVector(int rows){
  385.                 Vector vector=new Vector(this.colnums);
  386.                 for(int i=1;i<=vector.length();i++){
  387.                         vector.add(i-1, this.getMatrixValue(rows, i));
  388.                 }
  389.                 return vector;
  390.         }
  391.         public Vector getVerticalVector(int cols){
  392.                 Vector vector=new Vector(this.rownums);
  393.                 for(int i=1;i<=vector.length();i++){
  394.                         vector.add(i-1, this.getMatrixValue(i, cols));
  395.                 }
  396.                 return vector;
  397.         }
  398.         /**
  399.          * 以下设置矩阵列向量
  400.          * */
  401.         public Matrix setMatrixVVector(int cols,Vector vector){
  402.                 if(cols>colnums||vector.length()>rownums){
  403.                         try{
  404.                                 throw new Exception("请确认该向量");
  405.                         }catch(Exception e){
  406.                                 e.printStackTrace();
  407.                         }
  408.                 }
  409.                 for(int i=0;i<vector.length();i++){
  410.                         this.setMatrixValue(i+1, cols, vector.peek(i));
  411.                 }
  412.                 return this;
  413.         }
  414.         /**
  415.          * 以下设置矩阵行向量
  416.          * @param rows 指定行
  417.          * */
  418.         public Matrix setMatrixHVector(int rows,Vector vector){
  419.                 if(rows>rownums||vector.length()>colnums){
  420.                         try{
  421.                                 throw new Exception("请确认该向量");
  422.                         }catch(Exception e){
  423.                                 e.printStackTrace();
  424.                         }
  425.                 }
  426.                 for(int i=0;i<vector.length();i++){
  427.                         this.setMatrixValue(rows, i+1, vector.peek(i));
  428.                 }
  429.                 return this;
  430.         }
  431.         public int getRownums() {
  432.                 return rownums;
  433.         }
  434.         public void setRownums(int rownums) {
  435.                 this.rownums = rownums;
  436.         }
  437.         public int getColnums() {
  438.                 return colnums;
  439.         }
  440.         public void setColnums(int colnums) {
  441.                 this.colnums = colnums;
  442.         }
  443. }
复制代码
以下代码是向量类的代码
  1. import java.util.Arrays;
  2. import java.util.HashMap;
  3. import java.util.Map;

  5. public class Vector {
  6.         private int MaxSize;
  7.         private double[] vectorArray;
  8.         private int cursor;
  9.         public Vector(int MaxSize){
  10.                 this.MaxSize=MaxSize;
  11.                 vectorArray=new double[this.MaxSize];
  12.                 this.cursor=-1;
  13.         }
  14.         public double[] add(double s){
  15.                 vectorArray[++cursor]=s;
  16.                 return vectorArray;
  17.         }
  18.         public double add(int cursors,double s){
  19.                 return vectorArray[cursors]=s;
  20.         }
  21.         public double peek(int cursor){
  22.                 return vectorArray[cursor];
  23.         }
  24.         public double[] remove(double s){
  25.                 Map<Double,Integer> map=new HashMap<Double,Integer>();
  26.                 for(int i=0;i<vectorArray.length;i++){
  27.                         int count=0;
  28.                         for(int j=0;j<vectorArray.length;j++){
  29.                                 if(vectorArray[j]==s){
  30.                                         map.put((double)i, count++);
  31.                                 }
  32.                         }
  33.                 }
  34.                 for(int i=0;i<vectorArray.length;i++){
  35.                         for(int j=0;j<i;j++){
  36.                                 if(vectorArray[j]==s){
  37.                                         double temp=vectorArray[i];
  38.                                         vectorArray[i]=vectorArray[j];
  39.                                         vectorArray[j]=temp;
  40.                                 }
  41.                         }
  42.                 }
  43.                 double[] newvectorArray=new double[map.size()];
  44.                 System.out.println(map.size());
  45.                 for(int i=0;i<newvectorArray.length;i++){
  46.                         newvectorArray[i]=vectorArray[i];
  47.                 }
  48.                 System.out.println(Arrays.toString(vectorArray));
  49.                 return newvectorArray;
  50.         }
  51.         public Vector vecAdd(Vector vector){
  52.                 Vector newVector=new Vector(this.length());
  53.                 if(this.length()==vector.length()){
  54.                         for(int i=0;i<vector.length();i++){
  55.                                 newVector.add(i, (this.peek(i)+vector.peek(i)));
  56.                         }
  57.                 }else{
  58.                         try{
  59.                                 throw new Exception("请确认该向量的长度");
  60.                         }catch(Exception e){
  61.                                 e.printStackTrace();
  62.                         }
  63.                 }
  64.                 return newVector;
  65.         }
  66.         public Vector vecMinus(Vector vector){
  67.                 Vector newVector=new Vector(this.length());
  68.                 if(this.length()==vector.length()){
  69.                         for(int i=0;i<vector.length();i++){
  70.                                 newVector.add(i, (this.peek(i)-vector.peek(i)));
  71.                         }
  72.                 }else{
  73.                         try{
  74.                                 throw new Exception("请确认该向量的长度");
  75.                         }catch(Exception e){
  76.                                 e.printStackTrace();
  77.                         }
  78.                 }
  79.                 return newVector;
  80.         }
  81.         /**
  82.          * mutiple
  83.          * */
  84.         public Vector vecMutipleConstant(double K){
  85.                 Vector vector=new Vector(this.length());
  86.                 for(int i=0;i<this.length();i++){
  87.                         vector.add(i, this.peek(i));
  88.                 }
  89.                 return vector;
  90.         }
  91.         /**
  92.          * mutiple by vector
  93.          * */
  94.         public double vecMutipleVector(Vector vector){
  95.                 double d=0;
  96.                 if(this.length()==vector.length()){
  97.                         for(int i=0;i<this.length();i++){
  98.                                 d+=this.peek(i)*vector.peek(i);
  99.                         }
  100.                 }
  101.                 return d;
  102.         }
  103.         public boolean isFull(){
  104.                 return (MaxSize==cursor);
  105.         }
  106.         public boolean isEmpty(){
  107.                 return (cursor==-1);
  108.         }
  109.         public String toString(){
  110.                 return Arrays.toString(vectorArray)+"\n";
  111.         }
  112.         public int length(){
  113.                 return vectorArray.length;
  114.         }
  115. }
复制代码
本程序计算行列式值采用高斯消元法还有些问题，不管咋样，先发上来，
有人做了向量机。我也来写。后面发。
二维码

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0
关键词：Java jav exception specified Elements private Vector public Matrix double

相关帖子

已有 1 人评分经验 论坛币 学术水平 收起 理由
Xaero + 60 + 60 + 1 精彩帖子

总评分: 经验 + 60  论坛币 + 60  学术水平 + 1   查看全部评分

za rujina!

使用道具

沙发
zhukovasky 发表于 2013-12-2 22:14:36 |只看作者 |坛友微信交流群
感谢版主大神的加分，这个Matrix的求逆方法有些问题，所以重新补上新的用高斯消元法求解。
这段代码来自于VB版本，本人加工成java版本。
代码如下：
  1.         public Matrix getAdverMatrix(){
  2.                 int[] A=new int[this.rownums];
  3.                 int[] B=new int[this.colnums];
  4.                 int i,j,k,N;
  5.                 double D;
  6.                 if(this.rownums!=this.colnums){
  7.                         try{
  8.                                 throw new Exception("请确认该矩阵是否为行列式");
  9.                         }catch(Exception e){
  10.                                 e.printStackTrace();
  11.                         }
  12.                 }
  13.                 N=rownums;
  14.                 for(k=1;k<=N;k++){
  15.                         D=0;
  16.                         for(i=k;i<=N;i++){
  17.                                 for(j=k;j<=N;j++){
  18.                                         if(Math.abs(this.getMatrixValue(i, j))>D){
  19.                                                 D=Math.abs(this.getMatrixValue(i, j));
  20.                                                 A[k-1]=i;
  21.                                                 B[k-1]=j;
  22.                                         }
  23.                                 }
  24.                         }
  25.                         if(D+1==1){
  26.                                 System.out.println("该矩阵不可逆");
  27.                                 break;
  28.                         }

  30.                         if(A[k-1]!=k){
  31.                                 for(j=1;j<=N;j++){
  32.                                         this.SwapMatrixValue(k, j, A[k-1], j);
  33.                                 }
  34.                         }

  36.                         if(B[k-1]!=k){
  37.                                 for(i=1;i<=N;i++){
  38.                                         this.SwapMatrixValue(i, k, i, B[k-1]);
  39.                                 }
  40.                         }
  41.        
  42.                         double f=this.getMatrixValue(k, k);
  43.                         this.setMatrixValue(k, k, (1/f));
  44.                         for(j=1;j<=N;j++){
  45.                                 if(j!=k){
  46.                                         double d1=this.getMatrixValue(k, j);
  47.                                         double d2=this.getMatrixValue(k, k);
  48.                                         this.setMatrixValue(k, j, d1*d2);
  49.                                 }
  50.                         }

  52.                         for(i=1;i<=N;i++){

  54.                                 if(i!=k){
  55.                                         for(j=1;j<=N;j++){
  56.                                                 if(j!=k){

  58.                                                         double d=this.getMaxValueRow(i, j);

  60.                                                         double d1=this.getMatrixValue(i, k);

  62.                                                         double d2=this.getMatrixValue(k, j);
  63.                                                         this.setMatrixValue(i, j, d-d1*d2);
  64.                                                 }
  65.                                         }
  66.                                 }
  67.                         }

  69.                         for(i=1;i<=N;i++){
  70.                                 if(i!=k){
  71.                                         double d1=this.getMatrixValue(i, k);
  72.                                         double d2=this.getMatrixValue(k, k);
  73.                                         this.setMatrixValue(i, k, -1*d1*d2);
  74.                                 }
  75.                         }

  77.                 }

  79.                 for(k=N;k>=1;k--){
  80.                         if(B[k-1]!=k){
  81.                                 for(j=1;j<=N;j++){
  82.                                         this.SwapMatrixValue(k, j, B[k-1], j);
  83.                                 }
  84.                         }
  85.                         if(A[k-1]!=k){
  86.                                 for(i=1;i<=N;i++){
  87.                                         this.SwapMatrixValue(i, k, i, A[k-1]);
  88.                                 }
  89.                         }
  90.                 }
  91.                 return this;
  92.         }
复制代码
za rujina!

使用道具

藤椅
zhukovasky 发表于 2013-12-2 22:16:03 |只看作者 |坛友微信交流群
经过实地检测本代码最能够支持到2560*2560矩阵的计算，包括求逆。乐观的估计，本周末，本人发上java版本的向量机基础类，
之前有个台湾人已经写了，没测，不想看。
za rujina!

使用道具

返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 我要注册

本版微信群
加好友,备注cda
拉您进交流群
  • 手机版  |
  • 意见反馈  |
  • 帮助  |
  • 新手入门  |
  • 用户手册  |
  • 友情链接  |

    • 如有投资本站、合作意向或投放广告，请联系：13661292478（刘老师）

    联系客服

    邮箱：service@pinggu.org 投诉或不良信息处理：（010-68466864）

    010-68466864

    京ICP备16021002-2号 京B2-20170662号 京公网安备 11010802022788号 论坛法律顾问：王进律师 知识产权保护声明   免责及隐私声明

    GMT+8, 2024-4-27 14:38