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