00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef TNT_ARRAY2D_UTILS_H
00022 #define TNT_ARRAY2D_UTILS_H
00023
00024 #include <cstdlib>
00025 #include <cassert>
00026
00027 namespace TNT
00028 {
00029
00030
00031 template <class T>
00032 std::ostream& operator<<(std::ostream &s, const Array2D<T> &A)
00033 {
00034 int M=A.dim1();
00035 int N=A.dim2();
00036
00037 s << M << " " << N << "\n";
00038
00039 for (int i=0; i<M; i++)
00040 {
00041 for (int j=0; j<N; j++)
00042 {
00043 s << A[i][j] << " ";
00044 }
00045 s << "\n";
00046 }
00047
00048
00049 return s;
00050 }
00051
00052 template <class T>
00053 std::istream& operator>>(std::istream &s, Array2D<T> &A)
00054 {
00055
00056 int M, N;
00057
00058 s >> M >> N;
00059
00060 Array2D<T> B(M,N);
00061
00062 for (int i=0; i<M; i++)
00063 for (int j=0; j<N; j++)
00064 {
00065 s >> B[i][j];
00066 }
00067
00068 A = B;
00069 return s;
00070 }
00071
00072
00073 template <class T>
00074 Array2D<T> operator+(const Array2D<T> &A, const Array2D<T> &B)
00075 {
00076 int m = A.dim1();
00077 int n = A.dim2();
00078
00079 if (B.dim1() != m || B.dim2() != n )
00080 return Array2D<T>();
00081
00082 else
00083 {
00084 Array2D<T> C(m,n);
00085
00086 for (int i=0; i<m; i++)
00087 {
00088 for (int j=0; j<n; j++)
00089 C[i][j] = A[i][j] + B[i][j];
00090 }
00091 return C;
00092 }
00093 }
00094
00095 template <class T>
00096 Array2D<T> operator-(const Array2D<T> &A, const Array2D<T> &B)
00097 {
00098 int m = A.dim1();
00099 int n = A.dim2();
00100
00101 if (B.dim1() != m || B.dim2() != n )
00102 return Array2D<T>();
00103
00104 else
00105 {
00106 Array2D<T> C(m,n);
00107
00108 for (int i=0; i<m; i++)
00109 {
00110 for (int j=0; j<n; j++)
00111 C[i][j] = A[i][j] - B[i][j];
00112 }
00113 return C;
00114 }
00115 }
00116
00117
00118 template <class T>
00119 Array2D<T> operator*(const Array2D<T> &A, const Array2D<T> &B)
00120 {
00121 int m = A.dim1();
00122 int n = A.dim2();
00123
00124 if (B.dim1() != m || B.dim2() != n )
00125 return Array2D<T>();
00126
00127 else
00128 {
00129 Array2D<T> C(m,n);
00130
00131 for (int i=0; i<m; i++)
00132 {
00133 for (int j=0; j<n; j++)
00134 C[i][j] = A[i][j] * B[i][j];
00135 }
00136 return C;
00137 }
00138 }
00139
00140
00141
00142
00143 template <class T>
00144 Array2D<T> operator/(const Array2D<T> &A, const Array2D<T> &B)
00145 {
00146 int m = A.dim1();
00147 int n = A.dim2();
00148
00149 if (B.dim1() != m || B.dim2() != n )
00150 return Array2D<T>();
00151
00152 else
00153 {
00154 Array2D<T> C(m,n);
00155
00156 for (int i=0; i<m; i++)
00157 {
00158 for (int j=0; j<n; j++)
00159 C[i][j] = A[i][j] / B[i][j];
00160 }
00161 return C;
00162 }
00163 }
00164
00165
00166
00167
00168
00169 template <class T>
00170 Array2D<T>& operator+=(Array2D<T> &A, const Array2D<T> &B)
00171 {
00172 int m = A.dim1();
00173 int n = A.dim2();
00174
00175 if (B.dim1() == m || B.dim2() == n )
00176 {
00177 for (int i=0; i<m; i++)
00178 {
00179 for (int j=0; j<n; j++)
00180 A[i][j] += B[i][j];
00181 }
00182 }
00183 return A;
00184 }
00185
00186
00187
00188 template <class T>
00189 Array2D<T>& operator-=(Array2D<T> &A, const Array2D<T> &B)
00190 {
00191 int m = A.dim1();
00192 int n = A.dim2();
00193
00194 if (B.dim1() == m || B.dim2() == n )
00195 {
00196 for (int i=0; i<m; i++)
00197 {
00198 for (int j=0; j<n; j++)
00199 A[i][j] -= B[i][j];
00200 }
00201 }
00202 return A;
00203 }
00204
00205
00206
00207 template <class T>
00208 Array2D<T>& operator*=(Array2D<T> &A, const Array2D<T> &B)
00209 {
00210 int m = A.dim1();
00211 int n = A.dim2();
00212
00213 if (B.dim1() == m || B.dim2() == n )
00214 {
00215 for (int i=0; i<m; i++)
00216 {
00217 for (int j=0; j<n; j++)
00218 A[i][j] *= B[i][j];
00219 }
00220 }
00221 return A;
00222 }
00223
00224
00225
00226
00227
00228 template <class T>
00229 Array2D<T>& operator/=(Array2D<T> &A, const Array2D<T> &B)
00230 {
00231 int m = A.dim1();
00232 int n = A.dim2();
00233
00234 if (B.dim1() == m || B.dim2() == n )
00235 {
00236 for (int i=0; i<m; i++)
00237 {
00238 for (int j=0; j<n; j++)
00239 A[i][j] /= B[i][j];
00240 }
00241 }
00242 return A;
00243 }
00244
00258 template <class T>
00259 Array2D<T> matmult(const Array2D<T> &A, const Array2D<T> &B)
00260 {
00261 if (A.dim2() != B.dim1())
00262 return Array2D<T>();
00263
00264 int M = A.dim1();
00265 int N = A.dim2();
00266 int K = B.dim2();
00267
00268 Array2D<T> C(M,K);
00269
00270 for (int i=0; i<M; i++)
00271 for (int j=0; j<K; j++)
00272 {
00273 T sum = 0;
00274
00275 for (int k=0; k<N; k++)
00276 sum += A[i][k] * B [k][j];
00277
00278 C[i][j] = sum;
00279 }
00280
00281 return C;
00282
00283 }
00284
00285 }
00286
00287 #endif