/export/development/ViennaMath/viennamath/compiletime/operations/ct_expr.hpp

Go to the documentation of this file.

#ifndef VIENNAMATH_COMPILETIME_OPERATIONS_CT_EXPR_HPP
#define VIENNAMATH_COMPILETIME_OPERATIONS_CT_EXPR_HPP

/* =======================================================================
   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 "viennamath/forwards.h"
//#include "viennamath/runtime/constant.hpp"
//#include "viennamath/runtime/variable.hpp"
#include "viennamath/compiletime/ct_binary_expr.hpp"
//#include "viennamath/runtime/binary_operators.hpp"

namespace viennamath
{
  
      template <typename ScalarType, long value_1, typename RHS, long value_2>
      ct_binary_expr<ct_constant< value_1 + value_2 >,
                     op_plus<ScalarType>,
                     RHS >
      operator+(ct_binary_expr<ct_constant<value_1>, op_plus<ScalarType>, RHS> const & lhs,
                ct_constant<value_2> const & other)
      {
        return ct_binary_expr<ct_constant< value_1 + value_2 >,
                              op_plus<ScalarType>,
                              RHS >(ct_constant< value_1 + value_2 >(),
                                    lhs.rhs());
      }


      template <typename ScalarType, long value_1, typename RHS, long value_2>
      ct_binary_expr<ct_constant< value_1 + value_2 >,
              op_minus<ScalarType>,
              RHS >
      operator+(ct_binary_expr<ct_constant<value_1>, op_minus<ScalarType>, RHS> const & lhs,
                ct_constant<value_2> const & other)
      {
        return ct_binary_expr<ct_constant< value_1 + value_2 >,
                              op_minus<ScalarType>,
                              RHS >(ct_constant< value_1 + value_2 >(),
                                    lhs.rhs());
      }

      template <typename ScalarType, typename OtherScalarType, typename RHS, long value>
      ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<ScalarType>, long>::result_type >,
                      op_minus<ScalarType>,
                      RHS >
      operator+(ct_binary_expr<rt_constant<OtherScalarType>, op_minus<ScalarType>, RHS> const & lhs,
                ct_constant<value> const & other)
      {
        typedef rt_constant< typename promote_traits<OtherScalarType, op_plus<ScalarType>, long>::result_type >    result_constant;
        return ct_binary_expr<result_constant,
                              op_minus<ScalarType>,
                              RHS >(result_constant(static_cast<OtherScalarType>(lhs.lhs()) + value),
                                    lhs.rhs());
      }
  


      template <typename ScalarType, id_type id, typename RHS>
      RHS
      operator-(ct_binary_expr<ct_variable<id>, op_plus<ScalarType>, RHS> const & lhs,
                ct_variable<id> const & other)
      {
        return lhs.rhs();
      }
      

      template <long value_1, typename RHS, long value_2, typename T>
      ct_binary_expr< ct_constant< value_1 - value_2 >,
                      op_plus<T>,
                      RHS >
      operator-(ct_binary_expr<ct_constant<value_1>, op_plus<T>, RHS> const & lhs,
                ct_constant<value_2> const & other)
      {
        return ct_binary_expr<ct_constant< value_1 - value_2 >,
                              op_plus<T>,
                              RHS >(ct_constant< value_1 - value_2 >(),
                                    lhs.rhs());
      }

      template <typename OtherScalarType, typename RHS, long value, typename T>
      ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >,
                      op_plus<T>,
                      RHS >
      operator-(ct_binary_expr<rt_constant<OtherScalarType>, op_plus<T>, RHS> const & lhs,
                ct_constant<value> const & other)
      {
        typedef rt_constant< typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >    result_constant;
        return ct_binary_expr<result_constant,
                              op_plus<T>,
                              RHS >(result_constant(static_cast<OtherScalarType>(lhs.lhs()) - value),
                                    lhs.rhs());
      }

      template <long value_1, typename RHS, long value_2, typename T>
      ct_binary_expr< ct_constant< value_1 - value_2 >,
               op_minus<T>,
               RHS >
      operator-(ct_binary_expr<ct_constant<value_1>, op_minus<T>, RHS> const & lhs,
                ct_constant<value_2> const & other)
      {
        return ct_binary_expr<ct_constant< value_1 - value_2 >,
                              op_minus<T>,
                              RHS >(ct_constant< value_1 - value_2 >(),
                                    lhs.rhs());
      }

      template <typename OtherScalarType, typename RHS, long value, typename T>
      ct_binary_expr< rt_constant<typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >,
                      op_minus<T>,
                      RHS >
      operator-(ct_binary_expr<rt_constant<OtherScalarType>, op_minus<T>, RHS> const & lhs,
                ct_constant<value> const & other)
      {
        typedef rt_constant< typename promote_traits<OtherScalarType, op_plus<T>, long>::result_type >    result_constant;
        return ct_binary_expr<result_constant,
                              op_minus<T>,
                               RHS >(result_constant(static_cast<OtherScalarType>(lhs.lhs()) - value),
                                     lhs.rhs());
      }
  






      template <typename LHS, typename OP, typename RHS>
      ct_constant<1>
      operator/(ct_binary_expr<LHS, OP, RHS> const & lhs,
                ct_binary_expr<LHS, OP, RHS> const & other)
      {
        return ct_constant<1>();
      }
  
}

#endif