# Math Math provides various useful functions and constants. A number of useful function objects that operate with certain procedures in this part of the library is available from the Functors section. ## Interface ### Scalar Functions
      template <typename T, typename U>
      T round_cast(const U &u)
| A rounding type-cast, useful when converting floating-point types to integer types. When casting between floating-point types, rounding is not applied.
      template <typename T>
      T log2(const T n)
| Returns the largest result such that (2^result <= n). This version is intended for use with integer types, use std::tr1::log2() for floating point types.
      template <typename T>
      bool isPower2(const T x)
| Returns true if x is a power of two. Only for integral types.
      template <typename T>
      T clamp(const T &x, const T &low, const T &high)
| Returns the value of in the range [low, high] closest to x.
      template <typename T>
      T factorial(const T &x)
| Returns x!.
      template <typename T>
      T gcd(T u, T v)
| Greatest common divisor.
        template <typename T>
      T binomial(const T n, const T k)
| Binomial coefficient, choose k out of n.
        template <typename T, typename U>
      U binopmf(const T n, const T k, const U p)
| Probability mass function for the binomial distribution.
        template <typename T, typename U>
      U binocdf(const T n, const T k, const U p)
| Cumulative distribution function for the binomial distribution.
### Vector Functions
      template <typename T>
      ValueType<T>::value_type modulus(const T &x)
| Computes the modulus of scalars and Vectors.
      template <typename Iterator, typename T>
      T average(Iterator begin, Iterator end, const T init)
| Returns the average of the values in the range [begin, end].
      template <typename Iterator, typename T>
      T median(Iterator begin, Iterator end, const T init)
| Returns the median of the values in the range [begin, end].
      template <typename Iterator, typename T>
      T deviation(Iterator begin, Iterator end, T init)
| Returns init plus the sample standard deviation using the samples in the given range, computed as the square root of the sample variance.
      template <typename Iterator, typename T>
      T deviation(Iterator begin, Iterator end, T avg, T init)
| As the previous, except that the argument avg must be the mean value of the given samples, which makes it faster to compute than the version without this argument.
      template <typename Iterator, typename T>
      T variance(Iterator begin, Iterator end, T init)
| Returns init plus the unbiased sample variance, i.e. normalized by N-1 rather than N, where N is the number of samples in the range.
      template <typename Iterator, typename T>
      T variance(Iterator begin, Iterator end, T avg, T init)
| As the previous, except that the argument avg must be the mean value of the given samples, which makes it faster to compute than the version without this argument.
      template <typename Iterator, typename T>
      T generalizedGaussianShape(Iterator begin, Iterator end,
    			     T init)
| Estimates the ``shape''-parameter (alpha) of the Generalized Gaussian Distribution(GGD), based on the given samples, plus init.
      template <typename Iterator, typename T>
      T generalizedGaussianShape(Iterator begin, Iterator end,
    			     T avg, T init)
| As the previous, except that the argument avg must be the mean value of the given samples, which makes it faster to compute than the version without this argument.
### Constants Constants of different types are defined through a template class:
      template <typename T> struct Constants;
      value_type
| Alias for template parameter type T.
      value_type pi()
| Pi, the ratio of a circle's circumference to its diameter, i.e. 3.14.....
      value_type e()
| Base of the natural logarithm.
      std::complex<value_type> i()
| Complex component i is defined as sqrt(-1).
### Compatibility Macros Macro defined for backwards compatibility.
      PI
| Equal to Constants<double>::pi().
### Procedures #### Optimization
    template <class Function, class Derivative>
    typename Function::value_type optimize(const Function &f, const Derivative &d,
    		typename Function::value_type low,
    		typename Function::value_type high,
    		const std::size_t N = 1024);
    template <class Function>
    typename Function::value_type optimize(const Function &f,
    		typename Function::value_type low,
    		typename Function::value_type high,
    		const std::size_t N = 1024);
#### Newton-Raphson The Newton-Raphson procedure is a so-called "root-finding" method, which, given a function f(x), tries to find an x such that f(x) = 0. The procedure is iterative, and computation stops upon convergence, i.e. when it appears that the solution is no longer improving. The implementation can handle multi-dimensional function by using Vectors. As described here, the procedure is not entirely safe, and although the implementation addresses these weaknesses, it may fail. As a rule of the thumb, try to provide a starting point close to the solution and avoid having a local minimum or maximum in the function between the starting point and the solution. There are two definitions of the classic method:
    template <class Function, class Derivative>
    bool doNewtonRaphson(const Function &f, const Derivative &d, Function::value_type &x,
    		     unsigned N = 100000u);
    template <class Function>
    bool doNewtonRaphson(const Function &f, Function::value_type &x, unsigned N = 100000u);
And there are two that involve a fixed range into which x is clamped:
    template <class Function, class Derivative>
    bool doNewtonRaphson(const Function &f, const Derivative &d, Function::value_type &x,
    		     const Function::value_type &low, const Function::value_type &high,
    		     unsigned N = 100000u);
    template <class Function>
    bool doNewtonRaphson(const Function &f, Function::value_type &x,
    		     const Function::value_type &low, const Function::value_type &high,
    		     unsigned N = 100000u);
