Creation.hpp

#pragma once
 
#include <cstddef>
 
#include <stratax/core/dtypes/Concepts.hpp>
#include <stratax/containers/Matrix.hpp>
#include <stratax/containers/Tensor.hpp>
#include <stratax/containers/Vector.hpp>
#include <stratax/core/Shape.hpp>
 
namespace stratax::creation {
 
template<DType T>
[[nodiscard]]
stratax::container::Tensor<T> zeros(const stratax::core::Shape& shape)
{
    return stratax::container::Tensor<T>(shape, T{});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Vector<T> zeros(std::size_t size)
{
    return stratax::container::Vector<T>(size, T{});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Matrix<T> zeros(std::size_t rows, std::size_t cols)
{
    return stratax::container::Matrix<T>(rows, cols, T{});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Tensor<T> ones(const stratax::core::Shape& shape)
{
    return stratax::container::Tensor<T>(shape, T{1});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Vector<T> ones(std::size_t size)
{
    return stratax::container::Vector<T>(size, T{1});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Matrix<T> ones(std::size_t rows, std::size_t cols)
{
    return stratax::container::Matrix<T>(rows, cols, T{1});
}
 
template<DType T>
[[nodiscard]]
stratax::container::Tensor<T> full(const stratax::core::Shape& shape, const T& value)
{
    return stratax::container::Tensor<T>(shape, value);
}
 
template<DType T>
[[nodiscard]]
stratax::container::Vector<T> full(std::size_t size, const T& value)
{
    return stratax::container::Vector<T>(size, value);
}
 
template<DType T>
[[nodiscard]]
stratax::container::Matrix<T> full(std::size_t rows, std::size_t cols, const T& value)
{
    return stratax::container::Matrix<T>(rows, cols, value);
}
 
template<DType T>
[[nodiscard]]
stratax::container::Matrix<T> identity(std::size_t size)
{
    stratax::container::Matrix<T> result(size, size, T{});
 
    for (std::size_t i = 0; i < size; ++i)
    {
        result(i, i) = T{1};
    }
 
    return result;
}
 
}