x015.h

Go to the documentation of this file.

#pragma once

#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
#include <xmath.h>

namespace nmx::apps::x015 {

class PowerSeries
{
protected:
    //Anzahl der Terme des Polynoms
    size_t _n;

    //Funktion : berechnet einzelne Terme
    std::function<double(size_t, double)> _fn;

    //Zwischenspeicher n!
    inline static std::vector<double> cache;

    inline PowerSeries(size_t n)
        : _n{ n } {}

    inline double sum(double x) const {
        double val = 0;
        for (size_t idx = 0; idx <= _n + 1; idx++) {
            //wende das intern gespeicherte Funktionsobjekt an
            val += _fn(idx, x);
        }
        return val;
    }

    static inline double factorial(size_t n) {
        //maximale Anzahl der gespeicherten Werte für n!
        const size_t cachesize = 11;
        if (cache.empty()) {
            //n! wird berechnet und gespeichert
            double val = 1;
            cache.push_back(val);
            for (size_t idx = 1; idx < cachesize; idx++) {
                val *= idx;
                cache.push_back(val);
            }
        }
        if (n < cache.size()) {
            return cache[n]; //lese gespeicherten Wert
        }
        //Stirling-Formel
        return sqrt(2 * Math::PI * n) * std::pow(n / Math::E, n);
    }

    static inline int sign(size_t n) { return n % 2 == 0 ? 1 : -1; }

public:
    inline double operator()(double x) const { return sum(x); }
}; //PowerSeries

class Exp : public PowerSeries
{
private:
    //speichere den zuletzt berechneten Term: x^n
    double _powterm;

public:
    Exp(size_t n)
        : PowerSeries(n) {
        //lambda-Funktion ruft Elementfunktion der Klasse auf
        _fn = [this](size_t np, double x) { return term(np, x); };
    }

    double term(size_t n, double x) {
        _powterm = n == 0 ? 1 : _powterm *= x;
        return _powterm / factorial(n);
    }
}; //Exp

class Sin : public PowerSeries
{
private:
    double _powterm;

public:
    Sin(size_t n)
        : PowerSeries(n) {
        _fn = [this](size_t np, double x) { return term(np, x); };
    }

    double term(size_t n, double x) {
        size_t npow = 2 * n + 1;
        _powterm = n == 0 ? x : (_powterm *= x * x);
        return sign(n) / factorial(npow) * _powterm;
    }
}; //Sin

class Cos : public PowerSeries
{
private:
    double _powterm;

public:
    Cos(size_t n)
        : PowerSeries(n) {
        _fn = [this](size_t np, double x) { return term(np, x); };
    }

    double term(size_t n, double x) {
        size_t npow = 2 * n;
        _powterm = n == 0 ? 1 : (_powterm *= x * x);
        return sign(n) / factorial(npow) * _powterm;
    }
}; //Cos

inline void ex1() {
    const size_t nmax = 10; //Anzahl der Terme

    const Exp myexp(nmax);
    const Sin mysin(nmax);
    const Cos mycos(nmax);

    double x0 = 0.25;

    //Berechnung und Ausgabe
    std::cout << std::setprecision(7) << std::scientific;
    std::cout << "N=" << nmax << std::endl;
    std::cout << "x0=" << x0 << std::endl;
    std::cout << myexp(x0) << "\t" << std::exp(x0) << std::endl;
    std::cout << mysin(x0) << "\t" << std::sin(x0) << std::endl;
    std::cout << mycos(x0) << "\t" << std::cos(x0) << std::endl;
}

} // namespace nmx::apps::x015