mat2d.hpp

/**************************************************************************************************
 * Copyright (c) 2023-2025 NWSOFT                                                                 *
 *                                                                                                *
 * Permission is hereby granted, free of charge, to any person obtaining a copy                   *
 * of this software and associated documentation files (the "Software"), to deal                  *
 * in the Software without restriction, including without limitation the rights                   *
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell                      *
 * copies of the Software, and to permit persons to whom the Software is                          *
 * furnished to do so, subject to the following conditions:                                       *
 *                                                                                                *
 * The above copyright notice and this permission notice shall be included in all                 *
 * copies or substantial portions of the Software.                                                *
 *                                                                                                *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR                     *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,                       *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE                    *
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER                         *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,                  *
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE                  *
 * SOFTWARE.                                                                                      *
 **************************************************************************************************/

 
#pragma once
 
#include "steppable/number.hpp"
#include "testing.hpp"
#include "types/point.hpp"
 
#include <cstddef>
#include <string_view>
#include <vector>
 
namespace steppable
{
    template<typename NumberT>
    using MatVec2D = std::vector<std::vector<NumberT>>;
 
    namespace prettyPrint::printers
    {
        std::string ppMatrix(const MatVec2D<Number>& matrix, int endRows = 0);
    } // namespace prettyPrint::printers
 
    namespace __internals::symbols
    {
        constexpr std::string_view MATRIX_LEFT_TOP = "\u23A1";
        constexpr std::string_view MATRIX_LEFT_MIDDLE = "\u23A2";
        constexpr std::string_view MATRIX_LEFT_BOTTOM = "\u23A3";
        constexpr std::string_view MATRIX_RIGHT_TOP = "\u23A4";
        constexpr std::string_view MATRIX_RIGHT_MIDDLE = "\u23A5";
        constexpr std::string_view MATRIX_RIGHT_BOTTOM = "\u23A6";
    } // namespace __internals::symbols

    class Matrix
    {
        size_t _cols; 
        size_t _rows; 
        size_t prec = 10; 
        MatVec2D<Number> data; 

        void _checkIdxSanity(const YXPoint* point) const;

        static void _checkDataSanity(const MatVec2D<Number>& data);

        static MatVec2D<Number> roundOffValues(const MatVec2D<Number>& data, size_t prec);
 
    public:
        [[nodiscard]] Matrix roundOffValues(size_t prec) const;

        Matrix();

        Matrix(size_t rows, size_t cols, const Number& fill = Number("0"));

        Matrix(const MatVec2D<Number>& data, size_t prec = 5);

        template<concepts::Numeric ValueT>
        Matrix(const MatVec2D<ValueT>& data, const size_t prec) :
            _cols(data.front().size()), _rows(data.size()), prec(prec)
        {
            this->data = std::vector(_rows, std::vector(_cols, Number("0")));
            for (size_t i = 0; i < _rows; i++)
                for (size_t j = 0; j < _cols; j++)
                    this->data[i][j] = Number(data[i][j], prec);
        }

        [[nodiscard]] Matrix rref() const;

        [[nodiscard]] Matrix ref() const;

        [[nodiscard]] Number det() const;

        [[nodiscard]] std::string present(int endRows = 0) const;

        static Matrix ones(size_t rows, size_t cols);

        static Matrix zeros(size_t rows, size_t cols);

        static Matrix diag(size_t colsRows, const Number& fill = 1);

        template<concepts::Numeric NumberT>
        static Matrix diag(const size_t colsRows, const NumberT& fill = 0)
        {
            return diag(colsRows, Number(fill));
        }

        auto begin() { return data.begin(); }

        auto end() { return data.end(); }

        [[nodiscard]] Number rank() const;

        [[nodiscard]] Matrix transpose() const;

        Matrix operator+(const Matrix& rhs) const;

        Matrix operator+=(const Matrix& rhs);

        Matrix operator+() const;

        Matrix operator-(const Matrix& rhs) const;

        Matrix operator-=(const Matrix& rhs);

        Matrix operator-() const;

        Matrix operator*(const Number& rhs) const;

        Matrix operator*=(const Number& rhs);

        Matrix operator*(const Matrix& rhs) const;

        Matrix operator*=(const Matrix& rhs);

        Matrix operator^(const Number& times) const;

        Matrix operator^=(const Number& times);

        Matrix operator<<(const Matrix& rhs) const;

        Matrix operator<<=(const Matrix& rhs);

        Matrix operator>>(const Matrix& rhs) const;

        Matrix operator>>=(const Matrix& rhs);

        bool operator==(const Matrix& rhs) const;

        bool operator!=(const Matrix& rhs) const;

        Number& operator[](const YXPoint& point);

        Number operator[](const YXPoint& point) const;

        Matrix operator[](const YX2Points& point) const;

        [[nodiscard]] size_t getRows() const { return _rows; }

        [[nodiscard]] size_t getCols() const { return _cols; }

        [[nodiscard]] MatVec2D<Number> getData() const { return data; }
    };
} // namespace steppable