set.h

Go to the documentation of this file.

//
// APFEL++ 2017
//
// Author: Valerio Bertone: valerio.bertone@cern.ch
//
 
#pragma once
 
#include "apfel/convolutionmap.h"
 
#include <functional>
 
namespace apfel
{
  template<class T>
  class Set
  {
  public:
    Set(ConvolutionMap const& Map = ConvolutionMap{"UNDEFINED"}, std::map<int, T> const& in = std::map<int, T> {});
 
    Set(std::map<int, T> const& in);
 
 
    template<class V> Set<V> operator *= (Set<V> const& d) const;
 
    Set<T>& operator *= (double const& s);                                      
    Set<T>& operator *= (std::function<double(double const&)> f);               
    Set<T>& operator *= (std::function<std::vector<double>(double const&)> f);  
    Set<T>& operator *= (std::vector<double> const& v);                         
    Set<T>& operator *= (std::map<int, double> const& v);                       
    Set<T>& operator /= (double const& s);                                      
    Set<T>& operator += (Set<T> const& d);                                      
    Set<T>& operator -= (Set<T> const& d);                                      
 
 
    T const& at(int const& id) const { return _objects.at(id); }
    ConvolutionMap const& GetMap() const { return _map; }
    std::map<int, T> const& GetObjects() const { return _objects; }
 
    void SetMap(ConvolutionMap const& map) { _map = map; }
 
    void SetObjects(std::map<int, T> const& objects) { _objects = objects; }
 
    T Combine() const;
 
    T Combine(std::vector<double> const& weigths) const;
 
    void Print() const { std::cout << *this << std::endl; }
 
  private:
    ConvolutionMap   _map;     
    std::map<int, T> _objects; 
 
    template<class U>
    friend std::ostream& operator << (std::ostream& os, Set<U> const& s);
  };
 
  template<class A, class B>
  Set<B> operator * (Set<A> lhs, Set<B> const& rhs) { return lhs *= rhs; }
 
  // other operators
  template<class T>
  Set<T> operator * (double const& s, Set<T> rhs) { return rhs *= s; }
 
  template<class T>
  Set<T> operator * (Set<T> lhs, double const& s) { return lhs *= s; }
 
  template<class T>
  Set<T> operator * (std::function<double(double const&)> f, Set<T> rhs) { return rhs *= f; }
 
  template<class T>
  Set<T> operator * (std::function<std::vector<double>(double const&)> f, Set<T> rhs) { return rhs *= f; }
 
  template<class T>
  Set<T> operator * (Set<T> lhs, std::function<double(double const&)> f) { return lhs *= f; }
 
  template<class T>
  Set<T> operator * (std::vector<double> const& v, Set<T> rhs) { return rhs *= v; }
 
  template<class T>
  Set<T> operator * (Set<T> lhs, std::vector<double> const& v) { return lhs *= v; }
 
  template<class T>
  Set<T> operator * (std::map<int, double> const& v, Set<T> rhs) { return rhs *= v; }
 
  template<class T>
  Set<T> operator * (Set<T> lhs, std::map<int, double> const& v) { return lhs *= v; }
 
  template<class T>
  Set<T> operator / (Set<T> lhs, double const& s) { return lhs /= s; }
 
  template<class T>
  Set<T> operator * (Set<T> lhs, Set<T> const& rhs) { return lhs *= rhs; }
 
  template<class T>
  Set<T> operator + (Set<T> lhs, Set<T> const& rhs) { return lhs += rhs; }
 
  template<class T>
  Set<T> operator - (Set<T> lhs, Set<T> const& rhs) { return lhs -= rhs; }
}