LinearMapper1d.hh

Go to the documentation of this file.

#ifndef NPSTAT_LINEARMAPPER1D_HH_
#define NPSTAT_LINEARMAPPER1D_HH_
 
/*!
// \file LinearMapper1d.hh
//
// \brief Linear transformation functor
//
// Author: I. Volobouev
//
// October 2009
*/
 
#include <stdexcept>
 
namespace npstat {
    /** Functor which performs linear mapping in 1-d */
    template<class Numeric>
    class LinearMapper1dTmpl
    {
    public:
        /** Default constructor builds an identity transformation */
        inline LinearMapper1dTmpl() : a_(1.0), b_(0.0) {}
 
        /**
        // Transform definition from two points. The point at x0
        // is mapped into y0, the point at x1 is mapped into y1.
        // The linear transformation is thus fully defined.
        */
        inline LinearMapper1dTmpl(const Numeric x0, const Numeric y0,
                                  const Numeric x1, const Numeric y1)
        {
            const Numeric dx = x1 - x0;
            if (!dx) throw std::invalid_argument(
                "In npstat::LinearMapper1dTmpl constructor: "
                "invalid arguments (x0 == x1)");
            a_ = (y1 - y0)/dx;
            b_ = ((y0 + y1) - a_*(x0 + x1))/2.0;
        }
 
        /** Explicitly provide the transform coefficients as in y = ca*x + cb */
        inline LinearMapper1dTmpl(const Numeric ca, const Numeric cb)
            : a_(ca), b_(cb) {}
 
        /** Perform the transformation */
        inline Numeric operator()(const Numeric& x) const {return a_*x + b_;}
 
        /** Get the linear coefficient of the transform */
        inline Numeric a() const {return a_;}
 
        /** Get the transform constant */
        inline Numeric b() const {return b_;}
 
        /** Create the inverse transform */
        inline LinearMapper1dTmpl inverse() const
        {
            if (!a_) throw std::invalid_argument(
                "In npstat::LinearMapper1dTmpl::inverse: "
                "mapping is not invertible");
            return LinearMapper1dTmpl(1.0/a_, -b_/a_);
        }
 
        /** Sequence of two transforms: the one on the right is applied first */
        inline LinearMapper1dTmpl operator*(const LinearMapper1dTmpl& r) const
        {
            return LinearMapper1dTmpl(a_*r.a_, a_*r.b_ + b_);
        }
 
    private:
        Numeric a_;
        Numeric b_;
    };
 
    /** Typedefs for typical template parameters */
    typedef LinearMapper1dTmpl<double> LinearMapper1d;
    typedef LinearMapper1dTmpl<long double> LDLinearMapper1d;
    typedef LinearMapper1dTmpl<float> FLinearMapper1d;
}
 
#endif // NPSTAT_LINEARMAPPER1D_HH_