JMath.hh

Go to the documentation of this file.

#ifndef __JMATH__
#define __JMATH__

#include "JLang/JNullType.hh"
#include "JMath/JCalculator.hh"


/**
 * \file
 * 
 * Base class for data structures with artithmetic capabilities.
 * \author mdejong
 */
namespace JMATH {}
namespace JPP { using namespace JMATH; }

namespace JMATH {

  using JLANG::JNullType;


  /**
   * Auxiliary base class for aritmetic operations of derived class types.
   */
  template<class JFirst_t, class JSecond_t = JNullType>
  struct JMath;

    
  /**
   * Template class for data structures with arithmetic capabilities.
   *
   * This class provides for the operators <tt> - += -= *= /= + - * / </tt>.
   * The template parameter should have the corresponding member methods:
   * <pre>
   *       T& negate();
   *       T& add(const T& object);
   *       T& sub(const T& object);
   *       T& mul(const double factor);
   *       T& div(const double factor);
   * </pre>
   *
   * This class also provides for the object multiplication operators <tt>*= *</tt>.
   * The template parameter should then also have the member method:
   * <pre>
   *       T& mul(const T&, const T&);
   * </pre>
   *
   * This class uses in-class friend operators (see Barton-Nackman trick).
   * This class adds interpolation functionality.
   */
  template<class T>
  struct JMath<T, JNullType> {
    /**
     * Affirm operator.
     *
     * \param  object         this object
     * \return                affirmed object
     */
    friend T operator+(const T& object) 
    { 
      return T(object);
    }

    
    /**
     * Negate operator.
     *
     * \param  object         this object
     * \return                negated object
     */
    friend T operator-(const T& object) 
    { 
      return T(object).negate();
    }

    
    /**
     * Add object.
     *
     * \param  object         this object
     * \param  value          value
     * \return                this object
     */
    friend T& operator+=(T& object, const T& value)
    { 
      return object.add(value);
    }

    
    /**
     * Subtract object.
     *
     * \param  object         this object
     * \param  value          value
     * \return                this object
     */
    friend T& operator-=(T& object, const T& value)
    { 
      return object.sub(value);
    }


    /**
     * Scale object.
     *
     * \param  object         this object
     * \param  factor         factor
     * \return                this object
     */
    friend T& operator*=(T& object, const double factor)
    { 
      return object.mul(factor);
    }


    /**
     * Scale object.
     *
     * \param  object         this object
     * \param  factor         factor
     * \return                this object
     */
    friend T& operator/=(T& object, const double factor)
    { 
      return object.div(factor);
    }

    
    /**
     * Add objects.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                result object
     */
    friend T operator+(const T& first, const T& second)
    { 
      return T(first).add(second);
    }

    
    /**
     * Subtract objects.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                result object
     */
    friend T operator-(const T& first, const T& second)
    { 
      return T(first).sub(second);
    }


    /**
     * Scale object.
     *
     * \param  object         object
     * \param  factor         factor
     * \return                object
     */
    friend T operator*(const T& object, const double factor)
    { 
      return T(object).mul(factor);
    }


    /**
     * Scale object.
     *
     * \param  factor         factor
     * \param  object         object
     * \return                object
     */
    friend T operator*(const double factor, const T& object)
    { 
      return T(object).mul(factor);
    }


    /**
     * Scale object.
     *
     * \param  object         object
     * \param  factor         factor
     * \return                object
     */
    friend T operator/(const T& object, const double factor)
    { 
      return T(object).div(factor);
    }


    /**
     * Multiply with object.
     *
     * \param  object         object
     * \return                result object
     */
    T& mul(const T& object)
    {
      return static_cast<T&>(*this) = JCalculator<T>::calculator.mul(static_cast<const T&>(*this), object);
    }


    /**
     * Multiply with object.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                result object
     */
    friend T& operator*=(T& first, const T& second)
    {
      return first.mul(second);
    }

    
    /**
     * Multiply objects.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                calculator
     */
    friend const JCalculator<T, 1>& operator*(const T& first, const T& second)
    { 
      JCalculator<T, 1>::calculator.mul(first, second);

      return JCalculator<T, 1>::calculator;
    }


    /**
     * Interpolation between objects.
     * The result is equal to <tt>*this = (1 - alpha) x (*this) + (alpha) x (object)</tt>.
     *
     * \param  object         object
     * \param  alpha          interpolation factor (normally between 0 and 1)
     * \return                this object
     */
    T& interpolate(const T& object, const double alpha)
    {
      static_cast<T*>(this)->mul(1.0 - alpha);
      static_cast<T*>(this)->add(T(object).mul(alpha));

      return static_cast<T&>(*this);
    }
  };

  
  /**
   * Specialisation of JMath for two data types.
   *
   * This class provides for the object multiplication operators <tt>*= *</tt>.
   * The template parameter should then have the member method:
   * <pre>
   *       JFirst_t& mul(const JFirst_t&, const JSecond_t&);
   * </pre>
   * where <tt>JFirst_t</tt> and <tt>JSecond_t</tt> refer to the first and second template parameter, respectively.
   *
   * This class uses in-class friend operators (see Barton-Nackman trick).
   */
  template<class JFirst_t, class JSecond_t>
  struct JMath
  {
    /**
     * Multiply with object.
     *
     * \param  object         object
     * \return                result object
     */
    JFirst_t& mul(const JSecond_t& object)
    {
      return static_cast<JFirst_t&>(*this) = JCalculator<JFirst_t>::calculator.mul(static_cast<const JFirst_t&>(*this), object);
    }


    /**
     * Multiply with object.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                result object
     */
    friend JFirst_t& operator*=(JFirst_t& first, const JSecond_t& second)
    {
      return first.mul(second);
    }

    
    /**
     * Multiply objects.
     *
     * \param  first          first  object
     * \param  second         second object
     * \return                result object
     */
    friend JFirst_t operator*(const JFirst_t& first, const JSecond_t& second)
    { 
      return JFirst_t(first).mul(second);
    }
  };
}

#endif