Graph Framework
Loading...
Searching...
No Matches
vector.hpp
Go to the documentation of this file.
1//------------------------------------------------------------------------------
4//------------------------------------------------------------------------------
5
6#ifndef vector_h
7#define vector_h
8
9#include "node.hpp"
10
11namespace graph {
12//******************************************************************************
13// Vector interface.
14//******************************************************************************
15//------------------------------------------------------------------------------
20//------------------------------------------------------------------------------
21 template<jit::float_scalar T, bool SAFE_MATH=false>
22 class vector_quantity : public std::enable_shared_from_this<vector_quantity<T, SAFE_MATH>> {
23 protected:
25 shared_leaf<T, SAFE_MATH> x;
27 shared_leaf<T, SAFE_MATH> y;
29 shared_leaf<T, SAFE_MATH> z;
30
31 public:
32//------------------------------------------------------------------------------
38//------------------------------------------------------------------------------
43
44//------------------------------------------------------------------------------
48//------------------------------------------------------------------------------
49 shared_leaf<T, SAFE_MATH> get_x() const {
50 return x;
51 }
52
53
54//------------------------------------------------------------------------------
58//------------------------------------------------------------------------------
59 shared_leaf<T, SAFE_MATH> get_y() const {
60 return y;
61 }
62
63//------------------------------------------------------------------------------
67//------------------------------------------------------------------------------
68 shared_leaf<T, SAFE_MATH> get_z() const {
69 return z;
70 }
71
72//------------------------------------------------------------------------------
77//------------------------------------------------------------------------------
78 shared_leaf<T, SAFE_MATH>
79 dot(std::shared_ptr<vector_quantity<T, SAFE_MATH>> v2) {
80 return x*v2->get_x() +
81 y*v2->get_y() +
82 z*v2->get_z();
83 }
84
85//------------------------------------------------------------------------------
90//------------------------------------------------------------------------------
91 std::shared_ptr<vector_quantity<T, SAFE_MATH>>
92 cross(std::shared_ptr<vector_quantity<T, SAFE_MATH>> v2) {
93 return std::make_shared<vector_quantity<T, SAFE_MATH>> (y*v2->get_z() - z*v2->get_y(),
94 z*v2->get_x() - x*v2->get_z(),
95 x*v2->get_y() - y*v2->get_x());
96 }
97
98//------------------------------------------------------------------------------
102//------------------------------------------------------------------------------
103 shared_leaf<T, SAFE_MATH> length() {
104 return sqrt(this->dot(this->shared_from_this()));
105 }
106
107//------------------------------------------------------------------------------
111//------------------------------------------------------------------------------
112 std::shared_ptr<vector_quantity<T, SAFE_MATH>> unit() {
113 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, y, z)/length();
114 }
115 };
116
118 template<jit::float_scalar T, bool SAFE_MATH=false>
119 using shared_vector = std::shared_ptr<vector_quantity<T, SAFE_MATH>>;
120
121//------------------------------------------------------------------------------
131//------------------------------------------------------------------------------
132 template<jit::float_scalar T, bool SAFE_MATH=false>
133 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
134 shared_leaf<T, SAFE_MATH> y,
135 shared_leaf<T, SAFE_MATH> z) {
136 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, y, z);
137 }
138
139//------------------------------------------------------------------------------
150//------------------------------------------------------------------------------
151 template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH=false>
152 shared_vector<T, SAFE_MATH> vector(const L x,
153 shared_leaf<T, SAFE_MATH> y,
154 shared_leaf<T, SAFE_MATH> z) {
155 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)), y, z);
156 }
157
158//------------------------------------------------------------------------------
169//------------------------------------------------------------------------------
170 template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH=false>
171 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
172 const M y,
173 shared_leaf<T, SAFE_MATH> z) {
174 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, constant<T, SAFE_MATH> (static_cast<T> (y)), z);
175 }
176
177//------------------------------------------------------------------------------
188//------------------------------------------------------------------------------
189 template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH=false>
190 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
191 shared_leaf<T, SAFE_MATH> y,
192 const R z) {
193 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, y, constant<T, SAFE_MATH> (static_cast<T> (z)));
194 }
195
196//------------------------------------------------------------------------------
208//------------------------------------------------------------------------------
209 template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH=false>
210 shared_vector<T, SAFE_MATH> vector(const L x,
211 const M y,
212 shared_leaf<T, SAFE_MATH> z) {
213 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)),
214 constant<T, SAFE_MATH> (static_cast<T> (y)), z);
215 }
216
217//------------------------------------------------------------------------------
229//------------------------------------------------------------------------------
230 template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH=false>
231 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
232 const M y,
233 const R z) {
234 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, constant<T, SAFE_MATH> (static_cast<T> (y)),
235 constant<T, SAFE_MATH> (static_cast<T> (z)));
236 }
237
238//------------------------------------------------------------------------------
250//------------------------------------------------------------------------------
251 template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH=false>
252 shared_vector<T, SAFE_MATH> vector(const L x,
253 shared_leaf<T, SAFE_MATH> y,
254 const R z) {
255 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)), y,
256 constant<T, SAFE_MATH> (static_cast<T> (z)));
257 }
258
259//------------------------------------------------------------------------------
269//------------------------------------------------------------------------------
270 template<jit::float_scalar T, bool SAFE_MATH=false>
271 shared_vector<T, SAFE_MATH> vector(const T x,
272 const T y,
273 const T z) {
274 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)),
275 constant<T, SAFE_MATH> (static_cast<T> (y)),
276 constant<T, SAFE_MATH> (static_cast<T> (z)));
277 }
278
279//------------------------------------------------------------------------------
288//------------------------------------------------------------------------------
289 template<jit::float_scalar T, bool SAFE_MATH=false>
290 shared_vector<T, SAFE_MATH> operator+(shared_vector<T, SAFE_MATH> l,
291 shared_vector<T, SAFE_MATH> r) {
292 return vector(l->get_x() + r->get_x(),
293 l->get_y() + r->get_y(),
294 l->get_z() + r->get_z());
295 }
296
297//------------------------------------------------------------------------------
306//------------------------------------------------------------------------------
307 template<jit::float_scalar T, bool SAFE_MATH=false>
308 shared_vector<T, SAFE_MATH> operator-(shared_vector<T, SAFE_MATH> l,
309 shared_vector<T, SAFE_MATH> r) {
310 return vector(l->get_x() - r->get_x(),
311 l->get_y() - r->get_y(),
312 l->get_z() - r->get_z());
313 }
314
315//------------------------------------------------------------------------------
324//------------------------------------------------------------------------------
325 template<jit::float_scalar T, bool SAFE_MATH=false>
326 shared_vector<T, SAFE_MATH> operator*(shared_leaf<T, SAFE_MATH> s,
327 shared_vector<T, SAFE_MATH> v) {
328 return vector(s*v->get_x(),
329 s*v->get_y(),
330 s*v->get_z());
331 }
332
333//------------------------------------------------------------------------------
342//------------------------------------------------------------------------------
343 template<jit::float_scalar T, bool SAFE_MATH=false>
344 shared_vector<T, SAFE_MATH> operator/(shared_vector<T, SAFE_MATH> v,
345 shared_leaf<T, SAFE_MATH> s) {
346 return vector(v->get_x()/s,
347 v->get_y()/s,
348 v->get_z()/s);
349 }
350
351//******************************************************************************
352// Matrix interface.
353//******************************************************************************
354//------------------------------------------------------------------------------
359//------------------------------------------------------------------------------
360 template<jit::float_scalar T, bool SAFE_MATH=false>
361 class matrix_quantity : public std::enable_shared_from_this<matrix_quantity<T, SAFE_MATH>> {
362 protected:
364 shared_vector<T, SAFE_MATH> r1;
366 shared_vector<T, SAFE_MATH> r2;
368 shared_vector<T, SAFE_MATH> r3;
369
370 public:
371//------------------------------------------------------------------------------
377//------------------------------------------------------------------------------
382
383//------------------------------------------------------------------------------
388//------------------------------------------------------------------------------
389 shared_vector<T, SAFE_MATH>
390 dot(shared_vector<T, SAFE_MATH> v) {
391 return vector<T, SAFE_MATH> (r1->dot(v),
392 r2->dot(v),
393 r3->dot(v));
394 }
395 };
396
398 template<jit::float_scalar T, bool SAFE_MATH=false>
399 using shared_matrix = std::shared_ptr<matrix_quantity<T, SAFE_MATH>>;
400
401//------------------------------------------------------------------------------
411//------------------------------------------------------------------------------
412 template<jit::float_scalar T, bool SAFE_MATH=false>
413 shared_matrix<T, SAFE_MATH> matrix(shared_vector<T, SAFE_MATH> r1,
414 shared_vector<T, SAFE_MATH> r2,
415 shared_vector<T, SAFE_MATH> r3) {
416 return std::make_shared<matrix_quantity<T, SAFE_MATH>> (r1, r2, r3);
417 }
418}
419
420#endif /* vector_h */
graph::matrix_quantity
Class to represent matrix quantities.
Definition vector.hpp:361
graph::matrix_quantity::matrix_quantity
matrix_quantity(shared_vector< T, SAFE_MATH > r1, shared_vector< T, SAFE_MATH > r2, shared_vector< T, SAFE_MATH > r3)
Construct a new matrix_quantity.
Definition vector.hpp:378
graph::matrix_quantity::r3
shared_vector< T, SAFE_MATH > r3
Third row of the matrix.
Definition vector.hpp:368
graph::matrix_quantity::r1
shared_vector< T, SAFE_MATH > r1
First row of the matrix.
Definition vector.hpp:364
graph::matrix_quantity::dot
shared_vector< T, SAFE_MATH > dot(shared_vector< T, SAFE_MATH > v)
Multiply matrix by vector.
Definition vector.hpp:390
graph::matrix_quantity::r2
shared_vector< T, SAFE_MATH > r2
Second row of the matrix.
Definition vector.hpp:366
graph::vector_quantity
Class to represent vector quantities.
Definition vector.hpp:22
graph::vector_quantity::y
shared_leaf< T, SAFE_MATH > y
Y component of the vector.
Definition vector.hpp:27
graph::vector_quantity::get_x
shared_leaf< T, SAFE_MATH > get_x() const
Get the x component.
Definition vector.hpp:49
graph::vector_quantity::cross
std::shared_ptr< vector_quantity< T, SAFE_MATH > > cross(std::shared_ptr< vector_quantity< T, SAFE_MATH > > v2)
Vector cross product.
Definition vector.hpp:92
graph::vector_quantity::get_z
shared_leaf< T, SAFE_MATH > get_z() const
Get the z component.
Definition vector.hpp:68
graph::vector_quantity::get_y
shared_leaf< T, SAFE_MATH > get_y() const
Get the y component.
Definition vector.hpp:59
graph::vector_quantity::dot
shared_leaf< T, SAFE_MATH > dot(std::shared_ptr< vector_quantity< T, SAFE_MATH > > v2)
Vector dot product.
Definition vector.hpp:79
graph::vector_quantity::length
shared_leaf< T, SAFE_MATH > length()
Get the length of the vector.
Definition vector.hpp:103
graph::vector_quantity::unit
std::shared_ptr< vector_quantity< T, SAFE_MATH > > unit()
Get the unit vector.
Definition vector.hpp:112
graph::vector_quantity::z
shared_leaf< T, SAFE_MATH > z
Z component of the vector.
Definition vector.hpp:29
graph::vector_quantity::vector_quantity
vector_quantity(shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y, shared_leaf< T, SAFE_MATH > z)
Construct a new vector_quantity.
Definition vector.hpp:39
graph::vector_quantity::x
shared_leaf< T, SAFE_MATH > x
X component of the vector.
Definition vector.hpp:25
graph
Name space for graph nodes.
Definition arithmetic.hpp:13
graph::operator*
shared_leaf< T, SAFE_MATH > operator*(shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
Build multiply node from two leaves.
Definition arithmetic.hpp:2666
graph::zero
constexpr shared_leaf< T, SAFE_MATH > zero()
Forward declare for zero.
Definition node.hpp:994
graph::operator/
shared_leaf< T, SAFE_MATH > operator/(shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
Build divide node from two leaves.
Definition arithmetic.hpp:3631
graph::shared_vector
std::shared_ptr< vector_quantity< T, SAFE_MATH > > shared_vector
Convenience type for shared vector quantities.
Definition vector.hpp:119
graph::operator+
shared_leaf< T, SAFE_MATH > operator+(shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
Build add node from two leaves.
Definition arithmetic.hpp:774
graph::operator-
shared_leaf< T, SAFE_MATH > operator-(shared_leaf< T, SAFE_MATH > l, shared_leaf< T, SAFE_MATH > r)
Build subtract node from two leaves.
Definition arithmetic.hpp:1598
graph::vector
shared_vector< T, SAFE_MATH > vector(shared_leaf< T, SAFE_MATH > x, shared_leaf< T, SAFE_MATH > y, shared_leaf< T, SAFE_MATH > z)
Build a shared vector quantity.
Definition vector.hpp:133
graph::sqrt
shared_leaf< T, SAFE_MATH > sqrt(shared_leaf< T, SAFE_MATH > x)
Define sqrt convience function.
Definition math.hpp:279
graph::matrix
shared_matrix< T, SAFE_MATH > matrix(shared_vector< T, SAFE_MATH > r1, shared_vector< T, SAFE_MATH > r2, shared_vector< T, SAFE_MATH > r3)
Build a shared vector quantity.
Definition vector.hpp:413
graph::shared_matrix
std::shared_ptr< matrix_quantity< T, SAFE_MATH > > shared_matrix
Convenience type for shared vector quantities.
Definition vector.hpp:399
graph::shared_leaf
std::shared_ptr< leaf_node< T, SAFE_MATH > > shared_leaf
Convenience type alias for shared leaf nodes.
Definition node.hpp:673
node.hpp
Base nodes of graph computation framework.