x013.h

Go to the documentation of this file.

#pragma once

#include <array>
#include <cmath>
#include <complex>
#include <gsl/gsl_poly.h>
#include <iostream>
#include <vector>

namespace nmx::apps::x013 {

inline std::ostream &operator<<(std::ostream &os, const gsl_complex &c) {
    return os << "(" << GSL_REAL(c) << "," << GSL_IMAG(c) << ")";
}

template<class T, size_t N>
class Polynom
{
protected:
    // speichere Koeffizienten, Anzahl Grad des Polynoms+1
    std::array<T, N + 1> _c;

public:
    Polynom(std::array<T, N + 1> clst) {
        std::copy(std::begin(clst), std::end(clst), std::begin(_c));
    }

    T c(size_t idx) const {
        //Zugriff mit Index-Überprüfung
        return _c.at(idx);
    }

    auto eval(gsl_complex z) const {
        //komplexe Koeffizienten, komplexe Variable
        if constexpr (std::is_same_v<T, gsl_complex>) {
            return gsl_complex_poly_complex_eval( //
                _c.data(),
                N + 1,
                z);
        } else {
            //reelle Koeffizienten, komplexe Variable
            return gsl_poly_complex_eval(_c.data(), N, z);
        }
    }

    auto eval(double x) const {
        //komplexe Koeffizienten, reelle Variable
        if constexpr (std::is_same_v<T, gsl_complex>) {
            return gsl_complex_poly_complex_eval( //
                _c.data(),
                N + 1,
                gsl_complex{ x, 0 });
        } else {
            //reelle Koeffizienten, reelle Variable
            return gsl_poly_eval(_c.data(), N + 1, x);
        }
    }

    template<class R>
    auto operator()(R x) const {
        return eval(x);
    }

    friend inline std::ostream &operator<<(std::ostream &os, const Polynom &p) {
        os << "{" << p.c(0);
        for (size_t idx = 1; idx < p._c.size(); idx++) {
            os << "," << p.c(idx);
        }
        return os << "}";
    }

    inline constexpr size_t degree() const { return N; }
}; //Polynom

inline void ex1() {
    //Polynom 2 Grades mit reellen Koeffizienten
    Polynom<double, 2> p1{ { 1., 2., 3. } };
    std::cout << "p1=" << p1 << std::endl;
    std::cout << "p1(-0.5)=" << p1(-0.5) << std::endl;
    std::cout << "----------------" << std::endl;
    //Polynom 3 Grades mit reellen Koeffizienten
    Polynom<double, 3> p2{ { 1., -2., 3., 4. } };
    std::cout << "p2=" << p2 << std::endl;
    std::cout << "p2(-0.5)=" << p2(-0.5) << std::endl;
    std::cout << "----------------" << std::endl;
    //Polynom 1 Grades mit komplexen Koeffizienten
    Polynom<gsl_complex, 1> p3{ { gsl_complex{ 1., 1. }, //
                                  gsl_complex{ 2., 2. } } };

    //Ausgabe
    std::cout << "p3=" << p3 << std::endl;
    std::cout << "p3(1)=" << p3(1) << std::endl;
    std::cout << "p3({1,2})=" << p3(gsl_complex{ 1., 2. }) << std::endl;
}

} // namespace nmx::apps::x013