/export/development/ViennaMath/viennamath/forwards.h

Go to the documentation of this file.

#ifndef VIENNAMATH_FORWARDS_H
#define VIENNAMATH_FORWARDS_H

/* =======================================================================
   Copyright (c) 2012, Institute for Microelectronics,
                       Institute for Analysis and Scientific Computing,
                       TU Wien.
                             -----------------
               ViennaMath - Symbolic and Numerical Math in C++
                             -----------------

   Author:     Karl Rupp                          rupp@iue.tuwien.ac.at

   License:    MIT (X11), see file LICENSE in the ViennaMath base directory
======================================================================= */

#include <string>
#include <vector>
#include <exception>
#include <sstream>
#include <memory>

namespace viennamath
{
  //basic numeric type (customize to your needs)
  typedef double              default_numeric_type;
  
  typedef unsigned long       id_type;
  

  template <bool b, class T = void> 
  struct enable_if
  {
    typedef T   type;
  };

  template <class T> 
  struct enable_if<false, T> {};

  template <id_type dim>
  struct cartesian {};
  

  template <typename NumericT>
  class numeric_type_proxy
  {
    public:
      numeric_type_proxy(NumericT value) : value_(value) {}
      
      NumericT get() const { return value_; }
    private:
      NumericT value_;
  };

  //  
  //
  
  template <typename LHS,
            typename OP,
            typename RHS>
  class ct_binary_expr;

  template <typename LHS,
            typename OP>
  class ct_unary_expr;
  
  template <long value_>
  class ct_constant;

  template <id_type id = 0>
  struct ct_variable;

  template <typename Tag>
  class ct_function_symbol;

  template <typename LHS, typename RHS>
  class ct_equation;
  

  
  template <long i>
  struct ct_index {};
  
  template <typename T0>
  class ct_vector_1;
  
  template <typename T0, typename T1>
  class ct_vector_2;
  
  template <typename T0, typename T1, typename T2>
  class ct_vector_3;
 
  //
  //

  template <typename NumericT>
  class rt_expression_interface;
  
  typedef rt_expression_interface<default_numeric_type>     default_interface_type;
  
  template <typename InterfaceType = default_interface_type>
  class rt_variable;
  typedef rt_variable<>                variable;

  template <typename ScalarType = default_numeric_type, typename InterfaceType = default_interface_type>
  class rt_constant;
  typedef rt_constant<>                constant;

  template <typename InterfaceType = default_interface_type>
  class rt_binary_expr;  
  typedef rt_binary_expr<>             binary_expr;
  
  template <typename InterfaceType = default_interface_type>
  class rt_unary_expr;
  typedef rt_unary_expr<>              unary_expr;
  
  template <typename InterfaceType = default_interface_type>
  class rt_expr;
  typedef rt_expr<>                    expr;
  
  template <typename InterfaceType = default_interface_type>
  class rt_vector_expr; 
  typedef rt_vector_expr<>             vector_expr;
  
  template <typename InterfaceType = default_interface_type>
  class rt_function_symbol;
  typedef rt_function_symbol<>         function_symbol;

  template <typename InterfaceType = default_interface_type>
  class rt_equation;
  typedef rt_equation<>                equation;

  template <typename InterfaceType = default_interface_type>
  class rt_interval;
  typedef rt_interval<>                interval;

  template <typename InterfaceType = default_interface_type>
  class rt_symbolic_interval;
  typedef rt_symbolic_interval<>       symbolic_interval;
  
  
  template <typename InterfaceType = default_interface_type>   //Note: No convenience typedef needed here
  class rt_manipulation_interface;

  template <typename InterfaceType = default_interface_type>   //Note: No convenience typedef needed here
  class rt_manipulation_wrapper;
  
  
  template <typename InterfaceType = default_interface_type>   //Note: No convenience typedef needed here
  class rt_traversal_interface;
  
  template <typename InterfaceType = default_interface_type>   //Note: No convenience typedef needed here
  class rt_traversal_wrapper;
  
