Loading...
Searching...
No Matches
polynomial.h
Go to the documentation of this file.
1
13#ifndef _STRUCT_POLYNOMIAL
14#define _STRUCT_POLYNOMIAL
15
16#include <algorithm>
17#include <functional>
18#include <iostream>
19#include <stdexcept>
20
21#include "MathDefs.h"
22#include "curve_abc.h"
23
24namespace ndcurves {
31template <typename Time = double, typename Numeric = Time, bool Safe = false,
32 typename Point = Eigen::Matrix<Numeric, Eigen::Dynamic, 1>,
33 typename T_Point =
34 std::vector<Point, Eigen::aligned_allocator<Point> > >
35struct polynomial : public curve_abc<Time, Numeric, Safe, Point> {
36 typedef Point point_t;
37 typedef T_Point t_point_t;
38 typedef Time time_t;
39 typedef Numeric num_t;
41 typedef Eigen::MatrixXd coeff_t;
42 typedef Eigen::Ref<coeff_t> coeff_t_ref;
45
46 /* Constructors - destructors */
47 public:
52
59 polynomial(const coeff_t& coefficients, const time_t min, const time_t max)
60 : curve_abc_t(),
61 dim_(coefficients.rows()),
62 coefficients_(coefficients),
63 degree_(coefficients.cols() - 1),
64 T_min_(min),
65 T_max_(max) {
66 safe_check();
67 }
68
76 polynomial(const T_Point& coefficients, const time_t min, const time_t max)
77 : curve_abc_t(),
78 dim_(coefficients.begin()->size()),
79 coefficients_(init_coeffs(coefficients.begin(), coefficients.end())),
80 degree_(coefficients_.cols() - 1),
81 T_min_(min),
82 T_max_(max) {
83 safe_check();
84 }
85
93 template <typename In>
94 polynomial(In zeroOrderCoefficient, In out, const time_t min,
95 const time_t max)
96 : curve_abc_t(),
97 dim_(zeroOrderCoefficient->size()),
98 coefficients_(init_coeffs(zeroOrderCoefficient, out)),
99 degree_(coefficients_.cols() - 1),
100 T_min_(min),
101 T_max_(max) {
102 safe_check();
103 }
104
112 polynomial(const Point& init, const Point& end, const time_t min,
113 const time_t max)
114 : dim_(init.size()), degree_(1), T_min_(min), T_max_(max) {
115 if (T_min_ >= T_max_)
116 throw std::invalid_argument("T_min must be strictly lower than T_max");
117 if (init.size() != end.size())
118 throw std::invalid_argument(
119 "init and end points must have the same dimensions.");
120 t_point_t coeffs;
121 coeffs.push_back(init);
122 coeffs.push_back((end - init) / (max - min));
123 coefficients_ = init_coeffs(coeffs.begin(), coeffs.end());
124 safe_check();
125 }
126
137 polynomial(const Point& init, const Point& d_init, const Point& end,
138 const Point& d_end, const time_t min, const time_t max)
139 : dim_(init.size()), degree_(3), T_min_(min), T_max_(max) {
140 if (T_min_ >= T_max_)
141 throw std::invalid_argument("T_min must be strictly lower than T_max");
142 if (init.size() != end.size())
143 throw std::invalid_argument(
144 "init and end points must have the same dimensions.");
145 if (init.size() != d_init.size())
146 throw std::invalid_argument(
147 "init and d_init points must have the same dimensions.");
148 if (init.size() != d_end.size())
149 throw std::invalid_argument(
150 "init and d_end points must have the same dimensions.");
151 /* the coefficients [c0 c1 c2 c3] are found by solving the following system
152 of equation (found from the boundary conditions) : [1 0 0 0 ] [c0]
153 [ init ] [1 T T^2 T^3 ] x [c1] = [ end ] [0 1 0 0 ] [c2] [d_init]
154 [0 1 2T 3T^2] [c3] [d_end ]
155 */
156 double T = max - min;
157 Eigen::Matrix<double, 4, 4> m;
158 m << 1., 0, 0, 0, 1., T, T * T, T * T * T, 0, 1., 0, 0, 0, 1., 2. * T,
159 3. * T * T;
160 Eigen::Matrix<double, 4, 4> m_inv = m.inverse();
161 Eigen::Matrix<double, 4, 1> bc; // boundary condition vector
162 coefficients_ = coeff_t::Zero(
163 dim_, degree_ + 1); // init coefficient matrix with the right size
164 for (size_t i = 0; i < dim_;
165 ++i) { // for each dimension, solve the boundary condition problem :
166 bc[0] = init[i];
167 bc[1] = end[i];
168 bc[2] = d_init[i];
169 bc[3] = d_end[i];
170 coefficients_.row(i) = (m_inv * bc).transpose();
171 }
172 safe_check();
173 }
174
187 polynomial(const Point& init, const Point& d_init, const Point& dd_init,
188 const Point& end, const Point& d_end, const Point& dd_end,
189 const time_t min, const time_t max)
190 : dim_(init.size()), degree_(5), T_min_(min), T_max_(max) {
191 if (T_min_ >= T_max_)
192 throw std::invalid_argument("T_min must be strictly lower than T_max");
193 if (init.size() != end.size())
194 throw std::invalid_argument(
195 "init and end points must have the same dimensions.");
196 if (init.size() != d_init.size())
197 throw std::invalid_argument(
198 "init and d_init points must have the same dimensions.");
199 if (init.size() != d_end.size())
200 throw std::invalid_argument(
201 "init and d_end points must have the same dimensions.");
202 if (init.size() != dd_init.size())
203 throw std::invalid_argument(
204 "init and dd_init points must have the same dimensions.");
205 if (init.size() != dd_end.size())
206 throw std::invalid_argument(
207 "init and dd_end points must have the same dimensions.");
208 /* the coefficients [c0 c1 c2 c3 c4 c5] are found by solving the following
209 system of equation (found from the boundary conditions) : [1 0 0 0 0
210 0 ] [c0] [ init ] [1 T T^2 T^3 T^4 T^5 ] [c1] [ end ] [0
211 1 0 0 0 0 ] [c2] [d_init ] [0 1 2T 3T^2 4T^3 5T^4 ] x
212 [c3] = [d_end ] [0 0 2 0 0 0 ] [c4] [dd_init] [0 0 2 6T
213 12T^2 20T^3] [c5] [dd_end ]
214 */
215 double T = max - min;
216 Eigen::Matrix<double, 6, 6> m;
217 m << 1., 0, 0, 0, 0, 0, 1., T, T * T, pow(T, 3), pow(T, 4), pow(T, 5), 0,
218 1., 0, 0, 0, 0, 0, 1., 2. * T, 3. * T * T, 4. * pow(T, 3),
219 5. * pow(T, 4), 0, 0, 2, 0, 0, 0, 0, 0, 2, 6. * T, 12. * T * T,
220 20. * pow(T, 3);
221 Eigen::Matrix<double, 6, 6> m_inv = m.inverse();
222 Eigen::Matrix<double, 6, 1> bc; // boundary condition vector
223 coefficients_ = coeff_t::Zero(
224 dim_, degree_ + 1); // init coefficient matrix with the right size
225 for (size_t i = 0; i < dim_;
226 ++i) { // for each dimension, solve the boundary condition problem :
227 bc[0] = init[i];
228 bc[1] = end[i];
229 bc[2] = d_init[i];
230 bc[3] = d_end[i];
231 bc[4] = dd_init[i];
232 bc[5] = dd_end[i];
233 coefficients_.row(i) = (m_inv * bc).transpose();
234 }
235 safe_check();
236 }
237
239 virtual ~polynomial() {}
240
241 polynomial(const polynomial& other)
242 : dim_(other.dim_),
244 degree_(other.degree_),
245 T_min_(other.T_min_),
246 T_max_(other.T_max_) {}
247
248 // polynomial& operator=(const polynomial& other);
249
260 static polynomial_t MinimumJerk(const point_t& p_init, const point_t& p_final,
261 const time_t t_min = 0.,
262 const time_t t_max = 1.) {
263 if (t_min > t_max)
264 throw std::invalid_argument(
265 "final time should be superior or equal to initial time.");
266 const size_t dim(p_init.size());
267 if (static_cast<size_t>(p_final.size()) != dim)
268 throw std::invalid_argument(
269 "Initial and final points must have the same dimension.");
270 const double T = t_max - t_min;
271 const double T2 = T * T;
272 const double T3 = T2 * T;
273 const double T4 = T3 * T;
274 const double T5 = T4 * T;
275
276 coeff_t coeffs =
277 coeff_t::Zero(dim, 6); // init coefficient matrix with the right size
278 coeffs.col(0) = p_init;
279 coeffs.col(3) = 10 * (p_final - p_init) / T3;
280 coeffs.col(4) = -15 * (p_final - p_init) / T4;
281 coeffs.col(5) = 6 * (p_final - p_init) / T5;
282 return polynomial_t(coeffs, t_min, t_max);
283 }
284
285 private:
286 void safe_check() {
287 if (Safe) {
288 if (T_min_ > T_max_) {
289 throw std::invalid_argument("Tmin should be inferior to Tmax");
290 }
291 if (coefficients_.cols() != int(degree_ + 1)) {
292 throw std::runtime_error("Spline order and coefficients do not match");
293 }
294 }
295 }
296
297 /* Constructors - destructors */
298
299 /*Operations*/
300 public:
304 virtual point_t operator()(const time_t t) const {
305 check_if_not_empty();
306 if ((t < T_min_ || t > T_max_) && Safe) {
307 throw std::invalid_argument(
308 "error in polynomial : time t to evaluate should be in range [Tmin, "
309 "Tmax] of the curve");
310 }
311 time_t const dt(t - T_min_);
313 for (int i = (int)(degree_ - 1); i >= 0; i--) {
314 h = dt * h + coefficients_.col(i);
315 }
316 return h;
317 }
318
329 const polynomial_t& other,
330 const Numeric prec = Eigen::NumTraits<Numeric>::dummy_precision()) const {
331 return ndcurves::isApprox<num_t>(T_min_, other.min()) &&
332 ndcurves::isApprox<num_t>(T_max_, other.max()) &&
333 dim_ == other.dim() && degree_ == other.degree() &&
334 coefficients_.isApprox(other.coefficients_, prec);
335 }
336
337 virtual bool isApprox(
338 const curve_abc_t* other,
339 const Numeric prec = Eigen::NumTraits<Numeric>::dummy_precision()) const {
340 const polynomial_t* other_cast = dynamic_cast<const polynomial_t*>(other);
341 if (other_cast)
342 return isApprox(*other_cast, prec);
343 else
344 return false;
345 }
346
347 virtual bool operator==(const polynomial_t& other) const {
348 return isApprox(other);
349 }
350
351 virtual bool operator!=(const polynomial_t& other) const {
352 return !(*this == other);
353 }
354
360 virtual point_t derivate(const time_t t, const std::size_t order) const {
361 check_if_not_empty();
362 if ((t < T_min_ || t > T_max_) && Safe) {
363 throw std::invalid_argument(
364 "error in polynomial : time t to evaluate derivative should be in "
365 "range [Tmin, Tmax] of the curve");
366 }
367 time_t const dt(t - T_min_);
368 time_t cdt(1);
369 point_t currentPoint_ = point_t::Zero(dim_);
370 for (int i = (int)(order); i < (int)(degree_ + 1); ++i, cdt *= dt) {
371 currentPoint_ += cdt * coefficients_.col(i) * fact(i, order);
372 }
373 return currentPoint_;
374 }
375
376 polynomial_t compute_derivate(const std::size_t order) const {
377 check_if_not_empty();
378 if (order == 0) {
379 return *this;
380 }
381 coeff_t coeff_derivated = deriv_coeff(coefficients_);
382 polynomial_t deriv(coeff_derivated, T_min_, T_max_);
383 return deriv.compute_derivate(order - 1);
384 }
385
390 polynomial_t* compute_derivate_ptr(const std::size_t order) const {
391 return new polynomial_t(compute_derivate(order));
392 }
393
394 Eigen::MatrixXd coeff() const { return coefficients_; }
395
396 point_t coeffAtDegree(const std::size_t degree) const {
397 point_t res;
398 if (degree <= degree_) {
399 res = coefficients_.col(degree);
400 }
401 return res;
402 }
403
404 private:
405 num_t fact(const std::size_t n, const std::size_t order) const {
406 num_t res(1);
407 for (std::size_t i = 0; i < std::size_t(order); ++i) {
408 res *= (num_t)(n - i);
409 }
410 return res;
411 }
412
413 coeff_t deriv_coeff(coeff_t coeff) const {
414 if (coeff.cols() == 1) // only the constant part is left, fill with 0
415 return coeff_t::Zero(coeff.rows(), 1);
416 coeff_t coeff_derivated(coeff.rows(), coeff.cols() - 1);
417 for (std::size_t i = 0; i < std::size_t(coeff_derivated.cols()); i++) {
418 coeff_derivated.col(i) = coeff.col(i + 1) * (num_t)(i + 1);
419 }
420 return coeff_derivated;
421 }
422
423 void check_if_not_empty() const {
424 if (coefficients_.size() == 0) {
425 throw std::runtime_error(
426 "Error in polynomial : there is no coefficients set / did you use "
427 "empty constructor ?");
428 }
429 }
430 /*Operations*/
431
432 public:
433 /*Helpers*/
436 std::size_t virtual dim() const { return dim_; };
439 num_t virtual min() const { return T_min_; }
442 num_t virtual max() const { return T_max_; }
445 virtual std::size_t degree() const { return degree_; }
446 /*Helpers*/
447
449 assert_operator_compatible(p1);
450 if (p1.degree() > degree()) {
451 polynomial_t::coeff_t res = p1.coeff();
452 res.block(0, 0, coefficients_.rows(), coefficients_.cols()) +=
454 coefficients_ = res;
455 degree_ = p1.degree();
456 } else {
457 coefficients_.block(0, 0, p1.coeff().rows(), p1.coeff().cols()) +=
458 p1.coeff();
459 }
460 return *this;
461 }
462
464 assert_operator_compatible(p1);
465 if (p1.degree() > degree()) {
466 polynomial_t::coeff_t res = -p1.coeff();
467 res.block(0, 0, coefficients_.rows(), coefficients_.cols()) +=
469 coefficients_ = res;
470 degree_ = p1.degree();
471 } else {
472 coefficients_.block(0, 0, p1.coeff().rows(), p1.coeff().cols()) -=
473 p1.coeff();
474 }
475 return *this;
476 }
477
479 coefficients_.col(0) += point;
480 return *this;
481 }
482
484 coefficients_.col(0) -= point;
485 return *this;
486 }
487
488 polynomial_t& operator/=(const double d) {
489 coefficients_ /= d;
490 return *this;
491 }
492
493 polynomial_t& operator*=(const double d) {
494 coefficients_ *= d;
495 return *this;
496 }
497
506 polynomial_t cross(const polynomial_t& pOther) const {
507 assert_operator_compatible(pOther);
508 if (dim() != 3)
509 throw std::invalid_argument(
510 "Can't perform cross product on polynomials with dimensions != 3 ");
511 std::size_t new_degree = degree() + pOther.degree();
512 coeff_t nCoeffs = Eigen::MatrixXd::Zero(3, new_degree + 1);
513 Eigen::Vector3d currentVec;
514 Eigen::Vector3d currentVecCrossed;
515 for (long i = 0; i < coefficients_.cols(); ++i) {
516 currentVec = coefficients_.col(i);
517 for (long j = 0; j < pOther.coeff().cols(); ++j) {
518 currentVecCrossed = pOther.coeff().col(j);
519 nCoeffs.col(i + j) += currentVec.cross(currentVecCrossed);
520 }
521 }
522 // remove last degrees is they are equal to 0
523 long final_degree = new_degree;
524 while (nCoeffs.col(final_degree).norm() <= ndcurves::MARGIN &&
525 final_degree > 0) {
526 --final_degree;
527 }
528 return polynomial_t(nCoeffs.leftCols(final_degree + 1), min(), max());
529 }
530
540 if (dim() != 3)
541 throw std::invalid_argument(
542 "Can't perform cross product on polynomials with dimensions != 3 ");
543 coeff_t nCoeffs = coefficients_;
544 Eigen::Vector3d currentVec;
545 Eigen::Vector3d pointVec = point;
546 for (long i = 0; i < coefficients_.cols(); ++i) {
547 currentVec = coefficients_.col(i);
548 nCoeffs.col(i) = currentVec.cross(pointVec);
549 }
550 // remove last degrees is they are equal to 0
551 long final_degree = degree();
552 while (nCoeffs.col(final_degree).norm() <= ndcurves::MARGIN &&
553 final_degree > 0) {
554 --final_degree;
555 }
556 return polynomial_t(nCoeffs.leftCols(final_degree + 1), min(), max());
557 }
558
559 /*Attributes*/
560 std::size_t dim_; // const
562 std::size_t degree_; // const
564 /*Attributes*/
565
566 private:
567 void assert_operator_compatible(const polynomial_t& other) const {
568 if ((fabs(min() - other.min()) > ndcurves::MARGIN) ||
569 (fabs(max() - other.max()) > ndcurves::MARGIN) ||
570 dim() != other.dim()) {
571 throw std::invalid_argument(
572 "Can't perform base operation (+ - ) on two polynomials with "
573 "different time ranges or different dimensions");
574 }
575 }
576
577 template <typename In>
578 coeff_t init_coeffs(In zeroOrderCoefficient, In highestOrderCoefficient) {
579 std::size_t size =
580 std::distance(zeroOrderCoefficient, highestOrderCoefficient);
581 coeff_t res = coeff_t(dim_, size);
582 int i = 0;
583 for (In cit = zeroOrderCoefficient; cit != highestOrderCoefficient;
584 ++cit, ++i) {
585 res.col(i) = *cit;
586 }
587 return res;
588 }
589
590 public:
591 // Serialization of the class
593
594 template <class Archive>
595 void serialize(Archive& ar, const unsigned int version) {
596 if (version) {
597 // Do something depending on version ?
598 }
599 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(curve_abc_t);
600 ar& boost::serialization::make_nvp("dim", dim_);
601 ar& boost::serialization::make_nvp("coefficients", coefficients_);
602 ar& boost::serialization::make_nvp("dim", dim_);
603 ar& boost::serialization::make_nvp("degree", degree_);
604 ar& boost::serialization::make_nvp("T_min", T_min_);
605 ar& boost::serialization::make_nvp("T_max", T_max_);
606 }
607
608}; // class polynomial
609
610template <typename T, typename N, bool S, typename P, typename TP>
612 const polynomial<T, N, S, P, TP>& p2) {
614 return res += p2;
615}
616
617template <typename T, typename N, bool S, typename P, typename TP>
620 const typename polynomial<T, N, S, P, TP>::point_t& point) {
622 return res += point;
623}
624
625template <typename T, typename N, bool S, typename P, typename TP>
627 const typename polynomial<T, N, S, P, TP>::point_t& point,
628 const polynomial<T, N, S, P, TP>& p1) {
630 return res += point;
631}
632
633template <typename T, typename N, bool S, typename P, typename TP>
636 const typename polynomial<T, N, S, P, TP>::point_t& point) {
638 return res -= point;
639}
640
641template <typename T, typename N, bool S, typename P, typename TP>
643 const typename polynomial<T, N, S, P, TP>::point_t& point,
644 const polynomial<T, N, S, P, TP>& p1) {
646 return res += point;
647}
648
649template <typename T, typename N, bool S, typename P, typename TP>
651 typename polynomial<T, N, S, P, TP>::coeff_t res = -p1.coeff();
652 return polynomial<T, N, S, P, TP>(res, p1.min(), p1.max());
653}
654
655template <typename T, typename N, bool S, typename P, typename TP>
657 const polynomial<T, N, S, P, TP>& p2) {
659 return res -= p2;
660}
661
662template <typename T, typename N, bool S, typename P, typename TP>
664 const double k) {
666 return res /= k;
667}
668
669template <typename T, typename N, bool S, typename P, typename TP>
671 const double k) {
673 return res *= k;
674}
675
676template <typename T, typename N, bool S, typename P, typename TP>
678 const polynomial<T, N, S, P, TP>& p1) {
680 return res *= k;
681}
682
683} // namespace ndcurves
684
686 SINGLE_ARG(typename Time, typename Numeric, bool Safe, typename Point,
687 typename T_Point),
689#endif //_STRUCT_POLYNOMIAL
#define DEFINE_CLASS_TEMPLATE_VERSION(Template, Type)
Definition: archive.hpp:27
#define SINGLE_ARG(...)
Definition: archive.hpp:23
interface for a Curve of arbitrary dimension.
Eigen::Matrix< Numeric, Eigen::Dynamic, 1 > Point
Definition: effector_spline.h:28
double Numeric
Definition: effector_spline.h:26
double Time
Definition: effector_spline.h:27
std::vector< Point, Eigen::aligned_allocator< Point > > T_Point
Definition: effector_spline.h:29
Definition: bernstein.h:20
bezier_curve< T, N, S, P > operator*(const bezier_curve< T, N, S, P > &p1, const double k)
Definition: bezier_curve.h:812
bezier_curve< T, N, S, P > operator/(const bezier_curve< T, N, S, P > &p1, const double k)
Definition: bezier_curve.h:805
bezier_curve< T, N, S, P > operator-(const bezier_curve< T, N, S, P > &p1)
Definition: bezier_curve.h:755
polynomial_t::coeff_t coeff_t
Definition: python_definitions.h:32
bezier_curve< T, N, S, P > operator+(const bezier_curve< T, N, S, P > &p1, const bezier_curve< T, N, S, P > &p2)
Definition: bezier_curve.h:748
Represents a curve of dimension Dim. If value of parameter Safe is false, no verification is made on ...
Definition: curve_abc.h:37
boost::shared_ptr< curve_t > curve_ptr_t
Definition: curve_abc.h:46
Represents a polynomial of an arbitrary order defined on the interval . It follows the equation : ...
Definition: polynomial.h:35
virtual num_t min() const
Get the minimum time for which the curve is defined.
Definition: polynomial.h:439
polynomial< Time, Numeric, Safe, Point, T_Point > polynomial_t
Definition: polynomial.h:43
polynomial_t cross(const polynomial_t &pOther) const
Compute the cross product of the current polynomial by another polynomial. The cross product p1Xp2 of...
Definition: polynomial.h:506
polynomial()
Empty constructor. Curve obtained this way can not perform other class functions.
Definition: polynomial.h:51
polynomial_t cross(const polynomial_t::point_t &point) const
Compute the cross product of the current polynomial p by a point point. The cross product pXpoint of ...
Definition: polynomial.h:539
virtual std::size_t dim() const
Get dimension of curve.
Definition: polynomial.h:436
polynomial_t compute_derivate(const std::size_t order) const
Definition: polynomial.h:376
virtual bool operator!=(const polynomial_t &other) const
Definition: polynomial.h:351
Time time_t
Definition: polynomial.h:38
curve_abc< Time, Numeric, Safe, Point > curve_abc_t
Definition: polynomial.h:40
polynomial_t * compute_derivate_ptr(const std::size_t order) const
Compute the derived curve at order N.
Definition: polynomial.h:390
std::size_t dim_
Definition: polynomial.h:560
Point point_t
Definition: polynomial.h:36
bool isApprox(const polynomial_t &other, const Numeric prec=Eigen::NumTraits< Numeric >::dummy_precision()) const
isApprox check if other and *this are approximately equals. Only two curves of the same class can be ...
Definition: polynomial.h:328
Numeric num_t
Definition: polynomial.h:39
void serialize(Archive &ar, const unsigned int version)
Definition: polynomial.h:595
coeff_t coefficients_
Definition: polynomial.h:561
virtual bool isApprox(const curve_abc_t *other, const Numeric prec=Eigen::NumTraits< Numeric >::dummy_precision()) const
Definition: polynomial.h:337
virtual ~polynomial()
Destructor.
Definition: polynomial.h:239
polynomial(const polynomial &other)
Definition: polynomial.h:241
Eigen::MatrixXd coeff() const
Definition: polynomial.h:394
polynomial_t & operator-=(const polynomial_t &p1)
Definition: polynomial.h:463
polynomial(const Point &init, const Point &end, const time_t min, const time_t max)
Constructor from boundary condition with C0 : create a polynomial that connect exactly init and end (...
Definition: polynomial.h:112
virtual point_t derivate(const time_t t, const std::size_t order) const
Evaluation of the derivative of order N of spline at time t.
Definition: polynomial.h:360
polynomial(const Point &init, const Point &d_init, const Point &end, const Point &d_end, const time_t min, const time_t max)
Constructor from boundary condition with C1 : create a polynomial that connect exactly init and end a...
Definition: polynomial.h:137
T_Point t_point_t
Definition: polynomial.h:37
polynomial_t & operator*=(const double d)
Definition: polynomial.h:493
virtual point_t operator()(const time_t t) const
Evaluation of the cubic spline at time t using horner's scheme.
Definition: polynomial.h:304
curve_abc_t::curve_ptr_t curve_ptr_t
Definition: polynomial.h:44
polynomial_t & operator-=(const polynomial_t::point_t &point)
Definition: polynomial.h:483
std::size_t degree_
Definition: polynomial.h:562
Eigen::Ref< coeff_t > coeff_t_ref
Definition: polynomial.h:42
polynomial(In zeroOrderCoefficient, In out, const time_t min, const time_t max)
Constructor.
Definition: polynomial.h:94
time_t T_min_
Definition: polynomial.h:563
polynomial(const coeff_t &coefficients, const time_t min, const time_t max)
Constructor.
Definition: polynomial.h:59
polynomial_t & operator+=(const polynomial_t::point_t &point)
Definition: polynomial.h:478
polynomial(const T_Point &coefficients, const time_t min, const time_t max)
Constructor.
Definition: polynomial.h:76
virtual num_t max() const
Get the maximum time for which the curve is defined.
Definition: polynomial.h:442
virtual bool operator==(const polynomial_t &other) const
Definition: polynomial.h:347
friend class boost::serialization::access
Definition: polynomial.h:592
static polynomial_t MinimumJerk(const point_t &p_init, const point_t &p_final, const time_t t_min=0., const time_t t_max=1.)
MinimumJerk Build a polynomial curve connecting p_init to p_final minimizing the time integral of the...
Definition: polynomial.h:260
polynomial_t & operator+=(const polynomial_t &p1)
Definition: polynomial.h:448
point_t coeffAtDegree(const std::size_t degree) const
Definition: polynomial.h:396
polynomial(const Point &init, const Point &d_init, const Point &dd_init, const Point &end, const Point &d_end, const Point &dd_end, const time_t min, const time_t max)
Constructor from boundary condition with C2 : create a polynomial that connect exactly init and end a...
Definition: polynomial.h:187
virtual std::size_t degree() const
Get the degree of the curve.
Definition: polynomial.h:445
time_t T_max_
Definition: polynomial.h:563
polynomial_t & operator/=(const double d)
Definition: polynomial.h:488
Eigen::MatrixXd coeff_t
Definition: polynomial.h:41