symbolic.hpp

Go to the documentation of this file.

/*
  Copyright (C) 2017 Marcus N Campbell Bannerman <[email protected]>

  This file is part of stator.

  stator is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  stator is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with stator. If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once

// stator
#include <stator/config.hpp>
#include <stator/constants.hpp>
#include <stator/orphan/stack_vector.hpp>

// Eigen
#include <Eigen/Dense>

// C++
#include <complex>
#include <ratio>
#include <type_traits>

namespace sym {
  using stator::orphan::StackVector;
  using stator::detail::store;

  namespace detail {
    using stator::detail::choice;
    using stator::detail::last_choice;
    using stator::detail::select_overload;
  } // namespace detail

  struct SymbolicOperator {};
}

#include <stator/symbolic/constants.hpp>
#include <stator/orphan/template_config.hpp>

namespace sym {
  
  struct Dynamic {};

  
  template<class T>
  struct IsSymbolic {
    static constexpr bool value = std::is_base_of<SymbolicOperator, T>::value;
  };

  template<class Var, class Arg> struct Relation {
    Relation(const Var var, const Arg& val): _var(var), _val(val) {}

    const Var _var;
    const Arg& _val;
  };

  namespace detail {
    struct vidx_ID;
  };

  template<char idx>
  struct vidx : stator::orphan::value_conf_t<detail::vidx_ID, char, idx> {};

  template<typename ...Args> struct Var : SymbolicOperator {
    static constexpr const auto idx = stator::orphan::get_value<vidx<'x'>, Args...>::value;
    
    template<class Arg>
    Relation<Var<Args...>, Arg> operator=(const Arg& a) const {
      return Relation<Var<Args...>, Arg>(*this, a);
    }

    char getidx() const { return Var::idx; }
  };

  template<typename Var1, typename Var2>
  struct variable_in {
    static constexpr const bool value = Var1::idx == Var2::idx;
  };

  template<typename Var1, typename Var2>
  struct enable_if_var_in : std::enable_if<variable_in<Var1, Var2>::value> {
  };
  
  template<typename Var1, typename Var2>
  struct enable_if_var_not_in : std::enable_if<!variable_in<Var1, Var2>::value> {
  };

  template<typename Var1, typename Var2>
  struct variable_combine {
    typedef Var<vidx<Var1::idx> > type;
  };
  
  
  namespace detail {
    template<class T>
    struct IsConstant : std::conditional<std::is_arithmetic<T>::value || is_C<T>::value || std::is_base_of<Eigen::EigenBase<T>, T>::value, std::true_type, std::false_type>::type {};

    template<class T>
    struct IsConstant<std::complex<T> > : IsConstant<T> {};
    
  }// namespace detail

  template<class T>
  constexpr typename std::enable_if<detail::IsConstant<T>::value, bool>::type is_constant(const T&) { return true;}

  template<class T>
  constexpr typename std::enable_if<!detail::IsConstant<T>::value, bool>::type is_constant(const T&) { return false;}
  
  template<class T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type>
  T empty_sum(const T&) { return T(); }

  template<class T, typename = typename std::enable_if<std::is_base_of<Eigen::EigenBase<T>, T>::value>::type>
  auto empty_sum(const T&) -> STATOR_AUTORETURN_BYVALUE(T::Zero());

  template<class T>
  T empty_sum(const std::complex<T>&) { return T(); }
  
  template<class T, class Var, class Arg,
       typename = typename std::enable_if<detail::IsConstant<T>::value>::type >
  auto sub(const T& f, const Relation<Var, Arg>&) -> STATOR_AUTORETURN_BYVALUE(f);
  
  template<typename ...Args1, typename ...Args2, class Arg,
         typename = typename enable_if_var_in<Var<Args1...>, Var<Args2...> >::type>
  auto sub(const Var<Args1...>& f, const Relation<Var<Args2...>, Arg>& x)
   -> STATOR_AUTORETURN_BYVALUE(x._val);

  template<class ...Args1, class Arg, class Var2,
         typename = typename enable_if_var_not_in<Var<Args1...>, Var2>::type>
  Var<Args1...> sub(const Var<Args1...>& f, const Relation<Var2, Arg>& x)
  { return f; }
  
  
  template<class T, class ...Args,
         typename = typename std::enable_if<detail::IsConstant<T>::value>::type>
  Null derivative(const T&, Var<Args...>) { return Null(); }

  template<class ...Args1, class ...Args2,
       typename = typename std::enable_if<!std::is_base_of<Dynamic, Var<Args1...> >::value && !std::is_base_of<Dynamic, Var<Args2...> >::value>::type>
  auto derivative(Var<Args1...>, Var<Args2...>) -> typename std::enable_if<Var<Args1...>::idx == Var<Args2...>::idx, Unity>::type
  { return Unity(); } 

  inline StackVector<double, 0> solve_real_roots(Null f) {
    return StackVector<double, 0>();
  }

  template<class ...Args1, class ...Args2,
       typename = typename std::enable_if<!std::is_base_of<Dynamic, Var<Args1...> >::value && !std::is_base_of<Dynamic, Var<Args2...> >::value>::type>
    auto derivative(Var<Args1...>, Var<Args2...>) -> typename std::enable_if<Var<Args1...>::idx != Var<Args2...>::idx, Null>::type
  { return Null(); }

  template<class F, class Real,
         typename = typename std::enable_if<detail::IsConstant<F>::value>::type>
  inline F shift_function(const F& f, const Real t) {
    return f;
  }
  
  template<class F, class Real,
         typename = typename std::enable_if<detail::IsConstant<F>::value>::type>
  inline double precision(const F& f, const Real) {
    return 0.0;
  }

  template<size_t Order, class Real = double, class PolyVar = Var<>> class Polynomial;
}


#include <stator/symbolic/binary_ops.hpp>
#include <stator/symbolic/unary_ops.hpp>
#include <stator/symbolic/simplify.hpp>
#include <stator/symbolic/polynomial.hpp>
#include <stator/symbolic/integrate.hpp>
#include <stator/symbolic/taylor.hpp>
#include <stator/symbolic/runtime.hpp>
#include <stator/symbolic/parser.hpp>
#include <stator/symbolic/print.hpp>