/export/development/ViennaMath/viennamath/compiletime/ct_variable.hpp

Go to the documentation of this file.

#ifndef VIENNAMATH_COMPILETIME_VARIABLE_HPP
#define VIENNAMATH_COMPILETIME_VARIABLE_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/compiletime/ct_vector.hpp"
#include "viennamath/exception.hpp"

#include <assert.h>

namespace viennamath
{
  /********** evaluation at ViennaMath vector types ***************/
  template <typename vmath_vector, long id>
  struct type_by_index {};
  
  template <typename vmath_vector>
  struct type_by_index <vmath_vector, 0>
  {
    typedef typename vmath_vector::type_0   type; 
  };
  
  template <typename vmath_vector>
  struct type_by_index <vmath_vector, 1>
  {
    typedef typename vmath_vector::type_1   type; 
  };
  
  template <typename vmath_vector>
  struct type_by_index <vmath_vector, 2>
  {
    typedef typename vmath_vector::type_2   type; 
  };

  /********** evaluation at STL vector types ***************/
  template <typename VectorType,
            long id>
  struct variable_traits
  {
    typedef default_numeric_type          return_type;
    
    //per default, access id-th element;
    static return_type get(VectorType const & v)
    {
      return v[id];
    }
  };
  
  
  //vector_1:
  template <typename T0,
            long id>
  struct variable_traits <ct_vector_1<T0>, 
                          id>
  {
    typedef typename type_by_index<ct_vector_1<T0>, id>::type   return_type;
    
    //per default, access id-th element;
    static return_type get(ct_vector_1<T0> const & v)
    {
      return v[ct_index<id>()];
    }
  };
  
  //vector_2:
  template <typename T0, typename T1,
            long id>
  struct variable_traits <ct_vector_2<T0, T1>, 
                          id>
  {
    typedef typename type_by_index<ct_vector_2<T0, T1>, id>::type   return_type;
    
    //per default, access id-th element;
    static return_type get(ct_vector_2<T0, T1> const & v)
    {
      return v[ct_index<id>()];
    }
  };

  //vector_3:
  template <typename T0, typename T1, typename T2,
            long id>
  struct variable_traits <ct_vector_3<T0, T1, T2>, 
                          id>
  {
    typedef typename type_by_index<ct_vector_3<T0, T1, T2>, id>::type   return_type;
    
    //per default, access id-th element;
    static return_type get(ct_vector_3<T0, T1, T2> const & v)
    {
      return v[ct_index<id>()];
    }
  };

  

  
  /************* evaluation of a compile time constant *****************/
  template <long value_>
  struct variable_traits <ct_constant<value_>,
                          0>
  {
    typedef viennamath::ct_constant<value_>   return_type;
    
    //per default, access id-th element;
    static return_type get(viennamath::ct_constant<value_> const & v)
    {
      return v;
    }
  };

  //guard: something like (x*y - z)(constant<long, ct_constant<4> >()) is not allowed
  template <long value_, long id>
  struct variable_traits <ct_constant<value_>, 
                          id>
  {
    //try to provide a good compiler error message:
    typedef typename ct_constant<value_>::ERROR_PROVIDED_NOT_ENOUGH_ARGUMENTS_TO_EXPRESSION   error_type;
    
    //providing a non-vector type is bogus -> force linker error!
  };
  
  // further specialize variable_traits::get() here as required.
  
  
  
  template <id_type id /* see forwards.h for default argument */>
  struct ct_variable
  {
    typedef default_numeric_type   numeric_type;
    
    explicit ct_variable() {};

    std::ostream & operator<<(std::ostream & stream) const
    {
      stream << "variable<" << id << ">";
      return stream;
    }

    //template <typename NumericT>
    //NumericT operator()(NumericT value) const { return value; }

    template <typename ScalarType>
    rt_constant<ScalarType> operator()(rt_constant<ScalarType> const & other) const
    {
      if (id > 0)
        throw variable_index_out_of_bounds_exception(id, 0);
      return rt_constant<ScalarType>(static_cast<ScalarType>(other));
    }

    template <long value>
    long operator()(ct_constant<value> const & other) const
    {
      if (id > 0)
        throw variable_index_out_of_bounds_exception(id, 0);
      return value;
    }

    //Vector argument (can be of type std::vector)
    template <typename VectorType>
    typename variable_traits<VectorType, id>::return_type 
    //numeric_type 
    operator()(VectorType const & v) const
    {
      if(id >= v.size())
        throw variable_index_out_of_bounds_exception(id, v.size());
      return variable_traits<VectorType, id>::get(v);
    }
    
  }; //variable


  template <id_type id>
  std::ostream& operator<<(std::ostream & stream, ct_variable<id> const & u)
  {
    stream << "ct_variable<" << id << ">";
    return stream;
  }


}

#endif