Merged changes in the trunk up to revision 35203.
[blender.git] / intern / smoke / intern / tnt / tnt_array3d_utils.h
1 /** \file smoke/intern/tnt/tnt_array3d_utils.h
2  *  \ingroup smoke
3  */
4
5
6 #ifndef TNT_ARRAY3D_UTILS_H
7 #define TNT_ARRAY3D_UTILS_H
8
9 #include <cstdlib>
10 #include <cassert>
11
12 namespace TNT
13 {
14
15
16 template <class T>
17 std::ostream& operator<<(std::ostream &s, const Array3D<T> &A)
18 {
19     int M=A.dim1();
20     int N=A.dim2();
21     int K=A.dim3();
22
23     s << M << " " << N << " " << K << "\n";
24
25     for (int i=0; i<M; i++)
26     {
27         for (int j=0; j<N; j++)
28         {
29                         for (int k=0; k<K; k++)
30                 s << A[i][j][k] << " ";
31                         s << "\n";
32         }
33         s << "\n";
34     }
35
36
37     return s;
38 }
39
40 template <class T>
41 std::istream& operator>>(std::istream &s, Array3D<T> &A)
42 {
43
44     int M, N, K;
45
46     s >> M >> N >> K;
47
48         Array3D<T> B(M,N,K);
49
50     for (int i=0; i<M; i++)
51         for (int j=0; j<N; j++)
52                         for (int k=0; k<K; k++)
53                 s >>  B[i][j][k];
54
55         A = B;
56     return s;
57 }
58
59
60
61 template <class T>
62 Array3D<T> operator+(const Array3D<T> &A, const Array3D<T> &B)
63 {
64         int m = A.dim1();
65         int n = A.dim2();
66         int p = A.dim3();
67
68         if (B.dim1() != m ||  B.dim2() != n || B.dim3() != p )
69                 return Array3D<T>();
70
71         else
72         {
73                 Array3D<T> C(m,n,p);
74
75                 for (int i=0; i<m; i++)
76                         for (int j=0; j<n; j++)
77                                 for (int k=0; k<p; k++)
78                                 C[i][j][k] = A[i][j][k] + B[i][j][k];
79
80                 return C;
81         }
82 }
83
84
85 template <class T>
86 Array3D<T> operator-(const Array3D<T> &A, const Array3D<T> &B)
87 {
88         int m = A.dim1();
89         int n = A.dim2();
90         int p = A.dim3();
91
92         if (B.dim1() != m ||  B.dim2() != n || B.dim3() != p )
93                 return Array3D<T>();
94
95         else
96         {
97                 Array3D<T> C(m,n,p);
98
99                 for (int i=0; i<m; i++)
100                         for (int j=0; j<n; j++)
101                                 for (int k=0; k<p; k++)
102                                 C[i][j][k] = A[i][j][k] - B[i][j][k];
103
104                 return C;
105         }
106 }
107
108
109
110
111 template <class T>
112 Array3D<T> operator*(const Array3D<T> &A, const Array3D<T> &B)
113 {
114         int m = A.dim1();
115         int n = A.dim2();
116         int p = A.dim3();
117
118         if (B.dim1() != m ||  B.dim2() != n || B.dim3() != p )
119                 return Array3D<T>();
120
121         else
122         {
123                 Array3D<T> C(m,n,p);
124
125                 for (int i=0; i<m; i++)
126                         for (int j=0; j<n; j++)
127                                 for (int k=0; k<p; k++)
128                                 C[i][j][k] = A[i][j][k] * B[i][j][k];
129
130                 return C;
131         }
132 }
133
134
135 template <class T>
136 Array3D<T> operator/(const Array3D<T> &A, const Array3D<T> &B)
137 {
138         int m = A.dim1();
139         int n = A.dim2();
140         int p = A.dim3();
141
142         if (B.dim1() != m ||  B.dim2() != n || B.dim3() != p )
143                 return Array3D<T>();
144
145         else
146         {
147                 Array3D<T> C(m,n,p);
148
149                 for (int i=0; i<m; i++)
150                         for (int j=0; j<n; j++)
151                                 for (int k=0; k<p; k++)
152                                 C[i][j][k] = A[i][j][k] / B[i][j][k];
153
154                 return C;
155         }
156 }
157
158
159
160 template <class T>
161 Array3D<T>& operator+=(Array3D<T> &A, const Array3D<T> &B)
162 {
163         int m = A.dim1();
164         int n = A.dim2();
165         int p = A.dim3();
166
167         if (B.dim1() == m &&  B.dim2() == n && B.dim3() == p )
168         {
169                 for (int i=0; i<m; i++)
170                         for (int j=0; j<n; j++)
171                                 for (int k=0; k<p; k++)
172                                         A[i][j][k] += B[i][j][k];
173         }
174
175         return A;
176 }
177
178 template <class T>
179 Array3D<T>& operator-=(Array3D<T> &A, const Array3D<T> &B)
180 {
181         int m = A.dim1();
182         int n = A.dim2();
183         int p = A.dim3();
184
185         if (B.dim1() == m &&  B.dim2() == n && B.dim3() == p )
186         {
187                 for (int i=0; i<m; i++)
188                         for (int j=0; j<n; j++)
189                                 for (int k=0; k<p; k++)
190                                         A[i][j][k] -= B[i][j][k];
191         }
192
193         return A;
194 }
195
196 template <class T>
197 Array3D<T>& operator*=(Array3D<T> &A, const Array3D<T> &B)
198 {
199         int m = A.dim1();
200         int n = A.dim2();
201         int p = A.dim3();
202
203         if (B.dim1() == m &&  B.dim2() == n && B.dim3() == p )
204         {
205                 for (int i=0; i<m; i++)
206                         for (int j=0; j<n; j++)
207                                 for (int k=0; k<p; k++)
208                                         A[i][j][k] *= B[i][j][k];
209         }
210
211         return A;
212 }
213
214
215 template <class T>
216 Array3D<T>& operator/=(Array3D<T> &A, const Array3D<T> &B)
217 {
218         int m = A.dim1();
219         int n = A.dim2();
220         int p = A.dim3();
221
222         if (B.dim1() == m &&  B.dim2() == n && B.dim3() == p )
223         {
224                 for (int i=0; i<m; i++)
225                         for (int j=0; j<n; j++)
226                                 for (int k=0; k<p; k++)
227                                         A[i][j][k] /= B[i][j][k];
228         }
229
230         return A;
231 }
232
233
234
235
236
237 } // namespace TNT
238
239 #endif