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//------------------------------------------------------------------------------
121//------------------------------------------------------------------------------
122 std::shared_ptr<vector_quantity<T, SAFE_MATH>> df(shared_leaf<T, SAFE_MATH> arg) {
123 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x->df(arg),
124 y->df(arg),
125 z->df(arg));
126 }
127
128//------------------------------------------------------------------------------
132//------------------------------------------------------------------------------
133 std::shared_ptr<vector_quantity<T, SAFE_MATH>> remove_pseudo() {
134 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x->remove_pseudo(),
135 y->remove_pseudo(),
136 z->remove_pseudo());
137 }
138 };
139
141 template<jit::float_scalar T, bool SAFE_MATH=false>
142 using shared_vector = std::shared_ptr<vector_quantity<T, SAFE_MATH>>;
143
144//------------------------------------------------------------------------------
154//------------------------------------------------------------------------------
155 template<jit::float_scalar T, bool SAFE_MATH=false>
156 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
157 shared_leaf<T, SAFE_MATH> y,
158 shared_leaf<T, SAFE_MATH> z) {
159 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, y, z);
160 }
161
162//------------------------------------------------------------------------------
173//------------------------------------------------------------------------------
174 template<jit::float_scalar T, jit::float_scalar L, bool SAFE_MATH=false>
175 shared_vector<T, SAFE_MATH> vector(const L x,
176 shared_leaf<T, SAFE_MATH> y,
177 shared_leaf<T, SAFE_MATH> z) {
178 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)), y, z);
179 }
180
181//------------------------------------------------------------------------------
192//------------------------------------------------------------------------------
193 template<jit::float_scalar T, jit::float_scalar M, bool SAFE_MATH=false>
194 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
195 const M y,
196 shared_leaf<T, SAFE_MATH> z) {
197 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, constant<T, SAFE_MATH> (static_cast<T> (y)), z);
198 }
199
200//------------------------------------------------------------------------------
211//------------------------------------------------------------------------------
212 template<jit::float_scalar T, jit::float_scalar R, bool SAFE_MATH=false>
213 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
214 shared_leaf<T, SAFE_MATH> y,
215 const R z) {
216 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, y, constant<T, SAFE_MATH> (static_cast<T> (z)));
217 }
218
219//------------------------------------------------------------------------------
231//------------------------------------------------------------------------------
232 template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar M, bool SAFE_MATH=false>
233 shared_vector<T, SAFE_MATH> vector(const L x,
234 const M y,
235 shared_leaf<T, SAFE_MATH> z) {
236 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)),
237 constant<T, SAFE_MATH> (static_cast<T> (y)), z);
238 }
239
240//------------------------------------------------------------------------------
252//------------------------------------------------------------------------------
253 template<jit::float_scalar T, jit::float_scalar M, jit::float_scalar R, bool SAFE_MATH=false>
254 shared_vector<T, SAFE_MATH> vector(shared_leaf<T, SAFE_MATH> x,
255 const M y,
256 const R z) {
257 return std::make_shared<vector_quantity<T, SAFE_MATH>> (x, constant<T, SAFE_MATH> (static_cast<T> (y)),
258 constant<T, SAFE_MATH> (static_cast<T> (z)));
259 }
260
261//------------------------------------------------------------------------------
273//------------------------------------------------------------------------------
274 template<jit::float_scalar T, jit::float_scalar L, jit::float_scalar R, bool SAFE_MATH=false>
275 shared_vector<T, SAFE_MATH> vector(const L x,
276 shared_leaf<T, SAFE_MATH> y,
277 const R z) {
278 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)), y,
279 constant<T, SAFE_MATH> (static_cast<T> (z)));
280 }
281
282//------------------------------------------------------------------------------
292//------------------------------------------------------------------------------
293 template<jit::float_scalar T, bool SAFE_MATH=false>
294 shared_vector<T, SAFE_MATH> vector(const T x,
295 const T y,
296 const T z) {
297 return std::make_shared<vector_quantity<T, SAFE_MATH>> (constant<T, SAFE_MATH> (static_cast<T> (x)),
298 constant<T, SAFE_MATH> (static_cast<T> (y)),
299 constant<T, SAFE_MATH> (static_cast<T> (z)));
300 }
301
302//------------------------------------------------------------------------------
311//------------------------------------------------------------------------------
312 template<jit::float_scalar T, bool SAFE_MATH=false>
313 shared_vector<T, SAFE_MATH> operator+(shared_vector<T, SAFE_MATH> l,
314 shared_vector<T, SAFE_MATH> r) {
315 return vector(l->get_x() + r->get_x(),
316 l->get_y() + r->get_y(),
317 l->get_z() + r->get_z());
318 }
319
320//------------------------------------------------------------------------------
329//------------------------------------------------------------------------------
330 template<jit::float_scalar T, bool SAFE_MATH=false>
331 shared_vector<T, SAFE_MATH> operator-(shared_vector<T, SAFE_MATH> l,
332 shared_vector<T, SAFE_MATH> r) {
333 return vector(l->get_x() - r->get_x(),
334 l->get_y() - r->get_y(),
335 l->get_z() - r->get_z());
336 }
337
338//------------------------------------------------------------------------------
347//------------------------------------------------------------------------------
348 template<jit::float_scalar T, bool SAFE_MATH=false>
349 shared_vector<T, SAFE_MATH> operator*(shared_leaf<T, SAFE_MATH> s,
350 shared_vector<T, SAFE_MATH> v) {
351 return vector(s*v->get_x(),
352 s*v->get_y(),
353 s*v->get_z());
354 }
355
356//------------------------------------------------------------------------------
365//------------------------------------------------------------------------------
366 template<jit::float_scalar T, bool SAFE_MATH=false>
367 shared_vector<T, SAFE_MATH> operator/(shared_vector<T, SAFE_MATH> v,
368 shared_leaf<T, SAFE_MATH> s) {
369 return vector(v->get_x()/s,
370 v->get_y()/s,
371 v->get_z()/s);
372 }
373
374//******************************************************************************
375// Matrix interface.
376//******************************************************************************
377//------------------------------------------------------------------------------
382//------------------------------------------------------------------------------
383 template<jit::float_scalar T, bool SAFE_MATH=false>
384 class matrix_quantity : public std::enable_shared_from_this<matrix_quantity<T, SAFE_MATH>> {
385 protected:
387 shared_vector<T, SAFE_MATH> r1;
389 shared_vector<T, SAFE_MATH> r2;
391 shared_vector<T, SAFE_MATH> r3;
392
393 public:
394//------------------------------------------------------------------------------
400//------------------------------------------------------------------------------
405
406//------------------------------------------------------------------------------
411//------------------------------------------------------------------------------
412 shared_vector<T, SAFE_MATH>
413 dot(shared_vector<T, SAFE_MATH> v) {
414 return vector<T, SAFE_MATH> (r1->dot(v),
415 r2->dot(v),
416 r3->dot(v));
417 }
418 };
419
421 template<jit::float_scalar T, bool SAFE_MATH=false>
422 using shared_matrix = std::shared_ptr<matrix_quantity<T, SAFE_MATH>>;
423
424//------------------------------------------------------------------------------
434//------------------------------------------------------------------------------
435 template<jit::float_scalar T, bool SAFE_MATH=false>
436 shared_matrix<T, SAFE_MATH> matrix(shared_vector<T, SAFE_MATH> r1,
437 shared_vector<T, SAFE_MATH> r2,
438 shared_vector<T, SAFE_MATH> r3) {
439 return std::make_shared<matrix_quantity<T, SAFE_MATH>> (r1, r2, r3);
440 }
441}
442
443#endif /* vector_h */
graph::matrix_quantity
Class to represent matrix quantities.
Definition vector.hpp:384
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:401
graph::matrix_quantity::r3
shared_vector< T, SAFE_MATH > r3
Third row of the matrix.
Definition vector.hpp:391
graph::matrix_quantity::r1
shared_vector< T, SAFE_MATH > r1
First row of the matrix.
Definition vector.hpp:387
graph::matrix_quantity::dot
shared_vector< T, SAFE_MATH > dot(shared_vector< T, SAFE_MATH > v)
Multiply matrix by vector.
Definition vector.hpp:413
graph::matrix_quantity::r2
shared_vector< T, SAFE_MATH > r2
Second row of the matrix.
Definition vector.hpp:389
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::df
std::shared_ptr< vector_quantity< T, SAFE_MATH > > df(shared_leaf< T, SAFE_MATH > arg)
Take a derivative with respect to each component.
Definition vector.hpp:122
graph::vector_quantity::remove_pseudo
std::shared_ptr< vector_quantity< T, SAFE_MATH > > remove_pseudo()
Remove pseudo variables.
Definition vector.hpp:133
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:986
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:142
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:156
graph::sqrt
shared_leaf< T, SAFE_MATH > sqrt(shared_leaf< T, SAFE_MATH > x)
Define sqrt convenience 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:436
graph::shared_matrix
std::shared_ptr< matrix_quantity< T, SAFE_MATH > > shared_matrix
Convenience type for shared vector quantities.
Definition vector.hpp:422
graph::shared_leaf
std::shared_ptr< leaf_node< T, SAFE_MATH > > shared_leaf
Convenience type alias for shared leaf nodes.
Definition node.hpp:676
node.hpp
Base nodes of graph computation framework.