  //
  //
  
  template <typename InterfaceType = default_interface_type>
  class rt_op_interface;

  //binary operator tags:  
  template <typename BinaryOperation, typename InterfaceType = default_interface_type>
  class op_binary;
  
  template <typename NumericT>
  struct op_plus;
  
  template <typename NumericT>
  struct op_minus;
  
  template <typename NumericT>
  struct op_mult;
  
  template <typename NumericT>
  struct op_div;
  
  template <typename NumericT>
  struct op_pow;

  
  
  //
  //
  
  template <typename UnaryOperation, typename InterfaceType = default_interface_type>
  class op_unary;
  

  template <typename NumericT>
  struct op_id;
  
  template <typename NumericT>
  struct op_exp;
  
  template <typename NumericT>
  struct op_sin;
  
  template <typename NumericT>
  struct op_cos;
  
  template <typename NumericT>
  struct op_tan;
  
  template <typename NumericT>
  struct op_fabs;
  
  template <typename NumericT>
  struct op_sqrt;
  
  template <typename NumericT>
  struct op_log; //natural logarithm
  
  template <typename NumericT>
  struct op_log10;

  template <typename NumericT>
  class op_partial_deriv;
  
  template <typename InterfaceType>
  class op_rt_integral;

  
  template <typename InterfaceType>
  class op_rt_symbolic_integral;
  


  namespace result_of
  {
    template <typename T>
    struct is_viennamath
    {
      enum { value = false };
    };
    
    template <long val>
    struct is_viennamath<ct_constant<val> >
    {
      enum { value = true };
    };
    
    template <id_type id>
    struct is_viennamath<ct_variable<id> >
    {
      enum { value = true };
    };

    template <typename TAG>
    struct is_viennamath<ct_function_symbol<TAG> >
    {
      enum { value = true };
    };
    
    template <typename LHS, typename OP, typename RHS>
    struct is_viennamath<ct_binary_expr<LHS, OP, RHS> >
    {
      enum { value = true };
    };

    template <typename LHS, typename OP>
    struct is_viennamath<ct_unary_expr<LHS, OP> >
    {
      enum { value = true };
    };
    
    
    
    template <typename NumericType, typename InterfaceType>
    struct is_viennamath<rt_constant<NumericType, InterfaceType> >
    {
      enum { value = true };
    };
    
    template <typename InterfaceType>
    struct is_viennamath<rt_variable<InterfaceType> >
    {
      enum { value = true };
    };

    template <typename InterfaceType>
    struct is_viennamath<rt_function_symbol<InterfaceType> >
    {
      enum { value = true };
    };
    
    template <typename InterfaceType>
    struct is_viennamath<rt_unary_expr<InterfaceType> >
    {
      enum { value = true };
    };
    
    template <typename InterfaceType>
    struct is_viennamath<rt_binary_expr<InterfaceType> >
    {
      enum { value = true };
    };
    
    template <typename InterfaceType>
    struct is_viennamath<rt_expr<InterfaceType> >
    {
      enum { value = true };
    };
    
    
    template <typename T>
    struct is_compiletime
    {
      enum { value = false };
    };
    
    template <long val>
    struct is_compiletime<ct_constant<val> >
    {
      enum { value = true };
    };
    
    template <id_type id>
    struct is_compiletime<ct_variable<id> >
    {
      enum { value = true };
    };

    template <typename TAG>
    struct is_compiletime<ct_function_symbol<TAG> >
    {
      enum { value = true };
    };
    
    template <typename LHS, typename OP, typename RHS>
    struct is_compiletime<ct_binary_expr<LHS, OP, RHS> >
    {
      enum { value = true };
    };

    template <typename LHS, typename OP>
    struct is_compiletime<ct_unary_expr<LHS, OP> >
    {
      enum { value = true };
    };

    
    template <typename LHS, typename RHS>
    struct interface
    {
      typedef default_interface_type  type; //for compatibility with enable_if
    };

