xvector.h

Go to the documentation of this file.

#pragma once
#include "xerror.h"
#include "xoutput.h"
#include "xdefs.h"
#include "xvector7.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <gsl/gsl_blas.h>
#include <gsl/gsl_linalg.h>
#include <gsl/gsl_vector.h>
#include <initializer_list>
#include <iterator>
#include <numeric>
#include <optional>
#include <vector>

namespace nmx::gsl {

using namespace nmx::gsl::vec;

class Vector;

class VView : public IVBase<VView>,
              public IVCalc<VView>,
              public IVProperties<VView>,
              public IVCalc1<Vector, VView>,
              public IVBlas<VView>

{
private:
    gsl_vector_view _view; //gsl-Struktur

public:
    VView(gsl_vector_view v) { _view = v; }

    VView(size_t dim, double f[]) { //
        _view = gsl_vector_view_array(f, dim);
    }

    inline const gsl_vector *gsl() const { return &_view.vector; }

    inline gsl_vector *gsl() { return &_view.vector; }
}; //VView

} // namespace nmx::gsl

namespace nmx::gsl {

class Vector : public IVBase<Vector>,
               public IVCalc<Vector>,
               public IVStl<Vector>,
               public IVProperties<Vector>,
               public IVCalc1<Vector, Vector>,
               public IVBlas<Vector>,
               public IVMinMax<Vector>
{
public:
    using View = VView; //Synonym

private:
    gsl_vector *_vector = nullptr; // gsl-Struktur

public:
    inline Vector() {}

    inline explicit Vector(size_t dim, double val = 0) {
        //reserviere Speicher
        _vector = gsl_vector_alloc(dim);
        //setze alle Elemente gleich einem vorgegebenen Wert
        gsl_vector_set_all(_vector, val);
    }

    inline Vector(std::initializer_list<double> lst)
        : Vector(lst.size()) {
        std::copy(ALL(lst), begin());
    }

    inline Vector(size_t n, const double f[])
        : Vector(n) {
        std::copy(f, f + n, begin());
    }

    inline Vector(const Vector &v)
        : Vector(v.size()) {
        std::copy(ALL(v), begin());
    }

    inline Vector(Vector &&v) {
        std::swap(_vector, v._vector);
        v._vector = nullptr;
    }

    inline ~Vector() {
        if (_vector != nullptr) {
            gsl_vector_free(_vector);
        }
    }

    inline Vector &operator=(const Vector &v) {
        if (&v != this) {
            if (_vector != nullptr) {
                gsl_vector_free(_vector);
            }
            _vector = gsl_vector_alloc(v.size());
            std::copy(ALL(v), begin());
        }
        return *this;
    }

    inline Vector &operator=(Vector &&v) {
        if (&v != this) {
            if (_vector != nullptr) {
                //gebe alten Speicher frei
                gsl_vector_free(_vector);
                //der Zeiger ist ab jetzt ungültig
                _vector = nullptr;
            }
            //vertausche Zeiger
            std::swap(_vector, v._vector);
        }
        return *this;
    }

    inline const gsl_vector *gsl() const {
        //ist der Zeiger gültig?
        Check::ptr(nmx_msg, _vector);
        return _vector;
    }

    inline gsl_vector *gsl() {
        //ist der Zeiger gültig?
        Check::ptr(nmx_msg, _vector);
        return _vector;
    }

    inline View view(size_t offset, size_t n) {
        return View(gsl_vector_subvector(gsl(), offset, n));
    }

    inline View view(size_t offset, size_t stride, size_t n) {
        return View(gsl_vector_subvector_with_stride(gsl(), //
                                                     offset,
                                                     stride,
                                                     n));
    }

    inline bool empty() const { //
        return _vector != nullptr && size() != 0;
    }

    inline bool is_init() const { return _vector != nullptr; }
}; //Vector

} // namespace nmx::gsl