概要

#include <boost/math/tools/rational.hpp>

// 多項式:
template <std::size_t N, class T, class V>
V evaluate_polynomial(const T(&poly)[N], const V& val);

template <std::size_t N, class T, class V>
V evaluate_polynomial(const boost::array<T,N>& poly, const V& val);

template <class T, class U>
U evaluate_polynomial(const T* poly, U z, std::size_t count);

// 偶多項式(Even polynomials):
template <std::size_t N, class T, class V>
V evaluate_even_polynomial(const T(&poly)[N], const V& z);

template <std::size_t N, class T, class V>
V evaluate_even_polynomial(const boost::array<T,N>& poly, const V& z);

template <class T, class U>
U evaluate_even_polynomial(const T* poly, U z, std::size_t count);

// 奇多項式(Odd polynomials)   
template <std::size_t N, class T, class V>
V evaluate_odd_polynomial(const T(&a)[N], const V& z);

template <std::size_t N, class T, class V>
V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z);

template <class T, class U>
U evaluate_odd_polynomial(const T* poly, U z, std::size_t count);

// 有理函數(Rational Functions):
template <std::size_t N, class T, class V>
V evaluate_rational(const T(&a)[N], const T(&b)[N], const V& z);

template <std::size_t N, class T, class V>
V evaluate_rational(const boost::array<T,N>& a, const boost::array<T,N>& b, const V& z);

template <class T, class U, class V>
V evaluate_rational(const T* num, const U* denom, V z, unsigned count);

說明

每個函數都有3個變種(variants)：一對重載的函數，其中多項式或有理函數的次數(order)是在編譯時計算的，以及一個在運行時接受係數數組大小的重載版本。一般來說，編譯時計算數組的大小可以帶來更好的類型安全性，產生錯誤的可能性也更小一些，並可能產生更好的優化代碼。尤其是多項式計算函數，對於多種數組大小進行了特化，允許迭代展開，優化的內聯展開。

template <std::size_t N, class T, class V>
V evaluate_polynomial(const T(&poly)[N], const V& val);

template <std::size_t N, class T, class V>
V evaluate_polynomial(const boost::array<T,N>& poly, const V& val);

template <class T, class U>
U evaluate_polynomial(const T* poly, U z, std::size_t count);

計算由存儲在 poly中的係數描述的多項式 。

如果這個數組的大小在運行時指定，那麼這個多項式的次數為count-1 且有 count 個係數。否則它的次數為N-1 且有 N 個係數。

係數的存儲應當滿足xⁱ 的係數存儲在 poly[i]中。

只要*poly可以轉換為U類型，那麼係數和變量z 的類型可以不同。這允許係數數組可以為一個整數數組。

template <std::size_t N, class T, class V>
V evaluate_even_polynomial(const T(&poly)[N], const V& z);

template <std::size_t N, class T, class V>
V evaluate_even_polynomial(const boost::array<T,N>& poly, const V& z);

template <class T, class U>
U evaluate_even_polynomial(const T* poly, U z, std::size_t count);

和上面一樣，但是計算一個偶多項式( even polynomial)：z的所有指數為偶數。等價於調用evaluate_polynomial(poly, z*z, count)。

template <std::size_t N, class T, class V>
V evaluate_odd_polynomial(const T(&a)[N], const V& z);

template <std::size_t N, class T, class V>
V evaluate_odd_polynomial(const boost::array<T,N>& a, const V& z);

template <class T, class U>
U evaluate_odd_polynomial(const T* poly, U z, std::size_t count);

和上面一樣，但是計算一個所有的指數都為奇數的多項式，等價於調用用evaluate_polynomial(poly+1, z*z, count-1) * z + poly[0]。

template <std::size_t N, class T, class U, class V>
V evaluate_rational(const T(&num)[N], const U(&denom)[N], const V& z);

template <std::size_t N, class T, class U, class V>
V evaluate_rational(const boost::array<T,N>& num, const boost::array<U,N>& denom, const V& z);

template <class T, class U, class V>
V evaluate_rational(const T* num, const U* denom, V z, unsigned count);

計算係數存儲在num 和 demom中的有理函數(兩個多項式的比值)。

如果數組的大小在運行時指定，那麼兩個多項式的次數必須為count-1 且有 count 個係數。否則兩個多項式的次數都為N-1 且有N 個係數。

數組num 表示分子( numerator)，而demon 表示分母( denominator)。

係數的存儲必須滿足 xⁱ 項的係數存儲在 num[i] 和 denom[i]中。

如果 *num 和 *denom 可以轉換為 V類型，那麼係數和變量v類型可以不一樣。這使得這兩個係數數組之一或是兩個都可以為整數數組。

設計這些函數用來安全地計算結果，即使z的值非常大。就其本身而論，它們並沒有利用編譯時的數組大小來進行任何的優化。這些函數最好保留到當z非常大的時候使用：如果你可以確信不會出現數值溢出，那麼編譯時數組大小已知的多項式計算可以提供更好的性能。

實現

多項式使用霍納法則(Horners method)來計算。 如果在編譯時數組的大小已知，那麼這些函數被指定使用大小特定的函數實現來展開計算中使用的循環。

有理函數計算使用霍納法則(Horners method)：兩個多項式並行計算來最大程度使用處理器浮點指令流水線( processors floating-point pipeline)。如果v 大於1 ，那麼多項式使用相反順序來計算：當係數太大時，這就可以避免數值溢出。

多項式和有理函數計算算法可以使用各種配置宏(configuration macros)來進行調整，使得可以對不同的平台和編譯器的組合進行性能優化。這包含對於二階霍納法則(second-order Horner's method)的支持。具體選項在這裡進行了說明。然而，在當前的大多數硬件體繫上，這種性能的提升是很小的，因此，在改變缺省設置之前最好運行性能測試程序 。