CoCalc -- geomops.hpp

GitHub Repository: ElmerCSC/elmerfem
Path: blob/devel/ElmerGUI/netgen/libsrc/gprim/geomops.hpp
³²⁰⁶ views
1
#ifndef FILE_GEOMOPS
2
#define FILE_GEOMOPS
3

4
/* *************************************************************************/
5
/* File:   geomops.hpp                                                     */
6
/* Author: Joachim Schoeberl                                               */
7
/* Date:   20. Jul. 02                                                     */
8
/* *************************************************************************/
9

10

11
/*
12

13
Point - Vector operations
14

15
 */
16

17

18
template <int D>
19
inline Vec<D> operator+ (const Vec<D> & a, const Vec<D> & b)
20
{
21
  Vec<D> res;
22
  for (int i = 0; i < D; i++)
23
    res(i) = a(i) + b(i);
24
  return res;
25
}
26

27

28

29
template <int D>
30
inline Point<D> operator+ (const Point<D> & a, const Vec<D> & b)
31
{
32
  Point<D> res;
33
  for (int i = 0; i < D; i++)
34
    res(i) = a(i) + b(i);
35
  return res;
36
}
37

38

39

40
template <int D>
41
inline Vec<D> operator- (const Point<D> & a, const Point<D> & b)
42
{
43
  Vec<D> res;
44
  for (int i = 0; i < D; i++)
45
    res(i) = a(i) - b(i);
46
  return res;
47
}
48

49
template <int D>
50
inline Point<D> operator- (const Point<D> & a, const Vec<D> & b)
51
{
52
  Point<D> res;
53
  for (int i = 0; i < D; i++)
54
    res(i) = a(i) - b(i);
55
  return res;
56
}
57

58
template <int D>
59
inline Vec<D> operator- (const Vec<D> & a, const Vec<D> & b)
60
{
61
  Vec<D> res;
62
  for (int i = 0; i < D; i++)
63
    res(i) = a(i) - b(i);
64
  return res;
65
}
66

67

68

69
template <int D>
70
inline Vec<D> operator* (double s, const Vec<D> & b)
71
{
72
  Vec<D> res;
73
  for (int i = 0; i < D; i++)
74
    res(i) = s * b(i);
75
  return res;
76
}
77

78

79
template <int D>
80
inline double operator* (const Vec<D> & a, const Vec<D> & b)
81
{
82
  double sum = 0;
83
  for (int i = 0; i < D; i++)
84
    sum += a(i) * b(i);
85
  return sum;
86
}
87

88

89

90
template <int D>
91
inline Vec<D> operator- (const Vec<D> & b)
92
{
93
  Vec<D> res;
94
  for (int i = 0; i < D; i++)
95
    res(i) = -b(i);
96
  return res;
97
}
98

99

100
template <int D>
101
inline Point<D> & operator+= (Point<D> & a, const Vec<D> & b)
102
{
103
  for (int i = 0; i < D; i++)
104
    a(i) += b(i);
105
  return a;
106
}
107

108
template <int D>
109
inline Vec<D> & operator+= (Vec<D> & a, const Vec<D> & b)
110
{
111
  for (int i = 0; i < D; i++)
112
    a(i) += b(i);
113
  return a;
114
}
115

116

117
template <int D>
118
inline Point<D> & operator-= (Point<D> & a, const Vec<D> & b)
119
{
120
  for (int i = 0; i < D; i++)
121
    a(i) -= b(i);
122
  return a;
123
}
124

125
template <int D>
126
inline Vec<D> & operator-= (Vec<D> & a, const Vec<D> & b)
127
{
128
  for (int i = 0; i < D; i++)
129
    a(i) -= b(i);
130
  return a;
131
}
132

133

134

135
template <int D>
136
inline Vec<D> & operator*= (Vec<D> & a, double s)
137
{
138
  for (int i = 0; i < D; i++)
139
    a(i) *= s;
140
  return a;
141
}
142

143

144
template <int D>
145
inline Vec<D> & operator/= (Vec<D> & a, double s)
146
{
147
  for (int i = 0; i < D; i++)
148
    a(i) /= s;
149
  return a;
150
}
151

152

153

154

155
// Matrix - Vector operations
156

157
/*
158
template <int H, int W>
159
inline Vec<H> operator* (const Mat<H,W> & m, const Vec<W> & v)
160
{
161
  Vec<H> res;
162
  for (int i = 0; i < H; i++)
163
    {
164
      res(i) = 0;
165
      for (int j = 0; j < W; j++)
166
	res(i) += m(i,j) * v(j);
167
    }
168
  return res;
169
}
170
*/
171

172
// thanks to VC60 partial template specialization features !!!
173

174
inline Vec<2> operator* (const Mat<2,2> & m, const Vec<2> & v)
175
{
176
  Vec<2> res;
177
  for (int i = 0; i < 2; i++)
178
    {
179
      res(i) = 0;
180
      for (int j = 0; j < 2; j++)
181
	res(i) += m(i,j) * v(j);
182
    }
183
  return res;
184
}
185

186
inline Vec<2> operator* (const Mat<2,3> & m, const Vec<3> & v)
187
{
188
  Vec<2> res;
189
  for (int i = 0; i < 2; i++)
190
    {
191
      res(i) = 0;
192
      for (int j = 0; j < 3; j++)
193
	res(i) += m(i,j) * v(j);
194
    }
195
  return res;
196
}
197

