Transformation.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2024 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_TRANSFORMATION_H
#define YODA_TRANSFORMATION_H
 
#include "YODA/Exceptions.h"
#include "YODA/Utils/MathUtils.h"
//#include "YODA/Utils/Traits.h"
//#include "YODA/Utils/sortedvector.h"
#include "YODA/Utils/ndarray.h"
#include <algorithm>
#include <functional>
#include <map>
#include <utility>
 
 
namespace YODA {
 
 
  template<size_t N, typename... Args>
  class Transformation {
  public:
 
    using Pair = std::pair<double,double>;
    using NdVal = typename Utils::ndarray<double, N>;
    using NdValPair = typename Utils::ndarray<Pair, N>;
    using Breakdown = std::map<std::string,std::pair<double,double>>;
 
 
 
    Transformation() = delete;
 
    Transformation(const std::function<double(double, Args...)>& fn) : _Fn(fn) { }
 
    Transformation(std::function<double(double, Args...)>&& fn) : _Fn(std::move(fn)) { }
 
 
    double operator()(const double v, Args&&... args) const { return _Fn(v, std::forward<Args>(args)...); }
 
 
 
 
    void transform(double& val, Args&&... args) const { val = _Fn(val, std::forward<Args>(args)...); }
 
    void transform(NdVal& vals, Args&&... args) const {
      for (double& val : vals) {
        transform(val, std::forward<Args>(args)...);
      }
    }
 
    // @todo allow arbitrary arrays, not just NdVal ...
 
    void transform(double& val, Breakdown& signed_errs, Args&&... args) const {
      // keep track of original central value
      const double oldval = val;
      // transform central value
      transform(val, std::forward<Args>(args)...);
      // transform errors
      for (auto& item : signed_errs) {
        item.second.first = _Fn(oldval + item.second.first, std::forward<Args>(args)...) - val;
        item.second.second = _Fn(oldval + item.second.second, std::forward<Args>(args)...) - val;
      }
    }
 
    void transform(double& val, Pair& errs, Args&&... args) const {
      // transform errors
      const double trf_min = _Fn(val - errs.first, std::forward<Args>(args)...);
      const double trf_max = _Fn(val + errs.second, std::forward<Args>(args)...);
      // transform central value
      transform(val, std::forward<Args>(args)...);
      // Deal with possible inversions of min/max ordering under the transformation
      const double new_min = std::min(trf_min, trf_max);
      const double new_max = std::max(trf_min, trf_max);
      errs = std::make_pair(val - new_min, new_max - val);
    }
 
    void transform(NdVal& vals, NdValPair& errs, Args&&... args) const {
      for (size_t i = 0; i < N; ++i) {
        transform(vals[i], errs[i], std::forward<Args>(args)...);
      }
    }
 
 
  protected:
 
 
    std::function<double(double, Args...)> _Fn;
 
 
  };
 
 
 
 
  template<size_t N>
  using Trf = Transformation<N>;
 
 
}
 
#endif