Linspace.icc

#ifndef ISCE_CORE_LINSPACE_ICC
#error "Linspace.icc is an implementation detail of Linspace.h"
#endif
 
#include <cassert>
 
namespace isce3 { namespace core {
 
template<typename T>
CUDA_HOSTDEV
constexpr
Linspace<T>
Linspace<T>::from_interval(T first, T last, int size)
{
    T spacing = (last - first) / (size - 1);
    return {first, spacing, size};
}
 
template<typename T>
CUDA_HOSTDEV
constexpr
Linspace<T>::Linspace(T first, T spacing, int size)
:
    _first(first),
    _spacing(spacing),
    _size(size)
{
    assert(size >= 0);
}
 
template<typename T>
template<typename U>
CUDA_HOSTDEV
constexpr
Linspace<T>::Linspace(const Linspace<U> & x)
:
    _first(x.first()),
    _spacing(x.spacing()),
    _size(x.size())
{}
 
template<typename T>
template<typename U>
CUDA_HOSTDEV
constexpr
Linspace<T> &
Linspace<T>::operator=(const Linspace<U> & other)
{
    _first = other.first();
    _spacing = other.spacing();
    _size = other.size();
    return *this;
}
 
template<typename T>
CUDA_HOSTDEV
constexpr
void Linspace<T>::resize(int size)
{
    assert(size >= 0);
    _size = size;
}
 
template<typename T>
CUDA_HOSTDEV
constexpr
Linspace<T>
Linspace<T>::subinterval(int start, int stop) const
{
    return {operator[](start), _spacing, stop - start};
}
 
template<typename T>
template<typename U>
CUDA_HOSTDEV
constexpr
int Linspace<T>::search(U val) const
{
    if (spacing() >= 0) {
        if (val < first()) { return 0; }
        if (val > last())  { return size(); }
    }
    else {
        if (val > first()) { return 0; }
        if (val < last())  { return size(); }
    }
 
    return (val - first()) / spacing() + 1;
}
 
template<typename T, typename U>
CUDA_HOSTDEV
constexpr
bool operator==(const Linspace<T> & lhs, const Linspace<U> & rhs)
{
    return lhs.first() == rhs.first() &&
           lhs.spacing() == rhs.spacing() &&
           lhs.size() == rhs.size();
}
 
template<typename T, typename U>
CUDA_HOSTDEV
constexpr
bool operator!=(const Linspace<T> & lhs, const Linspace<U> & rhs)
{
    return !(lhs == rhs);
}
 
}}