198

199
inline Vec<3> operator* (const Mat<3,2> & m, const Vec<2> & v)
200
{
201
  Vec<3> res;
202
  for (int i = 0; i < 3; i++)
203
    {
204
      res(i) = 0;
205
      for (int j = 0; j < 2; j++)
206
	res(i) += m(i,j) * v(j);
207
    }
208
  return res;
209
}
210

211

212
inline Vec<3> operator* (const Mat<3,3> & m, const Vec<3> & v)
213
{
214
  Vec<3> res;
215
  for (int i = 0; i < 3; i++)
216
    {
217
      res(i) = 0;
218
      for (int j = 0; j < 3; j++)
219
	res(i) += m(i,j) * v(j);
220
    }
221
  return res;
222
}
223

224

225

226

227

228

229

230
/*
231
template <int H1, int W1, int H2, int W2>
232
inline Mat<H1,W2> operator* (const Mat<H1,W1> & a, const Mat<H2,W2> & b)
233
{
234
  Mat<H1,W2> m;
235
  for (int i = 0; i < H1; i++)
236
    for (int j = 0; j < W2; j++)
237
      {
238
	double sum = 0;
239
	for (int k = 0; k < W1; k++)
240
	  sum += a(i,k) * b(k, j);
241
	m(i,j) = sum; 
242
      }
243
  return m;
244
}
245
*/
246

247
inline Mat<2,2> operator* (const Mat<2,2> & a, const Mat<2,2> & b)
248
{
249
  Mat<2,2> m;
250
  for (int i = 0; i < 2; i++)
251
    for (int j = 0; j < 2; j++)
252
      {
253
	double sum = 0;
254
	for (int k = 0; k < 2; k++)
255
	  sum += a(i,k) * b(k, j);
256
	m(i,j) = sum; 
257
      }
258
  return m;
259
}
260

261
inline Mat<2,2> operator* (const Mat<2,3> & a, const Mat<3,2> & b)
262
{
263
  Mat<2,2> m;
264
  for (int i = 0; i < 2; i++)
265
    for (int j = 0; j < 2; j++)
266
      {
267
	double sum = 0;
268
	for (int k = 0; k < 3; k++)
269
	  sum += a(i,k) * b(k, j);
270
	m(i,j) = sum; 
271
      }
272
  return m;
273
}
274

275

276
inline Mat<3,2> operator* (const Mat<3,2> & a, const Mat<2,2> & b)
277
{
278
  Mat<3,2> m;
279
  for (int i = 0; i < 3; i++)
280
    for (int j = 0; j < 2; j++)
281
      {
282
	double sum = 0;
283
	for (int k = 0; k < 2; k++)
284
	  sum += a(i,k) * b(k, j);
285
	m(i,j) = sum; 
286
      }
287
  return m;
288
}
289

290

291

292
inline Mat<2,3> operator* (const Mat<2,2> & a, const Mat<2,3> & b)
293
{
294
  Mat<2,3> m;
295
  for (int i = 0; i < 2; i++)
296
    for (int j = 0; j < 3; j++)
297
      {
298
	double sum = 0;
299
	for (int k = 0; k < 2; k++)
300
	  sum += a(i,k) * b(k, j);
301
	m(i,j) = sum; 
302
      }
303
  return m;
304
}
305

306

307
inline Mat<3,3> operator* (const Mat<3,3> & a, const Mat<3,3> & b)
308
{
309
  Mat<3,3> m;
310
  for (int i = 0; i < 3; i++)
311
    for (int j = 0; j < 3; j++)
312
      {
313
	double sum = 0;
314
	for (int k = 0; k < 3; k++)
315
	  sum += a(i,k) * b(k, j);
316
	m(i,j) = sum; 
317
      }
318
  return m;
319
}
320

321

322

323

324

325

326

327

328
template <int H, int W>
329
inline Mat<W,H> Trans (const Mat<H,W> & m)
330
{
331
  Mat<W,H> res;
332
  for (int i = 0; i < H; i++)
333
    for (int j = 0; j < W; j++)
334
      res(j,i) = m(i,j);
335
  return res;
336
}
337

338

339

340

341

342

343

344

345

346

347

348
template <int D>
349
inline ostream & operator<< (ostream & ost, const Vec<D> & a)
350
{
351
  ost << "(";
352
  for (int i = 0; i < D-1; i++)
353
    ost << a(i) << ", ";
354
  ost << a(D-1) << ")";
355
  return ost;
356
}
357

358
template <int D>
359
inline ostream & operator<< (ostream & ost, const Point<D> & a)
360
{
361
  ost << "(";
362
  for (int i = 0; i < D-1; i++)
363
    ost << a(i) << ", ";
364
  ost << a(D-1) << ")";
365
  return ost;
366
}
367

368
template <int D>
369
inline ostream & operator<< (ostream & ost, const Box<D> & b)
370
{
371
  ost << b.PMin() << " - " << b.PMax();
372
  return ost;
373
}
374

375
template <int H, int W>
376
inline ostream & operator<< (ostream & ost, const Mat<H,W> & m)
377
{
378
  ost << "(";
379
  for (int i = 0; i < H; i++)
380
    {
381
      for (int j = 0; j < W; j++)
382
	ost << m(i,j) << "   ";
383
      ost << endl;
384
    }
385
  return ost;
386
}
387

388

389

390

391
#endif
392

393
Product

Resources

Company
