EIC code displayed by LXR master/​include/​apfel/​set.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-06-02 08:17:14

 //
 // APFEL++ 2017
 //
 // Author: Valerio Bertone: valerio.bertone@cern.ch
 //
 
 #pragma once
 
 #include "apfel/convolutionmap.h"
 #include "apfel/distribution.h"
 
 #include <functional>
 
 namespace apfel
 {
   /**
    * @brief The Set template class allocates a collection of objects
    * of type T along the ConvolutionMap and provides the methods to
    * perform operations between different types of objects T.
    */
   template<class T>
   class Set
   {
   public:
     /**
      * @brief The Set constructor.
      * @param Map: the convolution map (defualt: empty ConvolutionMap)
      * @param in: a map of objects of type T (defualt: empty map of objects)
      */
     Set(ConvolutionMap const& Map = ConvolutionMap{"UNDEFINED"}, std::map<int, T> const& in = std::map<int, T> {});
 
     /**
      * @brief The Set constructor.
      * @param in: a map of objects of type T (defualt: empty map of objects)
      * @note When invoking this constructor a diagonal convolution map
      * is automatically constructed.
      */
     Set(std::map<int, T> const& in);
 
     /**
      * @name Binary operators
      */
     ///@{
     /**
      * @brief operator *= product object
      * @param d: the left hand side object of type V
      * @return a new object of type V
      */
     template<class V> Set<V> operator *= (Set<V> const& d) const;
 
     Set<T>& operator *= (double const& s);                                      //!< this *= scalar
     Set<T>& operator *= (std::function<double(double const&)> f);               //!< this *= function of the integration variable (for distributions only)
     Set<T>& operator *= (std::function<std::vector<double>(double const&)> f);  //!< this *= function of the integration variable that returns a vector (for distributions only)
     Set<T>& operator *= (std::vector<double> const& v);                         //!< this *= vector of scalars
     Set<T>& operator *= (std::map<int, double> const& v);                       //!< this *= map of scalars
     Set<T>& operator /= (double const& s);                                      //!< this /= scalar
     Set<T>& operator += (Set<T> const& d);                                      //!< this += Set
     Set<T>& operator -= (Set<T> const& d);                                      //!< this -= Set
     ///@}
 
     /**
      * @name Getters
      */
     ///@{
     /**
      * @brief This returns object with ID "id" in the map.
      * @param id: objects ID
      */
     T const& at(int const& id) const { return _objects.at(id); }
     /**
      * @brief This returns the convolution map.
      */
     ConvolutionMap const& GetMap() const { return _map; }
     /**
      * @brief This returns the full map of objects.
      */
     std::map<int, T> const& GetObjects() const { return _objects; }
     ///@}
 
     /**
      * @brief This function (re)sets the convolution map.
      */
     void SetMap(ConvolutionMap const& map) { _map = map; }
 
     /**
      * @brief This function (re)sets the map of objects.
      * @param objects: set of objects
      */
     void SetObjects(std::map<int, T> const& objects) { _objects = objects; }
 
     /**
      * @brief This function sums up all the objects of the set into
      * one.
      */
     T Combine() const;
 
     /**
      * @brief This function sums up all the objects of the set into
      * one using the components of input vector as weights.
      * @param weigths: set of weights
      */
     T Combine(std::vector<double> const& weigths) const;
 
     /**
      * @brief This function trasforms the set of objects (only
      * Distributions) given a set of functions, one for each
      * distribution in the set. This function is diagonal in the sense
      * that each transforming function can only transform one single
      * distribution.
      * @param TranformationFuncs: set of transformation functions
      */
     Set<T> Transform(std::map<int, std::function<double(double const&)>> const& TranformationFuncs) const;
 
     /**
      * @brief This function trasforms the set of objects (only
      * Distributions) given a set of functions, one for each
      * distribution in the set. This function is not diagonal in the
      * sense that different distributions can mix upon transformation.
      * @param TranformationFuncs: set of transformation functions
      */
     Set<T> Transform(std::map<int, std::map<int, std::function<double(double const&)>>> const& TranformationFuncs) const;
 
     /**
      * @brief This function trasforms the set of objects (only
      * Distributions) given a set of functions, one for each
      * distribution in the set. This function is not diagonal in the
      * sense that different distributions can mix upon transformation.
      * @param TranformationFuncs: set of transformation functions
      */
     Set<T> Transform(std::map<int, std::function<double(std::map<int, double> const&)>> const& TranformationFuncs) const;
 
 
     /**
      * @brief This function interpolates the single objects of the set
      * (only Operators) over the first index and returns a set of
      * Distributions.
      * @param x: value of the variable to be interpolated
      */
     Set<Distribution> Evaluate(double const& x) const;
 
     /**
      * @brief This function squashes the single objects of the set
      * (only Distributions) and returns a map of integers to doubles.
      */
     std::map<int, double> Squash() const;
 
     /**
      * @brief Print the Operator object
      */
     void Print() const { std::cout << *this << std::endl; }
 
   private:
     ConvolutionMap   _map;     //!< The shared pointer containing the convolution map
     std::map<int, T> _objects; //!< The container for the map
 
     template<class U>
     friend std::ostream& operator << (std::ostream& os, Set<U> const& s);
   };
 
   /**
    * @name Ternary operators
    */
   ///@{
   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; }
   ///@}
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team