fsb_types.h

 
#ifndef FSB_TYPES_H
#define FSB_TYPES_H
 
#include <array>
#include <cmath>
#include <cstddef>
 
#define FSB_TOL (4.5e-15)
 
#define FSB_CART_SIZE (6U)
 
namespace fsb
{
 
using Real = double;
 
struct Vec3
{
    Real x = 0.0;
    Real y = 0.0;
    Real z = 0.0;
};
 
struct Mat3Sym
{
    Real m00 = 0.0;
    Real m11 = 0.0;
    Real m22 = 0.0;
    Real m01 = 0.0;
    Real m02 = 0.0;
    Real m12 = 0.0;
};
 
struct Mat3
{
    Real m00 = 0.0;
    Real m10 = 0.0;
    Real m20 = 0.0;
    Real m01 = 0.0;
    Real m11 = 0.0;
    Real m21 = 0.0;
    Real m02 = 0.0;
    Real m12 = 0.0;
    Real m22 = 0.0;
};
 
template<typename T>
class Span
{
public:
    Span() = default;
    Span(T* ptr, size_t len) noexcept : m_ptr(ptr), m_len(len) {}
 
    [[nodiscard]] T*       data()        noexcept { return m_ptr; }
    [[nodiscard]] const T* data()  const noexcept { return m_ptr; }
    [[nodiscard]] size_t   size()  const noexcept { return m_len; }
    [[nodiscard]] bool     empty() const noexcept { return m_len == 0U; }
 
    T&       operator[](size_t ind)       noexcept { return *(m_ptr + ind); }
    const T& operator[](size_t ind) const noexcept { return *(m_ptr + ind); }
 
    [[nodiscard]] T*       begin()       noexcept { return m_ptr; }
    [[nodiscard]] T*       end()         noexcept { return m_ptr + m_len; }
    [[nodiscard]] const T* begin() const noexcept { return m_ptr; }
    [[nodiscard]] const T* end()   const noexcept { return m_ptr + m_len; }
 
    [[nodiscard]] Span<T> active(size_t num, size_t offset = 0U) noexcept
    {
        const size_t off_clamped = (offset < m_len) ? offset : m_len;
        const size_t remaining = m_len - off_clamped;
        const size_t count = (num < remaining) ? num : remaining;
        return Span<T>(m_ptr + off_clamped, count);
    }
    [[nodiscard]] Span<const T> active(size_t num, size_t offset = 0U) const noexcept
    {
        const size_t off_clamped = (offset < m_len) ? offset : m_len;
        const size_t remaining = m_len - off_clamped;
        const size_t count = (num < remaining) ? num : remaining;
        return Span<const T>(m_ptr + off_clamped, count);
    }
 
private:
    T* m_ptr = nullptr;
    size_t m_len = 0U;
};
 
template<size_t Size, typename Type = Real>
struct Array : public std::array<Type, Size>
{
    Span<Type> active(size_t num) noexcept
    {
        const size_t num_count = (num < Size) ? num : Size;
        return Span<Type>(this->data(), num_count);
    }
    Span<const Type> active(size_t num) const noexcept
    {
        const size_t num_count = (num < Size) ? num : Size;
        return Span<const Type>(this->data(), num_count);
    }
};
 
} // namespace fsb
 
#endif