LUT1d.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Source Author: Bryan Riel
// Copyright 2017-2018
//

#pragma once

#include "forward.h"

#include <valarray>

template <typename T>
class isce3::core::LUT1d {

    public:
        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 LUT1d(const LUT2d<T> & lut2d);

        inline LUT1d & operator=(const LUT2d<T> & lut2d);

        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;

    // Data members
    private:
        bool _haveData;
        T _refValue;
        std::valarray<double> _coords;
        std::valarray<T> _values;
        bool _extrapolate;
};

// Get inline implementations for LUT1d
#define ISCE_CORE_LUT1D_ICC
#include "LUT1d.icc"
#undef ISCE_CORE_LUT1D_ICC