doubleobject.h

Go to the documentation of this file.

//
// APFEL++ 2017
//
// Author: Valerio Bertone: valerio.bertone@cern.ch
//
 
#pragma once
 
#include "apfel/tools.h"
 
#include <functional>
#include <iostream>
 
namespace apfel
{
  template <class V, class U = V>
  struct term
  {
    double coefficient;
    V      object1;
    U      object2;
  };
 
  template<class T, class U = T>
  class DoubleObject
  {
  public:
 
    DoubleObject();
 
    DoubleObject(std::vector<term<T, U>> const& terms);
 
    void AddTerm(term<T, U> const& newterm);
 
    std::vector<term<T, U>> GetTerms() const { return _terms; };
 
    double Evaluate(double const& x, double const& z) const;
 
    T Evaluate1(double const& x) const;
 
    U Evaluate2(double const& z) const;
 
    double Derive(double const& x, double const& z) const;
 
    T Derive1(double const& x) const;
 
    U Derive2(double const& z) const;
 
    double Integrate(double const& xl, double const& xu, double const& zl, double const& zu) const;
 
    T Integrate1(double const& xl, double const& xu) const;
 
    U Integrate2(double const& zl, double const& zu) const;
 
    double Integrate(double const& xl, double const& xu, std::function<double(double const&)> zlx, std::function<double(double const&)> zux) const;
 
    double Integrate(std::function<double(double const&)> xlz, std::function<double(double const&)> xuz, double const& zl, double const& zu) const;
 
    DoubleObject<T, U>& MultiplyBy(std::function<double(double const&)> const& fx, std::function<double(double const&)> const& fz);
 
    void Print() const { std::cout << *this << std::endl; }
 
    template<class V> DoubleObject<V> operator *= (DoubleObject<V> const& o) const;
    DoubleObject<T, U>& operator *= (double const& s);                               
    DoubleObject<T, U>& operator *= (DoubleObject<T, U> const& o);                   
    DoubleObject<T, U>& operator *= (std::function<double(double const&)> const& f); 
    DoubleObject<T, U>& operator /= (double const& s);                               
    DoubleObject<T, U>& operator += (DoubleObject<T, U> const& o);                   
    DoubleObject<T, U>& operator -= (DoubleObject<T, U> const& o);                   
 
  private:
    std::vector<term<T, U>> _terms;
 
    template<class V, class W>
    friend std::ostream& operator << (std::ostream& os, DoubleObject<V, W> const& dob);
  };
 
  template<class A, class B>
  DoubleObject<B> operator * (DoubleObject<A> lhs, DoubleObject<B> const& rhs) { return lhs *= rhs; }
 
  template<class T, class U>
  DoubleObject<T, U> operator * (double const& s, DoubleObject<T, U> rhs) { return rhs *= s; }
 
  template<class T, class U>
  DoubleObject<T, U> operator * (DoubleObject<T, U> lhs, double const& s) { return lhs *= s; }
 
  template<class T, class U>
  DoubleObject<T, U> operator / (DoubleObject<T, U> lhs, double const& s) { return lhs /= s; }
 
  template<class T, class U>
  DoubleObject<T, U> operator * (DoubleObject<T, U> lhs, DoubleObject<T, U> const& rhs) { return lhs *= rhs; }
 
  template<class T, class U>
  DoubleObject<T, U> operator + (DoubleObject<T, U> lhs, DoubleObject<T, U> const& rhs) { return lhs += rhs; }
 
  template<class T, class U>
  DoubleObject<T, U> operator - (DoubleObject<T, U> lhs, DoubleObject<T, U> const& rhs) { return lhs -= rhs; }
 
  template<class T, class U>
  std::ostream& operator << (std::ostream& os, DoubleObject<T, U> const& dob);
}