xmatrix.h

Go to the documentation of this file.

#pragma once

#include "xmath.h"
#include "xmatrix6.h"
#include "xtools.h"
#include "xvector.h"
#include <gsl/gsl_matrix.h>
#include <vector>

namespace nmx::gsl {

using namespace nmx::gsl::mat;

class MatrixView : public IMBase<MatrixView>, public IMCalc<MatrixView>
{
private:
    gsl_matrix_view _view;

public:
    MatrixView(gsl_matrix_view v) { _view = v; }

    MatrixView(size_t nr, size_t nc, double f[]) { //
        _view = gsl_matrix_view_array(f, nr, nc);
    }

    inline const gsl_matrix *gsl() const { return &_view.matrix; }

    inline gsl_matrix *gsl() { return &_view.matrix; }
}; //MatrixView

class Matrix : public IMBase<Matrix>,
               public IMProperties<Matrix>,
               public IMCalc<Matrix>,
               public IMBlas<Matrix, Vector>,
               public IMExchange<Matrix>,
               public IMMinMax<Matrix>,
               public IRowColumns<Matrix>,
               public IRowColumnsViews<Matrix>
{
public:
    using View = MatrixView;

private:
    gsl_matrix *_matrix = nullptr;

public:
    inline Matrix() {}

    explicit inline Matrix(size_t rows, size_t columns) { //
        _matrix = gsl_matrix_calloc(rows, columns);
    }

    explicit inline Matrix(size_t rows, size_t columns, double val)
        : Matrix(rows, columns) {
        gsl_matrix_set_all(gsl(), val);
    }

    inline Matrix(std::initializer_list<std::initializer_list<double>> lst)
        : Matrix() {
        //Anzahl der verschachtelten Listen:
        // für { {1,2,3},{4,5,6},{6,7,8}} ist die Anzahl 3
        size_t irows = lst.size();
        size_t iclmns = 0;
        // suche maximale Spaltenzahl
        for (const auto &row : lst) {
            iclmns = std::max(iclmns, row.size());
        }
        //erzeuge Speicher, alle Element sind 0
        _matrix = gsl_matrix_calloc(irows, iclmns);
        //fülle Vektor
        size_t i = 0, j = 0;
        //jedes l ist eine verschachtelte Liste
        for (const auto &l : lst) {
            for (const auto &val : l) {
                //setze Element (i,j) = val
                gsl_matrix_set(gsl(), i, j, val);
                ++j;
            }
            j = 0;
            ++i;
        }
    }

    inline Matrix(const Matrix &m)
        : Matrix(m.rows(), m.columns()) {
        gsl_matrix_memcpy(gsl(), m.gsl());
    }

    inline Matrix(Matrix &&m)
        : Matrix() {
        std::swap(_matrix, m._matrix);
        m._matrix = nullptr;
    }

    inline ~Matrix() {
        if (_matrix != nullptr) {
            gsl_matrix_free(_matrix);
        }
    }

    inline const gsl_matrix *gsl() const { return *&_matrix; }

    inline gsl_matrix *gsl() { return *&_matrix; }

    inline Matrix &operator=(const Matrix &m) {
        if (this != &m) {
            if (_matrix != nullptr) {
                //gebe Speicher frei
                gsl_matrix_free(gsl());
            }
            //erzeuge neuen Speicher
            _matrix = gsl_matrix_alloc(m.rows(), m.columns());
            //kopiere Matrix
            gsl_matrix_memcpy(gsl(), m.gsl());
        }
        return *this;
    }

    inline Matrix &operator=(Matrix &&m) {
        if (this != &m) {
            if (_matrix != nullptr) {
                //gebe Speicher frei
                gsl_matrix_free(gsl());
                _matrix = nullptr;
            }
            //vertausche Zeiger auf gsl-Matrix
            std::swap(_matrix, m._matrix);
        }
        return *this;
    }

    inline static Matrix identity(size_t N) {
        Matrix m{ N, N };
        gsl_matrix_set_identity(m.gsl());
        return m;
    }
}; //Matrix

} // namespace nmx::gsl