threshold.hpp

Go to the documentation of this file.

#pragma once
#include <memory>

#include "parameters.hpp"

//-
namespace QQbar_threshold{
  namespace detail{
    template<typename E>
    struct expression{
      double value(double thr) const{
    return static_cast<E const *>(this)->value(thr);
      }

      operator E&(){
    return static_cast<E&>(*this);
      }

      operator E const &() const{
    return static_cast<E const &>(*this);
      }
    };

    template<typename E1, typename E2>
    class difference: public expression<difference<E1,E2>>{
      std::shared_ptr<E1> x;
      std::shared_ptr<E2> y;
    public:
      difference(expression<E1> const & e1, expression<E2> const & e2)
    : x(std::make_shared<E1>(e1)), y(std::make_shared<E2>(e2)) {}

      double value(double thr) const{
    return x->value(thr) - y->value(thr);
      }
    };

    template<typename E1, typename E2>
    class sum: public expression<sum<E1,E2>>{
      std::shared_ptr<E1> x;
      std::shared_ptr<E2> y;
    public:
      sum(expression<E1> const & e1, expression<E2> const & e2)
    : x(std::make_shared<E1>(e1)), y(std::make_shared<E2>(e2)) {}

      double value(double thr) const{
    return x->value(thr) + y->value(thr);
      }
    };

    template<typename E1, typename E2>
    class product: public expression<product<E1,E2>>{
      std::shared_ptr<E1> x;
      std::shared_ptr<E2> y;
    public:
      product(expression<E1> const & e1, expression<E2> const & e2)
    : x(std::make_shared<E1>(e1)), y(std::make_shared<E2>(e2)) {}

      double value(double thr) const{
    return x->value(thr) * y->value(thr);
      }
    };

    template<typename E1, typename E2>
    class ratio: public expression<ratio<E1,E2>>{
      std::shared_ptr<E1> x;
      std::shared_ptr<E2> y;
    public:
      ratio(expression<E1> const & e1, expression<E2> const & e2)
    : x(std::make_shared<E1>(e1)), y(std::make_shared<E2>(e2)) {}

      double value(double thr) const{
    return x->value(thr) / y->value(thr);
      }
    };

    template<typename E>
    class neg: public expression<neg<E>>{
      std::shared_ptr<E> x;
    public:
      explicit neg(expression<E> const & e): x(std::make_shared<E>(e)) {}

      double value(double thr) const{
    return -x->value(thr);
      }
    };

    class double_expr: public expression<double_expr>{
      double const x;
    public:
      explicit double_expr(double d): x(d) {}

      double value(double) const{
    return x;
      }
    };

    //arithmetic operations ...
    template<typename E1, typename E2>
    sum<E1, E2> operator+(expression<E1> const & e1, expression<E2> const & e2){
      return sum<E1, E2>{e1, e2};
    }

    template<typename E1, typename E2>
    difference<E1, E2> operator-(expression<E1> const & e1, expression<E2> const & e2){
      return difference<E1, E2>{e1, e2};
    }

    template<typename E1, typename E2>
    product<E1, E2> operator*(expression<E1> const & e1, expression<E2> const & e2){
      return product<E1, E2>{e1, e2};
    }

    template<typename E1, typename E2>
    ratio<E1, E2> operator/(expression<E1> const & e1, expression<E2> const & e2){
      return ratio<E1, E2>{e1, e2};
    }

    template<typename E>
    neg<E> operator-(expression<E> const & e){
      return neg<E>(e);
    }

    template<typename E1>
    difference<E1, double_expr> operator-(expression<E1> const & e1, double x){
      return e1 - double_expr{x};
    }

    template<typename E1>
    sum<E1, double_expr> operator+(expression<E1> const & e1, double x){
      return e1 + double_expr{x};
    }

    template<typename E1>
    product<E1, double_expr> operator*(expression<E1> const & e1, double x){
      return e1 * double_expr{x};
    }

    template<typename E1>
    ratio<E1, double_expr> operator/(expression<E1> const & e1, double x){
      return e1 / double_expr{x};
    }

    template<typename E2>
    sum<double_expr, E2> operator+(double x, expression<E2> const & e2){
      return double_expr{x} + e2;
    }

    template<typename E2>
    difference<double_expr, E2> operator-(double x, expression<E2> const & e2){
      return double_expr{x} - e2;
    }

    template<typename E2>
    product<double_expr, E2> operator*(double x, expression<E2> const & e2){
      return double_expr{x} * e2;
    }

    template<typename E2>
    ratio<double_expr, E2> operator/(double x, expression<E2> const & e2){
      return double_expr{x} / e2;
    }

  }


  struct threshold : public detail::expression<threshold>{
    double value(double thr) const{
      return thr;
    }
  };



}