ScalarAlgebra.h

Go to the documentation of this file.

#ifndef SCALARALGEBRA_H_
#define SCALARALGEBRA_H_
 
#include <assert.h>
#include <cmath>
 
#include <boost/none.hpp>
#include <boost/any.hpp>
 
namespace muq {
  namespace Modeling {
    class ScalarAlgebra {
    public:
 
      ScalarAlgebra();
 
      virtual ~ScalarAlgebra();
 
 
      static bool IsScalar(std::type_info const& obj_type);
 
 
      static bool IsZero(boost::any const& obj);
 
 
      static boost::any Zero(std::type_info const& type);
 
 
      static double Norm(boost::any const& obj);
 
 
      static double InnerProduct(boost::any const& vec1, boost::any const& vec2);
 
 
      static boost::any OuterProduct(boost::any const& vec1, boost::any const& vec2);
 
 
      static boost::any Identity(std::type_info const& type);
 
 
      static boost::any Add(boost::any const& in0, boost::any const& in1);
 
 
      static boost::any Subtract(boost::any const& in0, boost::any const& in1);
 
 
      static boost::any Multiply(boost::any const& in0, boost::any const& in1);
 
 
      static boost::any Inverse(boost::any const& obj);
 
 
      static boost::any SquareRoot(boost::any const& obj);
 
 
      static double LogDeterminate(boost::any const& obj);
 
    private:
 
 
      template<typename type>
    static inline double Magnitude(boost::any const& obj) {
    const double x = (double)boost::any_cast<type const>(obj);
 
    return std::abs(x);
      }
 
 
      template<typename type0, typename type1> 
    static inline boost::any Add(boost::any const& in0, boost::any const& in1) {
    const type0 x0 = boost::any_cast<type0 const>(in0);
    const type1 x1 = boost::any_cast<type1 const>(in1);
 
    return x0 + x1;
      }
 
 
      template<typename type0> 
    static inline boost::any Add(boost::any const& in0, boost::any const& in1) {
    if( in1.type()==typeid(double) ) { return Add<type0, double>(in0, in1); }
    if( in1.type()==typeid(float) ) { return Add<type0, float>(in0, in1); }
    if( in1.type()==typeid(int) ) { return Add<type0, int>(in0, in1); }
    if( in1.type()==typeid(unsigned int) ) { return Add<type0, unsigned int>(in0, in1); }
 
    // something went wrong
    assert(false);
    return boost::none;
      }
 
 
      template<typename type0, typename type1> 
    static inline boost::any Subtract(boost::any const& in0, boost::any const& in1) {
    const type0 x0 = boost::any_cast<type0 const>(in0);
    const type1 x1 = boost::any_cast<type1 const>(in1);
 
    return x0 - x1;
      }
 
 
      template<typename type0> 
    static inline boost::any Subtract(boost::any const& in0, boost::any const& in1) {
    if( in1.type()==typeid(double) ) { return Subtract<type0, double>(in0, in1); }
    if( in1.type()==typeid(float) ) { return Subtract<type0, float>(in0, in1); }
    if( in1.type()==typeid(int) ) { return Subtract<type0, int>(in0, in1); }
    if( in1.type()==typeid(unsigned int) ) { return Subtract<type0, unsigned int>(in0, in1); }
 
    // something went wrong
    assert(false);
    return boost::none;
      }
 
 
      template<typename type0, typename type1> 
    static inline boost::any Multiply(boost::any const& in0, boost::any const& in1) {
    const type0 x0 = boost::any_cast<type0 const>(in0);
    const type1 x1 = boost::any_cast<type1 const>(in1);
 
    return x0 * x1;
      }
 
 
      template<typename type0> 
    static inline boost::any Multiply(boost::any const& in0, boost::any const& in1) {
    if( in1.type()==typeid(double) ) { return Multiply<type0, double>(in0, in1); }
    if( in1.type()==typeid(float) ) { return Multiply<type0, float>(in0, in1); }
    if( in1.type()==typeid(int) ) { return Multiply<type0, int>(in0, in1); }
    if( in1.type()==typeid(unsigned int) ) { return Multiply<type0, unsigned int>(in0, in1); }
 
    // something went wrong
    assert(false);
    return boost::none;
      }
    };
  } // namespace Modeling
} // namespace muq
 
#endif