#ifndef Matrix_h #define Matrix_h #include #include #include "../Basics/basic.h" #include "../Basics/exception.h" tcT class Matrix; // forward declaration tcT class Array { public: ///////////////////////// // Arrays constructors // ///////////////////////// Array (); Array (const Array& a); virtual ~Array (); ////////////////////// // Arrays selectors // ////////////////////// int l() const; // return length of rows /*virtual*/ int m() const; // return number of rows /*virtual*/ int n() const; // return number of columns T* x() const; // return pointer to array // subArray (without space reallocation) Array s(int i=0, int m=1, int j=0) const; Array s(int i, int m, int j, int n) const; // subMatrix (with space reallocation) Matrix _(int i=0, int m=1, int j=0) const; Matrix _(int i, int m, int j, int n) const; // subscripting T* operator [] (int i) const; T& operator () (int i) const /*??*/; T& operator () (int i, int j) const /*??*/; ////////////////////////// // Assignment of arrays // ////////////////////////// // simple assignment Array& operator = (const T& b); Array& operator = (const Array& b); // add and assign Array& operator += (const T& b); Array& operator += (const Array& b); // subtract and assign Array& operator -= (const T& b); Array& operator -= (const Array& b); // multiply and assign Array& operator *= (const T& b); Array& operator *= (const Array& b); // divide and assign Array& operator /= (const T& b); Array& operator /= (const Array& b); // shift left and assign Array& operator <<=(int n); // shift right and assign Array& operator >>=(int n); ////////////////////////// // Comparison of arrays // ////////////////////////// // less than boolean operator < (const T& b) const; friend boolean operator < (const T& a, const Array& b); /*virtual*/ boolean operator < (const Array& b) const; // less than or equal boolean operator <= (const T& b) const; friend boolean operator <= (const T& a, const Array& b); boolean operator <= (const Array& b) const; // greater than boolean operator > (const T& b) const; friend boolean operator > (const T& a, const Array& b); boolean operator > (const Array& b) const; // greater than or equal boolean operator >= (const T& b) const; friend boolean operator >= (const T& a, const Array& b); boolean operator >= (const Array& b) const; // equal boolean operator == (const T& b) const; friend boolean operator == (const T& a, const Array& b); boolean operator == (const Array& b) const; // not equal boolean operator != (const T& b) const; friend boolean operator != (const T& a, const Array& b); boolean operator != (const Array& b) const; /////////////////// // I/O of arrays // /////////////////// friend ostream& operator << (ostream& s, const Array& a); friend ostream& coefWidth (ostream& s, int w); friend ostream& coefPrecision (ostream& s, int p); friend ostream& charAsCharacter (ostream& s); friend ostream& charAsNumber (ostream& s); friend ostream& coefPerLine (ostream& s, int nbC); friend istream& operator >> (istream& s, const Array& a); friend istream& charAsCharacter (istream& s); friend istream& charAsNumber (istream& s); ///////////////////////// // Operators on arrays // ///////////////////////// // unary plus and minus Matrix operator + () const; Matrix operator - () const; // add (plus) Matrix operator + (const T& b) const; friend Matrix operator + (const T& a, const Array& b); Matrix operator + (const Array& b) const; // subtract (minus) Matrix operator - (const T& b) const; friend Matrix operator - (const T& a, const Array& b); Matrix operator - (const Array& b) const; // multiply Matrix operator * (const T& b) const; friend Matrix operator * (const T& a, const Array& b); Matrix operator * (const Array& b) const; // divide Matrix operator / (const T& b) const; friend Matrix operator / (const T& a, const Array& b); Matrix operator / (const Array& b) const; // matrix multiplication(inner product) Matrix operator % (const Array& b) const; // matrix multiplication(outer product) Matrix operator & (const Array& b) const; // shift left Matrix operator << (int n) const; // shift right Matrix operator >> (int n) const; // stack Matrix operator ^ (const Array& b) const; // adjoin Matrix operator | (const Array& b) const; // map (return a matrix given by mapping f to X) Matrix map(T (*f)( T )) const; // statistical tools Matrix sum() const; // sums of row elements Matrix sumC() const; // sums of col elements Matrix sumsq() const; // sums of row elements^2 Matrix sumsqC() const; // sums of col elements^2 Matrix sumabs() const; // sums of row |elements| Matrix sumabsC() const; // sums of col |elements| Matrix min() const; // minimum row by row Matrix minC() const; // minimum col by col Matrix max() const; // maximum row by row Matrix maxC() const; // maximum col by col T f(T x, T y) const; // interpolation // algebraic tools Matrix t () const; // transpose Array& ta(); // transpose an array /// Matrix i(T d = T(1e-12)) const; // inverse // search & sort int min_index() const; // minimum array element index int max_index() const; // maximum array element index Array& sort(); // sort rows lexico. if M>1, otherwise sort first row in increas. Array& sort(Matrix& index, boolean move=false); // as sort(), but only for elements with indices in index // if move, calling object is modified and index is unchanged, // otherwise only index is modified // cast (type conversion) operator T () const; // operator T* () const; ////////////////////////////////////////////////////////////////////////////// protected: Array (int l, int m, int n, T* d=0); Array ( int m, int n, T* d=0); Array ( int n, T* d=0); Array& resize(const Array& a); Array& resize(int m, int n, T* d); Array& resize( int n, T* d); int& l(int i); // change length of rows int& m(int i); // change number of rows int& n(int i); // change number of columns T*& x(T* u); // change pointer to array private: int L; // length of rows int M; // number of rows int N; // number of columns T* X; // matrix pointer void fusSortRow (Array& ind, int from, int to); void fusSort (Array& index, int from, int to, boolean move); }; tcT boolean operator < (const T& a, const Array& b); tcT boolean operator <= (const T& a, const Array& b); tcT boolean operator > (const T& a, const Array& b); tcT boolean operator >= (const T& a, const Array& b); tcT boolean operator == (const T& a, const Array& b); tcT boolean operator != (const T& a, const Array& b); tcT Matrix operator + (const T& a, const Array& b); tcT Matrix operator - (const T& a, const Array& b); tcT Matrix operator * (const T& a, const Array& b); tcT Matrix operator / (const T& a, const Array& b); /////////////////// // I/O of arrays // /////////////////// // Output tcT ostream& operator << (ostream& s, const Array& a); OMANIP (int) coefWidth(int w); OMANIP (int) coefPrecision(int p) ; // if negative, do not print ".0" for integers ostream& charAsCharacter (ostream& s); ostream& charAsNumber (ostream& s); OMANIP (int) coefPerLine(int nbC); // 0 means one row per line // Input tcT istream& operator >> (istream& s, const Array& a); istream& charAsCharacter (istream& s); istream& charAsNumber (istream& s); // tcT class Matrix : public virtual Array { public: /////////////////////////// // Matrices constructors // /////////////////////////// Matrix (int m, int n, const T a); Matrix (int m, int n); Matrix ( int n); Matrix (const Matrix& a); // ?? // Dropping this changes binarization -?? Matrix (const Array& a); Matrix (); virtual ~Matrix (); //////////////////////// // Matrices modifiers // //////////////////////// // resize without preserving the content Matrix& resize (const Array& a); Matrix& resize (int m, int n, T* d); Matrix& resize ( int n, T* d); Matrix& resize (int m, int n, const T& a); Matrix& resize (int m, int n); Matrix& resize ( int n=0); // resize while preserving the content ( this->(0,0) remains unchanged ) Matrix& resize_(int m, int n); Matrix& resize_( int n); ///////////////////////////// // Assignement of matrices // ?? ///////////////////////////// Matrix& operator = (const T& a); Matrix& operator = (const Array& a); Matrix& operator = (const Matrix& a); protected: Matrix (int m, int n, T* d); }; // error handling class nullArray : whereException { public: nullArray (const char* here) : whereException(here) {}; friend ostream& operator << (ostream& s, const nullArray& e); }; #endif