00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <iostream>
00013 #include <iomanip>
00014
00015 #if 1
00016 #include "Matrix.h"
00017 #else
00018 #include "Sparse_Matrix.h"
00019 #define Matrix Sparse_Matrix
00020 #endif
00021
00022 using namespace Mx;
00023 using namespace std;
00024
00025
00026 template <class E>
00027 void print( const char* name, Matrix<E> & V ) {
00028 cout << endl << name << '[' << V.rows() << ',' << V.cols() << ']' << endl;
00029 for (unsigned i=0; i < V.rows(); ++i) {
00030 for (unsigned j=0; j < V.cols(); ++j) {
00031 cout << " " << setw(6) << V(i,j);
00032 }
00033 cout << endl;
00034 }
00035 }
00036
00037 #include "uUnit.h"
00038 #include "str2list.h"
00039
00040
00041 int main() {
00042 {{
00043 int M[4][5];
00044 intmatrix<4,5>( M , " | 1 2 3 4 5 | "
00045 " | 6 7 8 9 10 | "
00046 " | 11 12 13 14 15 | "
00047 " | 16 17 18 19 20 | " );
00048
00049 assertTrue( M[0][0] == 1 ); assertTrue( M[2][1] == 12 );
00050
00051 Matrix<int> Mchirri(4,5);
00052 int k=1;
00053 for ( size_t i=0; i<4; ++i ) {
00054 for ( size_t j=0; j<5; ++j ) {
00055 Mchirri(i,j) = M[i][j];
00056 assertTrue( Mchirri(i,j)==k ); k++;
00057 }
00058 }
00059 }}
00060 {{
00061 int M[4][5];
00062 intmatrix<4,5>( M , " | 1 2 3 4 5 | "
00063 " | 6 7 8 9 10 | "
00064 " | 11 12 13 14 15 | "
00065 " | 16 17 18 19 20 | " );
00066
00067 Matrix<int> Mchirri(4,5);
00068 int k=1;
00069 for ( size_t i=0; i<4; ++i ) {
00070 for ( size_t j=0; j<5; ++j ) {
00071 Mchirri(i,j) = M[i][j];
00072 assertTrue( Mchirri(i,j)==k ); k++;
00073 }
00074 }
00075 assertTrue( Mchirri.rows() == 4 );
00076 assertTrue( Mchirri.cols() == 5 );
00077 }}
00078 {{
00079 int M[4][4];
00080 intmatrix<4,4>( M , " | 1 2 3 4 | "
00081 " | 0 5 6 7 | "
00082 " | 0 0 8 9 | "
00083 " | 0 0 0 10 | " );
00084
00085 Matrix<int> Mchirri(4,4);
00086 int k=1;
00087 for ( size_t i=0; i<4; ++i ) {
00088 for ( size_t j=0; j<4; ++j ) {
00089 Mchirri(i,j) = M[i][j];
00090 }
00091 }
00092 assertTrue( isUpperTriangular(Mchirri) );
00093 Mchirri(3,0) = 12;
00094 assertTrue( !isUpperTriangular(Mchirri) );
00095 }}
00096 {{
00097 int M[4][4];
00098 intmatrix<4,4>( M , " | 1 0 0 0 | "
00099 " | 2 3 0 0 | "
00100 " | 4 5 6 0 | "
00101 " | 7 8 9 10 | " );
00102
00103 Matrix<int> Mchirri(4,4);
00104 int k=1;
00105 for ( size_t i=0; i<4; ++i ) {
00106 for ( size_t j=0; j<4; ++j ) {
00107 Mchirri(i,j) = M[i][j];
00108 }
00109 }
00110 assertTrue( isLowerTriangular(Mchirri) );
00111 Mchirri(0,3) = 12;
00112 assertTrue( !isLowerTriangular(Mchirri) );
00113 }}
00114
00115 std::cout << "==============\n";
00116
00117 const unsigned M = 5;
00118 const unsigned N = 8;
00119 unsigned i,j,k;
00120 char * above = new char [10];
00121 typedef Matrix<unsigned> Matrix_unsigned;
00122 Matrix<unsigned> V(M,N);
00123 char * below = new char [10];
00124
00125 k = 0;
00126 for (i=0; i < V.rows(); ++i) {
00127 for (j=0; j < V.cols(); ++j) {
00128 V(i,j) = k++;
00129 }
00130 }
00131
00132 Matrix<unsigned> A = V;
00133 assertTrue( A == V );
00134 assertTrue( A.same(A) );
00135 print("A", A);
00136
00137 V.reSize(N,M);
00138 print("V", V);
00139
00140
00141 assertTrue( k == A.rows()*A.cols() );
00142 for (i=0; i < V.rows(); ++i) {
00143 for (j=0; j < V.cols(); ++j) {
00144 V(i,j) = k++;
00145 }
00146 }
00147
00148 Matrix<unsigned> B;
00149 B = V;
00150 assertTrue( B == V );
00151 print("B", B);
00152
00153 Matrix_unsigned C = V;
00154 C = C + C;
00155 print("C", C);
00156
00157 C = A - A;
00158 print("C", C);
00159 assertTrue( isNull( C ) && ! isScalar( C ) );
00160 assertTrue( ! isLowerTriangular( C ) && ! isUpperTriangular( C ) );
00161 assertTrue( ! isSquare( C ) && ! isUnit( C ) );
00162 assertTrue( ! isSymmetric( C ) );
00163
00164 print("A", A);
00165
00166 print("B", B);
00167 C = B * A;
00168 print("C", C);
00169 assertTrue( ! isNull( C ) && isSquare( C ) );
00170 assertTrue( ! isLowerTriangular( C ) && ! isUpperTriangular( C ) );
00171 assertTrue( ! isUnit( C ) && ! isScalar( C ) );
00172 assertTrue( ! isSymmetric( C ) );
00173
00174 print("A", A);
00175 print("B", B);
00176 C = A * B;
00177 print("C", C);
00178 assertTrue( ! isNull( C ) && isSquare( C ) );
00179 assertTrue( ! isLowerTriangular( C ) && ! isUpperTriangular( C ) );
00180 assertTrue( ! isUnit( C ) && ! isScalar( C ) );
00181 assertTrue( ! isSymmetric( C ) );
00182
00183 return 0;
00184 }
00185
00186