← Back to branch summary

~ubuntu-branches/ubuntu/saucy/merkaartor/saucy

« back to all changes in this revision

Viewing changes to include/builtin-boost/boost/math/tools/detail/polynomial_horner1_19.hpp

Tags: upstream-0.15.3+svn20934
Import upstream version 0.15.3+svn20934

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/builtin-boost/boost/math/tools/detail/polynomial_horner1_19.hpp
 
1
//  (C) Copyright John Maddock 2007.
 
2
//  Use, modification and distribution are subject to the
 
3
//  Boost Software License, Version 1.0. (See accompanying file
 
4
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
5
//
 
6
//  This file is machine generated, do not edit by hand
 
7
 
 
8
// Polynomial evaluation using Horners rule
 
9
#ifndef BOOST_MATH_TOOLS_POLY_EVAL_19_HPP
 
10
#define BOOST_MATH_TOOLS_POLY_EVAL_19_HPP
 
11
 
 
12
namespace boost{ namespace math{ namespace tools{ namespace detail{
 
13
 
 
14
template <class T, class V>
 
15
inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<0>*)
 
16
{
 
17
   return static_cast<V>(0);
 
18
}
 
19
 
 
20
template <class T, class V>
 
21
inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*)
 
22
{
 
23
   return static_cast<V>(a[0]);
 
24
}
 
25
 
 
26
template <class T, class V>
 
27
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*)
 
28
{
 
29
   return static_cast<V>(a[1] * x + a[0]);
 
30
}
 
31
 
 
32
template <class T, class V>
 
33
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*)
 
34
{
 
35
   return static_cast<V>((a[2] * x + a[1]) * x + a[0]);
 
36
}
 
37
 
 
38
template <class T, class V>
 
39
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*)
 
40
{
 
41
   return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]);
 
42
}
 
43
 
 
44
template <class T, class V>
 
45
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<5>*)
 
46
{
 
47
   return static_cast<V>((((a[4] * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
48
}
 
49
 
 
50
template <class T, class V>
 
51
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<6>*)
 
52
{
 
53
   return static_cast<V>(((((a[5] * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
54
}
 
55
 
 
56
template <class T, class V>
 
57
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<7>*)
 
58
{
 
59
   return static_cast<V>((((((a[6] * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
60
}
 
61
 
 
62
template <class T, class V>
 
63
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<8>*)
 
64
{
 
65
   return static_cast<V>(((((((a[7] * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
66
}
 
67
 
 
68
template <class T, class V>
 
69
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<9>*)
 
70
{
 
71
   return static_cast<V>((((((((a[8] * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
72
}
 
73
 
 
74
template <class T, class V>
 
75
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<10>*)
 
76
{
 
77
   return static_cast<V>(((((((((a[9] * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
78
}
 
79
 
 
80
template <class T, class V>
 
81
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<11>*)
 
82
{
 
83
   return static_cast<V>((((((((((a[10] * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
84
}
 
85
 
 
86
template <class T, class V>
 
87
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<12>*)
 
88
{
 
89
   return static_cast<V>(((((((((((a[11] * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
90
}
 
91
 
 
92
template <class T, class V>
 
93
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<13>*)
 
94
{
 
95
   return static_cast<V>((((((((((((a[12] * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
96
}
 
97
 
 
98
template <class T, class V>
 
99
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<14>*)
 
100
{
 
101
   return static_cast<V>(((((((((((((a[13] * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
102
}
 
103
 
 
104
template <class T, class V>
 
105
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<15>*)
 
106
{
 
107
   return static_cast<V>((((((((((((((a[14] * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
108
}
 
109
 
 
110
template <class T, class V>
 
111
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<16>*)
 
112
{
 
113
   return static_cast<V>(((((((((((((((a[15] * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
114
}
 
115
 
 
116
template <class T, class V>
 
117
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<17>*)
 
118
{
 
119
   return static_cast<V>((((((((((((((((a[16] * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
120
}
 
121
 
 
122
template <class T, class V>
 
123
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<18>*)
 
124
{
 
125
   return static_cast<V>(((((((((((((((((a[17] * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
126
}
 
127
 
 
128
template <class T, class V>
 
129
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<19>*)
 
130
{
 
131
   return static_cast<V>((((((((((((((((((a[18] * x + a[17]) * x + a[16]) * x + a[15]) * x + a[14]) * x + a[13]) * x + a[12]) * x + a[11]) * x + a[10]) * x + a[9]) * x + a[8]) * x + a[7]) * x + a[6]) * x + a[5]) * x + a[4]) * x + a[3]) * x + a[2]) * x + a[1]) * x + a[0]);
 
132
}
 
133
 
 
134
 
 
135
}}}} // namespaces
 
136
 
 
137
#endif // include guard
 
138