matrix.hpp

基于线性规划的回归支持向量机源程序

		 //ppt=m
         //converts matrix to double **.
         operator double **();

		 //mresult=m
         matrix &  operator=( matrix & m);

		 //mresult=v
         matrix &  operator=( vector  & v);

		 //mresult=x
         matrix &  operator=(double x);

		//mresult=m1+m2
        friend matrix operator+(matrix & m1,
                    matrix & m2);

		//mresult=m1-m2
        friend matrix operator-(matrix & m1,
                    matrix & m2);

		//mresult=m1*m2
        friend matrix operator*(matrix & m1,
                    matrix & m2);

		//mresult=m1/m2
        friend matrix operator/(matrix & m1,
                    matrix & m2);

		//mresult=m1+x
        friend matrix operator+(matrix & m1, double x);

		//mresult=m1-x
        friend matrix operator-(matrix & m1, double x);

		//mresult=m1*x
        friend matrix operator*(matrix & m1, double x);

		//vresult=m1*v2
        friend vector operator*(matrix & m1,
                                vector & v2);
		//vresult=v1*m2
        friend vector operator*(vector & v1,
                                 matrix & m2);
		//mresult=m1/x
        friend matrix operator/(matrix & m1, double x);

		//mresult=x+m1
        friend matrix operator+(double x, matrix & m1);

		//mresult=x-m1
        friend matrix operator-(double x, matrix & m1);

		//mresult=x*m1
        friend matrix operator*(double x, matrix & m1);

		//mresult=x/m1
        friend matrix operator/(double x, matrix & m1);

		//mresult=+m1
        friend matrix operator+(matrix & m1);

		//mresult=-m1
        friend matrix operator-(matrix & m1);

		//mresult+=m1
        matrix &  operator+=(matrix & m1);

		//mresult-=m1
        matrix &  operator-=(matrix & m1);

		//mresult/=m1
        matrix &  operator/=(matrix & m1);

		//mresult+=x
        matrix &  operator+=(double x);

		//mresult-=x
        matrix &  operator-=(double x);

		//mresult*=x
        matrix &  operator*=(double x);

		//mresult/=x
        matrix &  operator/=(double x);

		//mresult=m1.prod(m2) or mresult=prod(m1,m2)
        matrix prod(matrix & m2);
        friend matrix prod(matrix & m1,matrix & m2);

		//vresult=m[i]
        vector &  operator[](int i);
        double &  operator()(int i,int j);

		//iresult=(m1==m2)
        friend int operator==(matrix & m1, matrix & m2);

		//iresult=(m1!=m2)
        friend int operator!=(matrix & m1, matrix & m2);

        //cin>>m
        friend istream &  operator>>(istream &, matrix & m);

        //cout<<m
        friend ostream &  operator<<(ostream &, matrix & m);

		//vresult=m.row(n) or vresult=row(m,n)
		//returns a special row of a matrix.
        vector row(int n);
        friend vector row(matrix & m,int n);

		//vresult=m.col(n) or vresult=col(m,n)
		//returns a special column of a matrix.
        vector col(int n);
        friend vector col(matrix & m,int n);

		//mresult=m.slice(row,col) or  mresult=slice(m,row,col)
		//returns a submatrix of m. it is row*col and mresult[0][0]=x[0][0].
        matrix slice(int row,int col);
        friend matrix slice(matrix & m,int row,int col);

		//mresult=m.slice(row1,col1,row2,col2) or mresult=slice(m,row1,col1,
		//row2,col2)       returns a submatrix of m. it is row2*col2 and
		//mresult[0][0]=v[row1][col1].
        matrix slice(int row1,int col1,int row2,int col2);
        friend matrix slice(matrix & m, int row1,
					int col1,int row2,int col2);

		//mresult=m1.commat(m2,select) or mresult=commat(m1,m2,select)
		//mresult=m1.commat(m2) or mresult=commat(m1,m2)
		//combines two matrices:
		//select=0: 		  the matrix A(n1*m1) and B(n2*m2) will be placed
		//					  at main diagnal line and result is a
		//					  (n1+n2)*(m1+m2) matrix;
		//select=1:	   	      combines a n1*m1 matrix with a n2*m2 matrix. the
		//					  result is a n*(m1+m2) matrix (n=MAX(n1,n2));
		//select=2(default):  combines a n1*m1 matrix with a n2*m2 matrix. the
		//					  result is a (n1+n2)*m matrix (m=MAX(m1,m2));
		//other select:		  reports an error !
        friend matrix commat(matrix & m1,matrix & m2,
							int select=2);
        matrix commat(matrix & m2,
							int select=2);

		//mresult=m1.commat(v2,select) or mresult=commat(m1,v2,select)
		//mresult=m1.commat(v2) or mresult=commat(m1,v2)
		//combines a matrix with a vector to form a new matrix:
		//select=1:			    combines a n1*m1 matrix with a n2 element
		//						column-vector. the result is a n*(m1+1)
		//						matrix (n=MAX(n1,n2));
		//select=2(default):    combines a n1*m1 matrix with a m2 element
		//				        row-vector. the result is a (n1+1)*m
		//						matrix (m=MAX(m1,m2));
		//other select:			will report an error !
        friend matrix commat(matrix & m1,
                        vector & v2,int select=2);
        matrix commat(vector & v2,int select=2);

		//mresult=v1.commat(m2,select) or mresult=commat(v1,m2,select)
		//mresult=v1.commat(m2) or mresult=commat(v1,m2)
		//same as above function, but the vector is placed at first row or
		//first column.
        friend matrix commat(vector & v1,
                        matrix & m2,int select=2);

		//mresult=v1.commat(v2,select) or mresult=commat(v1,v2,select)
		//combines two vectors to form a new matrix:
		//select=1:			    combines a n1 element column-vector with a n2
		//						element column-vector. the result is a n*2
		//						matrix (n=MAX(n1,n2));
		//select=2(default):    combines a m1 element row-vector with a m2
		//						element row-vector. the result is a 2*m
		//						matrix (m=MAX(m1,m2));
		//other select:		    reports an error !
        friend matrix commat(vector & v1,
                        vector & v2,int select=2);

		//mresult=m1.commat(m2,srow,scol) or mresult=commat(m1,m2,srow,scol)
		//combines two matrices with arbitry manner. the limitation is that
		//any element of the two matrices can not be overlapped. the matrix
		//A(n1*m1) is placed at left-top corner. the first element of matrix
		//B(n2*m2) is placed at (srow,scol). the dimension of result matrix
		//is max(srow+n2,n1)*max(scol+m2,m1).
        friend matrix commat(matrix & m1,matrix & m2,
							int srow,int scol);
        matrix commat(matrix & m2,
							int srow,int scol);

		//mresult=diag(v2)
		//returns a matrix which uses input vector as diagnal elements.
        friend matrix diag(vector & v2);

		//mresult=diag(v2,k)
		//returns a matrix which uses the element of vector as the k-th
		//diagnal. if k>0, the subdiagnal is above main diagnal. otherwise,
		//it is under the main diagnal. the dimension of return matrix
		//is (n+|k|)*(n+|k|).
        friend matrix diag(vector & v2,int k);

		//vresult=diag(m2) or vresult=m2.diag()
		//returns the main diagnal element of input matrix.
        friend vector diag(matrix & m2);
        vector diag();

		//vresult=diag(m2,k) or vresult=m2.diag(k)
		//returns the k-th subdiagnal of input matrix. if k>0, the subdiagnal
		//is above main diagnal. otherwise, it is under the main diagnal.
        friend vector diag(matrix & m2,int k);
        vector diag(int k);

		//vresult=sum(m) or vresult=m.sum()
		//returns the sum of every element in the same row of input matrix.
        friend vector sum(matrix & m);
        vector sum();

        //mresult=trans(m) or mresult=m.trans()
        matrix trans();
        friend matrix trans(matrix & m);

		//mresult=abs(m) or mresult=m.abs()
        matrix abs();
        friend matrix abs(matrix & m);

		//vresult=any(m) or vresult=m.any()
		//returns a vector. if the i-th row has any non-zero element. the i-th
		//element of return vector is 1. otherwise, it is 0.
        vector any();
        friend vector any(matrix & m);

		 //vresult=max(m) or vresult=m.max()
         vector mmax();
         friend vector mmax(matrix & m);

		 //mresult=max(v1,v2) or mresult=v1.max(v2)
		 //mresult[i][j]=max(v1(i,j),v2(i,j)).
         matrix mmax(matrix & v2);
         friend matrix mmax(matrix & v1,matrix & v2);

         vector maxofrow();
         friend vector maxofrow(matrix & m);

         vector maxofcol();
         friend vector maxofcol(matrix & m);

         vector minofrow();
         friend vector minofrow(matrix & m);

         vector minofcol();
         friend vector minofcol(matrix & m);
		 //vresult=min(m) or vresult=m.min()
         vector mmin();
         friend vector mmin(matrix & m);

		 //mresult=min(v1,v2) or mresult=v1.min(v2)
		 //mresult[i][j]=min(v1(i,j),v2(i,j)).
         matrix mmin(matrix & v2);
         friend matrix mmin(matrix & v1,matrix & v2);

		//mresult=eye(n)
		//returns a n*n E matrix.
        friend matrix eye(int n);

		//mresult=eye(m,n)
		//returns m*n matrix. the main diagnal elements are 1, and
		//other elements are 0.
        friend matrix eye(int m,int n);

		//mresult=eye(m) or mresult=m.eye()
		//returns a matrix which has the same order with input matrix.
		//the main diagnal elements are 1, and  other elements are 0.
        friend matrix eye(matrix & m);
        matrix eye();

		 //mresult=rand(m) or rand(m) or mresult=m.rand()
		 //fullfills every element of matrix m with random numbers
		 //which are uniformly distributed in the range of (0.0, 1.0).
		 //WARNING: this function will destroy the old content of
		 //matrix object which calls this function.
         matrix &  rand();
         friend matrix &  rand(matrix & m);

		 //mresult=m.rand(m,n)
		 //creates a new matrix which has m*n elements.
         //there is no influence to matrix which calls this function.
         matrix rand(int m,int n);

//        double norm(int n=2);
//        friend double norm(dmatrix& v,int n=2);

		//result=det(m) or result=m.det()
//        double det();
//        friend double det(matrix & m);

		//mresult=inv(m) or mresult=m.inv()
//        matrix inv();
//        friend matrix inv(matrix & m);

		//mesult=inv1(m) or mresult=m.inv1()
//        matrix inv1();
//        friend matrix inv1(matrix & m);

		//mresult=inv(m,det) or mresult=m.inv(det)
		//calculates inv and det at the same time.
//        matrix inv(double & det);
//        friend matrix inv(matrix & m,
//                double & det);
        void matmult(vector& u,vector& v);
        void rndnorm(double mu=0,double sigma=1);
};



#endif //__BMATPAC_HPP