    template <typename T, typename U, typename RHS>
    struct interface< rt_constant<T, U>, RHS >
    {
      typedef U    type;
    };

    template <typename T, typename RHS>
    struct interface< rt_variable<T>, RHS >
    {
      typedef T    type;
    };

    template <typename T>
    struct interface< default_numeric_type, rt_variable<T> >
    {
      typedef T    type;
    };

    template <typename T, typename RHS>
    struct interface< rt_binary_expr<T>, RHS >
    {
      typedef T    type;
    };

    template <typename T>
    struct interface< default_numeric_type, rt_binary_expr<T> >
    {
      typedef T    type;
    };

    template <typename T, typename RHS>
    struct interface< rt_unary_expr<T>, RHS >
    {
      typedef T    type;
    };
    
    template <typename T, typename RHS>
    struct interface< rt_expr<T>, RHS >
    {
      typedef T    type;
    };

    template <typename T>
    struct interface< double,  rt_expr<T> >
    {
      typedef T    type;
    };
    
    template <typename LHS,
              typename RHS,
              bool lhs_is_ct = is_compiletime<LHS>::value,
              bool rhs_is_ct = is_compiletime<RHS>::value>
    struct add;
    
    template <typename LHS,
              typename RHS,
              bool lhs_is_ct = is_compiletime<LHS>::value,
              bool rhs_is_ct = is_compiletime<RHS>::value>
    struct subtract;
    
    template <typename LHS,
              typename RHS,
              bool lhs_is_ct = is_compiletime<LHS>::value,
              bool rhs_is_ct = is_compiletime<RHS>::value>
    struct mult;

    template <typename LHS,
              typename RHS,
              bool lhs_is_ct = is_compiletime<LHS>::value,
              bool rhs_is_ct = is_compiletime<RHS>::value>
    struct div;
    
    
    
    template <long a, long b>
    struct gcd
    {
      enum { value = gcd<b, a % b>::value };
    };
    
    template <long a>
    struct gcd <a, 0>
    {
      enum { value = a};
    };

    template <>
    struct gcd <0, 0>
    {
      enum { error = 1};
    };
    
    
  } //namespace result_of
  
  
    
  template <typename T>
  struct expression_traits
  {
    typedef T   const_reference_type; 
  };
  
  //for compile time constants, we have to copy in order to circumvent problems with temporaries
  template <long value>
  struct expression_traits < ct_constant<value> >
  {
     typedef ct_constant<value>    const_reference_type;
  };

  template <typename T, typename InterfaceType>
  struct expression_traits < rt_constant<T, InterfaceType> >
  {
     typedef rt_constant<T, InterfaceType>    const_reference_type;
  };
  

  
  
  template <typename LHS, typename RHS>
  typename enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value,
                      typename result_of::add<LHS, RHS>::type >::type
  operator+(LHS const & lhs, RHS const & rhs)
  {
    return result_of::add<LHS, RHS>::instance(lhs, rhs); 
  }
  
  template <typename LHS, typename RHS>
  typename enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value,
                      typename result_of::subtract<LHS, RHS>::type >::type
  operator-(LHS const & lhs, RHS const & rhs)
  {
    return result_of::subtract<LHS, RHS>::instance(lhs, rhs); 
  }

  template <typename LHS, typename RHS>
  typename enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value,
                      typename result_of::mult<LHS, RHS>::type >::type
  operator*(LHS const & lhs, RHS const & rhs)
  {
    return result_of::mult<LHS, RHS>::instance(lhs, rhs); 
  }
  
  template <typename LHS, typename RHS>
  typename enable_if< result_of::is_viennamath<LHS>::value || result_of::is_viennamath<RHS>::value,
                      typename result_of::div<LHS, RHS>::type >::type
  operator/(LHS const & lhs, RHS const & rhs)
  {
    return result_of::div<LHS, RHS>::instance(lhs, rhs); 
  }
  
}

#endif