vector-wrapper.h

#pragma once
#include <cstdint>
#include <matrix-types.h>
#include <snowboy-debug.h>
#include <stdexcept>
#include <string>

namespace snowboy {
	struct MatrixBase;
	class SubVector;
	class VectorBase {
	protected:
		size_t m_size{0};
		float* m_data{nullptr};

	public:
		float* begin() const noexcept { return m_data; }
		float* end() const noexcept { return m_data + m_size; }
		size_t size() const noexcept { return m_size; }
		float* data() const noexcept { return m_data; }
		float& operator[](size_t index) const noexcept {
			SNOWBOY_ASSERT(index < m_size);
			return m_data[index];
		}
		float& operator()(size_t index) const noexcept {
			SNOWBOY_ASSERT(index < m_size);
			return m_data[index];
		}
		bool empty() const noexcept { return size() == 0; }

		void Add(float x) noexcept;
		void AddDiagMat2(float, const MatrixBase&, MatrixTransposeType, float) noexcept;
		void AddMatVec(float alpha, const MatrixBase& a, MatrixTransposeType trans, const VectorBase& x, float beta) noexcept;
		void AddVec(float, const VectorBase&) noexcept;
		void AddVec2(float, const VectorBase&) noexcept;
		void ApplyFloor(float) noexcept;
		void ApplyLog() noexcept;
		void ApplyPow(float) noexcept;
		float ApplySoftmax() noexcept;
		void CopyColsFromMat(const MatrixBase&) noexcept;
		void CopyFromVec(const VectorBase&) noexcept;
		void CopyRowsFromMat(const MatrixBase&) noexcept;
		float CosineDistance(const VectorBase&) const;
		float DotVec(const VectorBase&) const;
		float EuclideanDistance(const VectorBase&) const;
		bool IsZero(float cutoff) const noexcept;
		float Max() const noexcept;
		float Max(int* e) const noexcept;
		float Min() const noexcept;
		float Min(int* e) const noexcept;
		void MulElements(const VectorBase&) noexcept;
		float Norm(float) const noexcept;
		SubVector Range(size_t offset, size_t size) const noexcept;
		void Scale(float) noexcept;
		void Set(float) noexcept;
		void SetRandomGaussian();
		void SetRandomUniform();
		float Sum() const noexcept;
		void Write(bool, std::ostream*) const;

		bool HasNan() const noexcept;
		bool HasInfinity() const noexcept;
	};
	class Vector : public VectorBase {
	protected:
		size_t m_cap{0};

	public:
		Vector() noexcept {}
		Vector(const VectorBase& other) {
			Resize(other.size(), MatrixResizeType::kUndefined);
			CopyFromVec(other);
		}
		Vector(const Vector& other) {
			Resize(other.m_size, MatrixResizeType::kUndefined);
			CopyFromVec(other);
		}
		Vector(Vector&& other) noexcept {
			m_size = other.m_size;
			m_cap = other.m_cap;
			m_data = other.m_data;
			other.m_data = nullptr;
			other.m_size = 0;
			other.m_cap = 0;
		}

		size_t capacity() const noexcept { return m_cap; }
		void Resize(size_t size, MatrixResizeType resize = MatrixResizeType::kSetZero);
		~Vector() noexcept;

		Vector& operator=(const Vector& other);
		Vector& operator=(const VectorBase& other);
		Vector& operator=(Vector&& other) noexcept {
			Swap(&other);
			return *this;
		}

		void Read(bool, bool, std::istream*);
		void Read(bool, std::istream*);
		void Swap(Vector* other) noexcept;
		void RemoveElement(size_t index) noexcept;

		static void PrintAllocStats(std::ostream&);
		static void ResetAllocStats();
	};
	class SubVector : public VectorBase {
	public:
		SubVector(const VectorBase& parent, size_t offset, size_t size) noexcept;
		SubVector(const MatrixBase& parent, size_t row) noexcept;
		SubVector(const SubVector& other) noexcept {
			m_data = other.m_data;
			m_size = other.m_size;
		}
	};
	template <size_t N>
	class FixedVector : public VectorBase {
		float m_storage[N];

	public:
		FixedVector() noexcept {
			m_data = m_storage;
		}
		FixedVector(const VectorBase& other) {
			m_data = m_storage;
			Resize(other.size(), MatrixResizeType::kUndefined);
			CopyFromVec(other);
		}
		FixedVector(const FixedVector& other) {
			m_data = m_storage;
			Resize(other.m_size, MatrixResizeType::kUndefined);
			CopyFromVec(other);
		}
		FixedVector(size_t size, MatrixResizeType resize = MatrixResizeType::kSetZero) {
			m_data = m_storage;
			Resize(size, resize);
		}

		constexpr size_t capacity() const noexcept { return N; }
		void Resize(size_t size, MatrixResizeType resize = MatrixResizeType::kSetZero) {
			if (size > N) throw std::invalid_argument("new size exceeds fixed capacity");
			m_size = size;
			if (resize == MatrixResizeType::kSetZero) Set(0.0f);
		}

		FixedVector& operator=(const FixedVector& other) {
			Resize(other.m_size, MatrixResizeType::kUndefined);
			CopyFromVec(other);
			return *this;
		}
		FixedVector& operator=(const VectorBase& other) {
			Resize(other.size(), MatrixResizeType::kUndefined);
			CopyFromVec(other);
			return *this;
		}
	};
} // namespace snowboy