Linspace.h

#pragma once
 
#include "Common.h"
 
namespace isce3 { namespace core {

template<typename T>
class Linspace {
public:

    CUDA_HOSTDEV
    constexpr
    static
    Linspace<T> from_interval(T first, T last, int size);
 
    Linspace() = default;

    CUDA_HOSTDEV
    constexpr
    Linspace(T first, T spacing, int size);
 
    template<typename U>
    CUDA_HOSTDEV
    constexpr
    Linspace(const Linspace<U> &);
 
    template<typename U>
    CUDA_HOSTDEV
    constexpr
    Linspace<T> & operator=(const Linspace<U> &);

    CUDA_HOSTDEV
    constexpr
    T operator[](int pos) const { return _first + pos * _spacing; }

    CUDA_HOSTDEV
    constexpr
    T first() const { return _first; }

    CUDA_HOSTDEV
    constexpr
    void first(T first) { _first = first; }

    CUDA_HOSTDEV
    constexpr
    T last() const { return operator[](_size - 1); }

    CUDA_HOSTDEV
    constexpr
    T spacing() const { return _spacing; }

    CUDA_HOSTDEV
    constexpr
    void spacing(T spacing) { _spacing = spacing; };

    CUDA_HOSTDEV
    constexpr
    int size() const { return _size; }

    CUDA_HOSTDEV
    constexpr
    void resize(int size);

    CUDA_HOSTDEV
    constexpr
    Linspace<T> subinterval(int start, int stop) const;

    CUDA_HOSTDEV
    constexpr
    bool empty() const { return _size == 0; }

    template<typename U>
    CUDA_HOSTDEV
    constexpr
    int search(U) const;
 
private:
    T _first = {};
    T _spacing = {};
    int _size = 0;
};
 
template<typename T, typename U>
CUDA_HOSTDEV
constexpr
bool operator==(const Linspace<T> &, const Linspace<U> &);
 
template<typename T, typename U>
CUDA_HOSTDEV
constexpr
bool operator!=(const Linspace<T> &, const Linspace<U> &);
 
}}
 
#define ISCE_CORE_LINSPACE_ICC
#include "Linspace.icc"
#undef ISCE_CORE_LINSPACE_ICC