The first form requires a user-defined function Derivative d, which must be the derivative of Function f. The second form does not require a user-supplied derivative but uses a numerical technique, see Derivative. The first form is recommended as it is expected to be both faster and more accurate. On input, the parameter x is the start-point of the procedure; on output it contains the result if the procedure has succesfully terminated. If the procedure has succesfully converged onto a solution, the return value is true, otherwise it is false and the contents of x are unspecified. The "clamped" versions are a bit safer, and potentially faster, as they make sure x does not leave the given range; and employ a bi-section scheme to speed up convergence if possible. The method works best when the function is smaller than zero on one side of the range and grater than zero on the other side. The template parameter classes Function and Derivative must model a well-behaved mathematical function, meaning that for any given parameter x, the corresponding f(x) is always the same. Both Function and Derivative must offer a typedef for value_type and an operator of the following form:
      value_type operator()(const value_type &x) const
An example:
    template <typename T>
    struct Square
    {
    	typedef T value_type;
    	T operator()(const T &x) const { return x * x; }
    };

    template <typename T>
    struct SquareDerivative
    {
    	typedef T value_type;
    	T operator()(const T &x) const { return T(2)*x; }
    };

    // Automatic Derivative
    float r1 = -10.0f;
    bool ok = doNewtonRaphson(Square<float>(), r1);
    assert(ok);

    // With User-Supplied Derivative
    double r2 = -10.0;
    ok = doNewtonRaphson(Square<double>(), SquareDerivative<double>(), r2);
    assert(ok);

    // Multi-Dimensional through Vectors
    StaticVector<double, 2u> r3 = -10.0;
    ok = doNewtonRaphson(Square<StaticVector<double, 2u> >(), r3);
    assert(ok);
#### Runge-Kutta 4 The Runge-Kutta 4 algorithm is an iterative method for the approximation of solutions of ordinary differential equations of the form:
    y' = f(t, y)
    y(t0) = y0
In this case y' is the derivative of y, and its value in point t is given by f(t, y). The so-called "initial value" is y0, and it is the value of y(t0), where t0 is a specified point. The procedure will produce a vector of N + 1 values, corresponding to solution of the above initial-value problem in N + 1 points in the range [t0, tN]. The method has the following definition:
    template <class Function>
    void doRungeKutta(const Function &f, const Function::value_type t0,
    		  const Function::value_type tN, const unsigned N,
    		  const Function::value_type y0,
    		  std::vector<Function::value_type> &y);
The template parameter class Function must model a well-behaved mathematical function, meaning that for any given parameters t, y, the corresponding f(t, y) is always the same. Function must offer a typedef for value_type and an operator of the following form:
    value_type operator()(const value_type &t, const value_type &y) const
The parameters are defined as follows:
      const Function &f
| A Functor giving the derivative y' = f(t, y).
      const Function::value_type t0
| The position of the initial condition y(t0) = y0.
      const Function::value_type tN
| The final position.
      const unsigned N
| The number of iterations.
      const Function::value_type y0
| The initial condition, i.e. y(t0)=y0.
      std::vector<Function::value_type> &y
| The vector where the values of y will be stored. Upon return, y will contain N + 1 values.
An example:
    template <typename T>
    struct RKSquare
    {
    	typedef T value_type;
    	typedef T result_type;
    	T operator()(const T t, const T y) const { return t*t-y; }
    };

    RKSquare<double> f;
    std::vector<double> result;

    // Compute 10 values in the range [0.0, 1.0], where y(0.0) = 3.0
    doRungeKutta(f, 0.0, 1.0, 10u, 3.0, result);
#### Least Squares Implements the well-known least-squares method. Here, the Matrix A is the design matrix, vector y contains observations, and the estimated parameters will be placed in vector x.
    template <template <typename Tm, std::size_t Dm, typename Aux> class Array_t,
    	  typename Ta, typename A, class XVector_t, class YVector_t>
    bool leastSquaresFit(const Array_t<Ta, 2, A> &A, const YVector_t &y, XVector_t &x)
#### Hungarian Algorithm The hungarian algorithm finds a matching in a bi-partite graph that minimizes overall cost or maximizes overall benefit. That is, given two sets of items A and B, the best possible set of pairs having one item from set A and one item from set B is found. The overall cost or benefit is calculated as the sum of the costs or benefits from the individual pairs. Should your overall cost function actually be a product of the individual costs or benefits, then simply provide the log of your cost function. Note: the costs matrix is destroyed during the calculation!
    template <template <typename Tm, std::size_t D, typename Aux> class Array_t,
    	typename T, typename A>
    void find_matching(Array_t<T, 2, A> &costs,
    		   std::vector<std::pair<std::size_t, std::size_t> > &matches,
    		   const bool minimize_costs = true,
    		   const bool heuristic = true);
      costs
| A 2-dimensional matrix containing at each element costs[a][b] the cost or benefit of a match between elements a and b from their respective sets.
      matches
| On exit, contains a set of pairs of indices <a,b> that each represent a match.
      minimize_costs
| If true (default) the costs will be minimized. If false, the costs (benefits) will be maximized.
      heuristic
| Indicate whether a heuristic should be used.
#### Matrix Operations
      void transpose(Array_t<T, 2u, A> &m)
| Transpose the Matrix.
      bool invert(Array_t<T, 2u, A> &m)
| Invert the matrix. Returns false if inversion fails.