vector.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "NeoN/core/error.hpp"
#include "NeoN/core/executor/executor.hpp"
#include "NeoN/core/primitives/label.hpp"
#include "NeoN/core/primitives/scalar.hpp"
#include "NeoN/core/view.hpp"
#include "NeoN/helpers/exceptions.hpp"
 
#include <vector>
 
 
namespace NeoN
{
template<typename ValueType>
class Vector
{
 
public:
 
    using VectorValueType = ValueType;

    Vector(const Executor& exec, sizeType size);

    Vector(
        const Executor& exec,
        const ValueType* in,
        sizeType size,
        Executor hostExec = SerialExecutor()
    );

    Vector(const Executor& exec, sizeType size, ValueType value);

    Vector(const Executor& exec, std::vector<ValueType> in);

    Vector(const Executor& exec, const Vector<ValueType>& in);

    Vector(const Vector<ValueType>& rhs);

    Vector(Vector<ValueType>&& rhs) noexcept;

    ~Vector();

    template<typename func>
    void apply(func f)
    {
        map(*this, f);
    }

    [[nodiscard]] Vector<ValueType> copyToExecutor(Executor dstExec) const;

    [[nodiscard]] Vector<ValueType> copyToHost() const;

    void copyToHost(Vector<ValueType>& result);

    ValueType& operator[](const localIdx i) = delete;
 
    const ValueType& operator[](const localIdx i) const = delete;

    void operator=(const ValueType& rhs);

    void operator=(const Vector<ValueType>& rhs);

    Vector<ValueType>& operator=(Vector<ValueType>&& rhs) noexcept;

    Vector<ValueType>& operator+=(const Vector<ValueType>& rhs);

    Vector<ValueType>& operator-=(const Vector<ValueType>& rhs);

    [[nodiscard]] Vector<ValueType> operator*(const Vector<ValueType>& rhs)
        requires requires(ValueType a, ValueType b) { a* b; };

    [[nodiscard]] Vector<ValueType> operator*(const scalar rhs)
        requires requires(ValueType a, scalar b) { a* b; };

    Vector<ValueType>& operator*=(const Vector<ValueType>& rhs)
        requires requires(ValueType a, ValueType b) { a *= b; };

    Vector<ValueType>& operator*=(const scalar rhs)
        requires requires(ValueType a, scalar b) { a *= b; };

    void resize(const sizeType size);

    [[nodiscard]] ValueType* data() { return data_; }

    [[nodiscard]] const ValueType* data() const { return data_; }

    [[nodiscard]] ValueType* begin() { return data_; }

    [[nodiscard]] const ValueType* begin() const { return data_; }

    [[nodiscard]] ValueType* end() { return data_ + size(); }

    [[nodiscard]] const ValueType* end() const { return data_ + size(); }

    [[nodiscard]] const Executor& exec() const { return exec_; }

    [[nodiscard]] sizeType size() const { return size_; }

    [[nodiscard]] label ssize() const { return static_cast<label>(size_); }

    [[nodiscard]] bool empty() const { return size() == 0; }

    View<ValueType> view() && = delete;
 
    View<const ValueType> view() const&& = delete;

    [[nodiscard]] View<ValueType> view() & { return View<ValueType>(data_, size_); }

    [[nodiscard]] View<const ValueType> view() const&
    {
        return View<const ValueType>(data_, size_);
    }

    [[nodiscard]] View<ValueType> view(std::pair<localIdx, localIdx> range) && = delete;
 
    [[nodiscard]] View<const ValueType> view(std::pair<localIdx, localIdx> range) const&& = delete;

    [[nodiscard]] View<ValueType> view(std::pair<localIdx, localIdx> range) &
    {
        NeoN::validateRange(range, size());
        return View<ValueType>(
            data_ + range.first, static_cast<sizeType>(range.second - range.first)
        );
    }

    [[nodiscard]] View<const ValueType> view(std::pair<localIdx, localIdx> range) const&
    {
        NeoN::validateRange(range, size());
        return View<const ValueType>(
            data_ + range.first, static_cast<sizeType>(range.second - range.first)
        );
    }

    [[nodiscard]] inline std::pair<localIdx, localIdx> range() const
    {
        return {0, NeoN::toLocalIdx(size())};
    }
 
private:
 
    sizeType size_ {0};         
    ValueType* data_ {nullptr}; 
    const Executor exec_;       

    void validateOtherVector(const Vector<ValueType>& rhs) const;
};

template<typename ValueType>
[[nodiscard]] Vector<ValueType> operator+(Vector<ValueType> lhs, const Vector<ValueType>& rhs);

template<typename ValueType>
[[nodiscard]] Vector<ValueType> operator-(Vector<ValueType> lhs, const Vector<ValueType>& rhs);
 
} // namespace NeoN