shape.hpp

Go to the documentation of this file.

#include <array>
#include <cmath>
#include <numeric>
#include <vector>

#include "logs/logs.hpp"

#ifndef TEQ_SHAPE_HPP
#define TEQ_SHAPE_HPP

namespace teq
{

using RankT = uint8_t;

#define SDIM_BYTES 2

#if !defined(SDIM_BYTES) || SDIM_BYTES <= 1
using DimT = uint8_t;
#elif SDIM_BYTES <= 2
using DimT = uint16_t;
#elif SDIM_BYTES <= 4
using DimT = uint32_t;
#else
using DimT = uint64_t;
#endif

using CDimT = double;

using NElemT = uint64_t;

const RankT rank_cap = 8;

using ShapeT = std::array<DimT,rank_cap>;

using CoordT = std::array<CDimT,rank_cap>;

struct Shape final
{
    using iterator = ShapeT::iterator;

    using const_iterator = ShapeT::const_iterator;

    Shape (void)
    {
        std::fill(dims_.begin(), dims_.end(), 1);
    }

    Shape (std::vector<DimT> dims)
    {
        vector_assign(dims);
    }

    Shape (const Shape& other) = default;

    Shape& operator = (const Shape& other) = default;

    Shape& operator = (const std::vector<DimT>& dims)
    {
        vector_assign(dims);
        return *this;
    }

    Shape (Shape&& other)
    {
        move_helper(std::move(other));
    }

    Shape& operator = (Shape&& other)
    {
        if (this != &other)
        {
            move_helper(std::move(other));
        }
        return *this;
    }


    // >>>> ACCESSORS <<<<

    DimT at (RankT idx) const
    {
        if (rank_cap <= idx)
        {
            logs::fatalf("cannot access out of bounds index %d", idx);
        }
        return dims_.at(idx);
    }

    NElemT n_elems (void) const
    {
        auto it = dims_.begin();
        return std::accumulate(it, it + rank_cap, (NElemT) 1,
            std::multiplies<NElemT>());
    }

    bool compatible_before (const Shape& other, RankT idx) const
    {
        auto it = dims_.begin();
        return std::equal(it, it + std::min(idx, rank_cap), other.dims_.begin());
    }

    bool compatible_after (const Shape& other, RankT idx) const
    {
        bool compatible = false;
        if (idx < rank_cap)
        {
            compatible = std::equal(dims_.begin() + idx,
                dims_.end(), other.dims_.begin() + idx);
        }
        return compatible;
    }

    std::string to_string (void) const
    {
        return fmts::to_string(begin(), end());
    }

    // >>>> INTERNAL CONTROL <<<<

    iterator begin (void)
    {
        return dims_.begin();
    }

    iterator end (void)
    {
        return dims_.end();
    }

    const_iterator begin (void) const
    {
        return dims_.begin();
    }

    const_iterator end (void) const
    {
        return dims_.end();
    }

private:
    void vector_assign (const std::vector<DimT>& dims)
    {
        auto src = dims.begin();
        if (std::any_of(src, dims.end(),
            [](DimT d)
            {
                return d == 0;
            }))
        {
            logs::fatalf("cannot create shape with vector containing zero: %s",
                fmts::to_string(dims.begin(), dims.end()).c_str());
        }
        auto dest = dims_.begin();
        RankT rank = std::min((size_t) rank_cap, dims.size());
        std::copy(src, src + rank, dest);
        std::fill(dest + rank, dest + rank_cap, 1);
    }

    void move_helper (Shape&& other)
    {
        dims_ = std::move(other.dims_);
        std::fill(other.dims_.begin(), other.dims_.end(), 1);
    }

    ShapeT dims_;
};

NElemT index (Shape shape, CoordT coord);

CoordT coordinate (Shape shape, NElemT idx);

}

#endif // TEQ_SHAPE_HPP