Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	src/catkin/robots/blmc_robots/include/blmc_robots/mathematics/polynome.hxx	Lines:	28	44	63.6 %
Date:	2020-04-15 11:50:02	Branches:	13	20	65.0 %


/**
 * @file polynome_impl.hh
 * @author Maximilien Naveau (maximilien.naveau@gmail.com)
 * @brief Polynomes object for trajectories.
 * @version 0.1
 * @date 2019-11-06
 *
 * @copyright Copyright (c) 2019
 *
 */

#pragma once


#include <iostream>
#include <vector>
#include "blmc_robots/mathematics/polynome.hpp"


namespace blmc_robots
{

/**
 * Polynome<ORDER> definitions
 */

template<int ORDER>
Polynome<ORDER>::Polynome()
{
  coefficients_.fill(0.0);
}

template<int ORDER>
Polynome<ORDER>::~Polynome()
{
}

template<int ORDER>
double Polynome<ORDER>::compute(double x)
{
  double res = 0.0;
  double pt = 1.0;
  for(size_t i = 0 ; i < coefficients_.size() ; ++i)
  {
      res += coefficients_[i] * pt;
      pt *= x;
  }
  return res;
}

template<int ORDER>
double Polynome<ORDER>::compute_derivative(double x)
{
  double res = 0.0;
  double pt = 1.0;
  for(size_t i = 1 ; i < coefficients_.size() ; ++i)
  {
      res += i * coefficients_[i] * pt;
      pt *= x ;
  }
  return res;
}

template<int ORDER>
double Polynome<ORDER>::compute_sec_derivative(double x)
{
  double res = 0.0;
  double pt = 1.0;
  for(size_t i = 2 ; i < coefficients_.size() ; ++i)
    {
      res += i * (i - 1) * coefficients_[i] * pt;
      pt *= x;
    }
  return res;
}

template<int ORDER>
void Polynome<ORDER>::get_coefficients(Coefficients &coefficients) const
{
  coefficients = coefficients_;
}

template<int ORDER>
void Polynome<ORDER>::set_coefficients(const Coefficients &coefficients)
{
  coefficients_ = coefficients;
}

template<int ORDER>
void Polynome<ORDER>::print() const
{
  for(size_t i = 0 ; i < ORDER ; ++i)
  {
    std::cout << coefficients_[i] << " " ;
  }
  std::cout << std::endl;
}

/**
 * TimePolynome<ORDER> definitions
 */

template<int ORDER>
double TimePolynome<ORDER>::compute(double t)
{
    if(t <= 0.0)
    {
        return init_pose_;
    }
    else if( t >= final_time_ )
    {
        return final_pose_;
    }
    else
    {
        return Polynome<ORDER>::compute(t);
    }

}

template<int ORDER>
double TimePolynome<ORDER>::compute_derivative(double t)
{
    if(t <= 0.0)
    {
        return init_speed_;
    }
    else if( t >= final_time_ )
    {
        return final_speed_;
    }
    else
    {
        return Polynome<ORDER>::compute_derivative(t);
    }
}

template<int ORDER>
double TimePolynome<ORDER>::compute_sec_derivative(double t)
{
    if(t <= 0.0)
    {
        return init_acc_;
    }
    else if( t >= final_time_ )
    {
        return final_acc_;
    }
    else
    {
        return Polynome<ORDER>::compute_sec_derivative(t);
    }
}


} // namespace blmc_robots


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/**
2			* @file polynome_impl.hh
3			* @author Maximilien Naveau (maximilien.naveau@gmail.com)
4			* @brief Polynomes object for trajectories.
5			* @version 0.1
6			* @date 2019-11-06
7			*
8			* @copyright Copyright (c) 2019
9			*
10			*/
11
12			#pragma once
13
14
15			#include <iostream>
16			#include <vector>
17			#include "blmc_robots/mathematics/polynome.hpp"
18
19
20			namespace blmc_robots
21			{
22
23			/**
24			* Polynome<ORDER> definitions
25			*/
26
27			template<int ORDER>
28		2	Polynome<ORDER>::Polynome()
29			{
30	✓✗	2	coefficients_.fill(0.0);
31		2	}
32
33			template<int ORDER>
34		2	Polynome<ORDER>::~Polynome()
35			{
36		2	}
37
38			template<int ORDER>
39		7143	double Polynome<ORDER>::compute(double x)
40			{
41		7143	double res = 0.0;
42		7143	double pt = 1.0;
43	✓✓	50001	for(size_t i = 0 ; i < coefficients_.size() ; ++i)
44			{
45		42858	res += coefficients_[i] * pt;
46		42858	pt *= x;
47			}
48		7143	return res;
49			}
50
51			template<int ORDER>
52			double Polynome<ORDER>::compute_derivative(double x)
53			{
54			double res = 0.0;
55			double pt = 1.0;
56			for(size_t i = 1 ; i < coefficients_.size() ; ++i)
57			{
58			res += i * coefficients_[i] * pt;
59			pt *= x ;
60			}
61			return res;
62			}
63
64			template<int ORDER>
65			double Polynome<ORDER>::compute_sec_derivative(double x)
66			{
67			double res = 0.0;
68			double pt = 1.0;
69			for(size_t i = 2 ; i < coefficients_.size() ; ++i)
70			{
71			res += i * (i - 1) * coefficients_[i] * pt;
72			pt *= x;
73			}
74			return res;
75			}
76
77			template<int ORDER>
78			void Polynome<ORDER>::get_coefficients(Coefficients &coefficients) const
79			{
80			coefficients = coefficients_;
81			}
82
83			template<int ORDER>
84			void Polynome<ORDER>::set_coefficients(const Coefficients &coefficients)
85			{
86			coefficients_ = coefficients;
87			}
88
89			template<int ORDER>
90			void Polynome<ORDER>::print() const
91			{
92			for(size_t i = 0 ; i < ORDER ; ++i)
93			{
94			std::cout << coefficients_[i] << " " ;
95			}
96			std::cout << std::endl;
97			}
98
99			/**
100			* TimePolynome<ORDER> definitions
101			*/
102
103			template<int ORDER>
104		10012	double TimePolynome<ORDER>::compute(double t)
105			{
106	✓✓	10012	if(t <= 0.0)
107			{
108		1430	return init_pose_;
109			}
110	✓✓	8582	else if( t >= final_time_ )
111			{
112		1439	return final_pose_;
113			}
114			else
115			{
116		7143	return Polynome<ORDER>::compute(t);
117			}
118
119			}
120
121			template<int ORDER>
122		2	double TimePolynome<ORDER>::compute_derivative(double t)
123			{
124	✓✓	2	if(t <= 0.0)
125			{
126		1	return init_speed_;
127			}
128	✓✗	1	else if( t >= final_time_ )
129			{
130		1	return final_speed_;
131			}
132			else
133			{
134			return Polynome<ORDER>::compute_derivative(t);
135			}
136			}
137
138			template<int ORDER>
139		2	double TimePolynome<ORDER>::compute_sec_derivative(double t)
140			{
141	✓✓	2	if(t <= 0.0)
142			{
143		1	return init_acc_;
144			}
145	✓✗	1	else if( t >= final_time_ )
146			{
147		1	return final_acc_;
148			}
149			else
150			{
151			return Polynome<ORDER>::compute_sec_derivative(t);
152			}
153			}
154
155
156			} // namespace blmc_robots