Conversion.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <vector>
 
#include <stratax/containers/Matrix.hpp>
#include <stratax/containers/Tensor.hpp>
#include <stratax/containers/Vector.hpp>
#include <stratax/core/ArrayTraits.hpp>
#include <stratax/core/dtypes/Concepts.hpp>
#include <stratax/core/Shape.hpp>
#include <stratax/exceptions/Exceptions.hpp>
 
namespace stratax::conversion {
 
namespace detail {

inline bool is_vector_shape(const stratax::core::Shape& shape)
{
    if (shape.rank() == 1)
    {
        return true;
    }
 
    std::size_t non_singleton = 0;
 
    for (std::size_t dim : shape)
    {
        if (dim > 1)
        {
            ++non_singleton;
        }
    }
 
    return non_singleton == 1;
}

inline bool is_matrix_shape(const stratax::core::Shape& shape)
{
    if (shape.rank() == 2)
    {
        return true;
    }
 
    std::size_t non_singleton = 0;
 
    for (std::size_t dim : shape)
    {
        if (dim > 1)
        {
            ++non_singleton;
        }
    }
 
    return non_singleton == 2;
}

inline stratax::core::Shape matrix_shape(const stratax::core::Shape& shape)
{
    if (shape.rank() == 2)
    {
        return shape;
    }
 
    std::vector<std::size_t> dims;
    dims.reserve(2);
 
    for (std::size_t dim : shape)
    {
        if (dim > 1)
        {
            dims.push_back(dim);
        }
    }
 
    return stratax::core::Shape(dims);
}
 
} // namespace detail

template<Array A>
[[nodiscard]]
stratax::container::Vector<typename A::value_type>
to_vector(const A& arr)
{
    if (!detail::is_vector_shape(arr.shape()))
    {
        throw Exceptions::ShapeError(
            "Array cannot be converted to a Vector.");
    }
 
    stratax::container::Vector<typename A::value_type> result(arr.size());
 
    std::copy(
        arr.begin(),
        arr.end(),
        result.begin());
 
    return result;
}

template<Array A>
[[nodiscard]]
stratax::container::Matrix<typename A::value_type>
to_matrix(const A& arr)
{
    if (!detail::is_matrix_shape(arr.shape()))
    {
        throw Exceptions::ShapeError(
            "Array cannot be converted to a Matrix.");
    }
 
    const stratax::core::Shape shape =
        detail::matrix_shape(arr.shape());
 
    stratax::container::Matrix<typename A::value_type> result(shape);
 
    std::copy(
        arr.begin(),
        arr.end(),
        result.begin());
 
    return result;
}

template<Array A>
[[nodiscard]]
stratax::container::Tensor<typename A::value_type>
to_tensor(const A& arr)
{
    stratax::container::Tensor<typename A::value_type> result(arr.shape());
 
    std::copy(
        arr.begin(),
        arr.end(),
        result.begin());
 
    return result;
}

template<DType To, Array A>
[[nodiscard]]
stratax::core::rebind_array_t<A, To>
astype(const A& arr)
{
    using result_type =
        stratax::core::rebind_array_t<A, To>;
 
    result_type result(arr.shape());
 
    std::transform(
        arr.begin(),
        arr.end(),
        result.begin(),
        [](const auto& value)
        {
            return static_cast<To>(value);
        });
 
    return result;
}
 
} // namespace stratax::conversion