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