mat_1d.h

#ifndef MAT_1D_H
#define MAT_1D_H
 
#ifdef __cplusplus
#include <cassert>
#include <climits>
#include <cstdint>
#include <initializer_list>
#include <iostream>
#include <optional>
#include <vector>
#include "../algorithms/sorting/quick_sort.h"
#endif

template <typename T, size_t SIZE> class Mat1d {
  private:
    T* arr;
    size_t _size;
 
  public:
    explicit Mat1d(std::vector<T> v = {}) : _size(SIZE) {
        arr = new T[_size];
        if (!v.empty()) {
            try {
                if (v.size() != _size) {
                    throw std::logic_error("Initializer array don't have the same size "
                                           "as the constructed array");
                } else {
                    for (size_t i = 0; i < _size; i++) {
                        arr[i] = v[i];
                    }
                }
            } catch (std::logic_error& e) {
                std::cerr << e.what() << '\n';
            }
        }
    }

    explicit Mat1d(std::initializer_list<T> il) : _size(SIZE) {
        arr = new T[_size];
        if (il.size() != _size) {
            throw std::logic_error("Initializer list doesn't have the same size as "
                                   "the constructed array");
        }
        std::copy(il.begin(), il.end(), arr);
    }

    explicit Mat1d(const T val) noexcept : _size(SIZE) {
        arr = new T[_size];
        for (size_t i = 0; i < _size; ++i) {
            arr[i] = val;
        }
    }

    explicit Mat1d(Mat1d& mat) : _size(SIZE) {
        try {
            if (mat.size() != _size) {
                throw std::logic_error("Tried to copy matrices with different sizes");
            }
            this->arr = new T[_size];
            for (size_t i = 0; i < _size; i++) {
                this->arr[i] = mat.arr[i];
            }
        } catch (std::logic_error& e) {
            std::cerr << e.what() << '\n';
        }
    }

    Mat1d& operator=(Mat1d& mat) {
        if (this == &mat) {
            return *(this);
        }
        assert(mat.size() == this->_size);
        for (size_t i = 0; i < _size; i++) {
            this->arr[i] = mat.arr[i];
        }
        return *(this);
    }

    ~Mat1d() { delete[] arr; }

    size_t size() const { return this->_size; }

    typedef T* iterator;
    T* begin() { return &arr[0]; }
    // Iterator begin() { return Iterator(0, _size, arr); }

    T* end() { return &arr[0] + SIZE; }
    // Iterator end() { return Iterator(_size, _size, arr); }

    T& operator[](const size_t index) {
        assert(index < _size);
        return arr[index];
    }

    bool operator==(const Mat1d<T, SIZE>& mat) const {
        if (mat.size() != _size) {
            return false;
        }
 
        for (size_t i = 0; i < _size; i++) {
            if (mat.arr[i] != this->arr[i]) {
                return false;
            }
        }
        return true;
    }

    bool operator!=(const Mat1d<T, SIZE>& mat) const { return !(*this == mat); }

    friend std::ostream& operator<<(std::ostream& out, const Mat1d& mat) {
        out << '[';
        for (size_t i = 0; i < mat.size(); i++) {
            out << mat.arr[i];
            if (i != mat.size() - 1) {
                out << " ";
            }
        }
        out << ']' << '\n';
        return out;
    }
};

template <typename T, size_t SIZE1, size_t SIZE2>
bool operator==(const Mat1d<T, SIZE1>& mat1, const Mat1d<T, SIZE2>& mat2) {
    return false; // Matrices of different sizes are not equal
}
 
template <typename T, size_t SIZE1, size_t SIZE2>
bool operator!=(const Mat1d<T, SIZE1>& mat1, const Mat1d<T, SIZE2>& mat2) {
    return !(mat1 == mat2); // Uses the == operator specialization
}
 
#endif