LUT1d.h

#pragma once
 
#include "forward.h"
#include <isce3/core/EMatrix.h>
#include <isce3/except/Error.h>
 
#include <valarray>
#include <Eigen/Core>
 
namespace isce3::core {

template <typename T>
class LUT1d {
 
    public:
        using ArrayXt = Eigen::Array<T, Eigen::Dynamic, 1>;
        inline LUT1d() : _haveData(false), _refValue(0.0), _extrapolate{true} {
            std::valarray<double> x{0.0, 1.0};
            std::valarray<double> y{0.0, 0.0};
            _coords = x;
            _values = y;
        }

        inline LUT1d(T refValue) : _haveData(false), _refValue(refValue), _extrapolate{true} {}

        inline LUT1d(size_t size) : _haveData(false), _refValue(0.0), _extrapolate{true} {
            _coords.resize(size);
            _values.resize(size);
        }

        inline LUT1d(const std::valarray<double> & coords, const std::valarray<T> & values,
                     bool extrapolate = false) :
                     _haveData(true),
                     _refValue(values[0]),
                     _coords(coords),
                     _values(values),
                     _extrapolate{extrapolate} {}

        inline LUT1d(const LUT1d<T> & lut) :
            _haveData(lut.haveData()),
            _refValue(lut.refValue()),
            _coords(lut.coords()),
            _values(lut.values()),
            _extrapolate(lut.extrapolate()) {}

        inline LUT1d & operator=(const LUT1d<T> & lut) {
            _haveData = lut.haveData();
            _refValue = lut.refValue();
            _coords = lut.coords();
            _values = lut.values();
            _extrapolate = lut.extrapolate();
            return *this;
        }

        inline std::valarray<double> & coords() { return _coords; }

        inline const std::valarray<double> & coords() const { return _coords; }

        inline void coords(const std::valarray<double> & c) { _coords = c; }

        inline std::valarray<T> & values() { return _values; }

        inline const std::valarray<T> & values() const { return _values; }

        inline void values(const std::valarray<T> & v) { _values = v; }

        inline bool extrapolate() const { return _extrapolate; }

        inline void extrapolate(bool flag) { _extrapolate = flag; }

        inline bool haveData() const { return _haveData; }

        inline T refValue() const { return _refValue; }

        inline size_t size() const { return _coords.size(); }

        inline T eval(double x) const;
        inline ArrayXt eval(const Eigen::Ref<const Eigen::ArrayXd>& x) const;
    // Data members
    private:
        bool _haveData;
        T _refValue;
        std::valarray<double> _coords;
        std::valarray<T> _values;
        bool _extrapolate;
};

template <typename T>
LUT1d<T> avgLUT2dToLUT1d(const LUT2d<T> & lut2d, const int axis = 0);
 
} // namespace isce3::core
 
// Get inline implementations for LUT1d
#define ISCE_CORE_LUT1D_ICC
#include "LUT1d.icc"
#undef ISCE_CORE_LUT1D_ICC