-
Notifications
You must be signed in to change notification settings - Fork 0
/
tensor2.hpp
121 lines (101 loc) · 2.8 KB
/
tensor2.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#if !defined TENSOR3_HPP
#define TENSOR3_HPP
#include <iostream>
#include <cassert>
#include <initializer_list>
#include "vector2.hpp"
namespace LocalStress {
template <typename T>
struct Tensor2 final {
T xx, xy;
T yx, yy;
Tensor2(void) :
xx(0), xy(0),
yx(0), yy(0) {}
explicit Tensor2(const T c) :
xx(c), xy(c),
yx(c), yy(c) {}
Tensor2(const T xx_, const T xy_,
const T yx_, const T yy_) :
xx(xx_), xy(xy_),
yx(yx_), yy(yy_) {}
Tensor2(const Tensor2<T>& src) :
xx(src.xx), xy(src.xy),
yx(src.yx), yy(src.yy) {}
Tensor2(const std::initializer_list<T> ilist) {
assert(ilist.size() == 4);
T* it = &xx;
for (const auto i : ilist) *it++ = i;
}
const Tensor2& operator = (const Tensor2& src) {
xx = src.xx; xy = src.xy;
yx = src.yx; yy = src.yy;
return *this;
}
T& operator [] (const int i) {
return (&xx)[i];
}
const T& operator [] (const int i) const {
return (&xx)[i];
}
const Tensor2 operator + (const Tensor2& rhs) const {
return Tensor2(xx + rhs.xx, xy + rhs.xy,
yx + rhs.yx, yy + rhs.yy);
}
const Tensor2& operator += (const Tensor2& rhs) {
*this = (*this) + rhs;
return *this;
}
const Tensor2 operator - (const Tensor2& rhs) const {
return Tensor2(xx - rhs.xx, xy - rhs.xy,
yx - rhs.yx, yy - rhs.yy);
}
const Tensor2& operator -= (const Tensor2& rhs) {
*this = (*this) - rhs;
return *this;
}
const Tensor2 operator * (const T c) const {
return Tensor2(xx * c, xy * c,
yx * c, yy * c);
}
friend const Tensor2 operator * (const T c, const Tensor2& rhs) {
return Tensor2(c * rhs.xx, c * rhs.xy,
c * rhs.yx, c * rhs.yy);
}
const Tensor2& operator *= (const T c) {
*this = (*this) * c;
return *this;
}
const Tensor2 operator / (const T c) const {
return Tensor2(xx / c, xy / c,
yx / c, yy / c);
}
const Tensor2& operator /= (const T c) {
*this = (*this) / c;
return *this;
}
friend std::ostream& operator << (std::ostream& ost, const Tensor2& t) {
ost << "(";
ost << t.xx << ", " << t.xy << ",\n";
ost << t.yx << ", " << t.yy << ")";
return ost;
}
void clear(void) {
xx = xy = 0.0;
yx = yy = 0.0;
}
T trace(void) const {
return xx + yy;
}
T det(void) const {
return xx * yy - xy * yx;
}
};
template <typename T>
static inline Tensor2<T> tensor_dot(const Vector2<T>& v0,
const Vector2<T>& v1) {
return Tensor2<T>(v0.x * v1.x, v0.x * v1.y,
v0.y * v1.x, v0.y * v1.y);
}
}
#endif