x018.h

Go to the documentation of this file.

#pragma once

#include <array>
#include <chrono>
#include <cmath>
#include <iomanip>
#include <iostream>

namespace nmx::apps::x018 {

template<size_t N = 10>
class Factorial
{
private:
    //reserviere Speicher für n!
    inline static std::array<double, N> _data;
    // Daten berechnet?
    inline static bool _init = false;

public:
    //berechne und speichere n! (Hilfsfunktion)
    inline static void init() {
        if (!_init) {
            _data[0] = 1;
            for (size_t idx = 1; idx < N; idx++) {
                _data[idx] = idx * _data[idx - 1];
            }
            _init = true;
        }
    }

    //Es dürfen keine Instanzen dieser Klasse erzeugt werden
    Factorial() = delete;
    Factorial(const Factorial &) = delete;
    Factorial &operator=(const Factorial &) = delete;

    //berechne n!
    inline static double get(size_t n) { //
        return n < N ? _data[n] : (n * get(n - 1));
    }
};

template<class T = double, size_t N = 15>
class PowerSeries
{
public:
    using Factorial = Factorial<N>;

protected:
    size_t _n;
    //Variable speichert die Potenzen von x
    mutable double xval = 1;

protected:
    inline PowerSeries(size_t n)
        : _n{ n } {
        Factorial::init();
    }

    inline double term(double x, size_t n) const { //
        return static_cast<const T *>(this)->term(x, n);
    }

    inline double sum(double x) const {
        xval = 1;
        double val = 0;
        for (size_t idx = 0; idx < _n + 1; idx++) {
            val += term(x, idx);
        }
        return val;
    }

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

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

class Exp : public PowerSeries<Exp>
{
    friend PowerSeries; //Zugriff auf private Elemente

protected:
    inline double term(double x, size_t n) const { //
        xval *= n == 0 ? 1 : x;
        return xval / Factorial::get(n);
    }

public:
    Exp(size_t n)
        : PowerSeries(n) {}
}; //Exp

class Sin : public PowerSeries<Sin>
{
    friend PowerSeries; //Zugriff auf private Elemente

protected:
    inline double term(double x, size_t n) const { //
        const size_t npw = 2 * n + 1;
        xval *= n == 0 ? x : (x * x);
        return sign(n) * xval / Factorial::get(npw);
    }

public:
    Sin(size_t n)
        : PowerSeries(n) {}
}; //Sin

class Cos : public PowerSeries<Cos>
{
    friend PowerSeries; //Zugriff auf private Elemente

protected:
    inline double term(double x, size_t n) const { //
        const size_t npw = 2 * n;
        xval *= n == 0 ? 1 : (x * x);
        return sign(n) * xval / Factorial::get(npw);
    }

public:
    Cos(size_t n)
        : PowerSeries(n) {}
}; //Cos

inline void ex1() {
    const Exp myexp(5);
    const Sin mysin(5);
    const Cos mycos(5);
    //berechne Funktionswert an dieser Stelle
    const double x0 = 0.2;
    std::cout << myexp(x0) << std::setw(10) << std::exp(x0) << std::endl;
    std::cout << mysin(x0) << std::setw(10) << std::sin(x0) << std::endl;
    std::cout << mycos(x0) << std::setw(10) << std::cos(x0) << std::endl;
}

inline void ex2() {
    using namespace std::chrono;
    constexpr size_t N = 3;
    const Exp myexp(N);
    const Sin mysin(N);
    const Cos mycos(N);
    //berechne Funktionswert an dieser Stelle
    const double x0 = 0.2;

    double y1 = 0.0, y2 = 0.0, y3 = 0.0, y4 = 0.0, y5 = 0.0, y6 = 0.0;

    auto start1 = steady_clock::now();
    for (double idx = 0; idx < 100000; idx++) {
        y1 = std::exp(x0);
        y2 = std::sin(x0);
        y3 = std::cos(x0);
    }
    auto end1 = steady_clock::now();
    auto diff1 = duration<double, std::milli>(end1 - start1).count();

    auto start2 = steady_clock::now();
    for (double idx = 0; idx < 100000; idx++) {
        y4 = myexp(x0);
        y5 = mysin(x0);
        y6 = mycos(x0);
    }
    auto end2 = steady_clock::now();
    auto diff2 = duration<double, std::milli>(end2 - start2).count();

    std::cout << std::setprecision(4) << std::scientific;

    std::cout << "dt1=" << diff1 << " ms" << std::endl;
    std::cout << "dt2=" << diff2 << " ms" << std::endl;
    std::cout << "dt1/dt2=" << diff1 / diff2 << std::endl;
    std::cout << "---------------------------------" << std::endl;
    const size_t w = 15;
    std::cout << "exp(x)" << std::setw(w) << "sin(x)" << std::setw(w) << "cos(x)" << std::endl;
    std::cout << y1 << std::setw(w) << y2 << std::setw(w) << y3 << std::endl;
    std::cout << y4 << std::setw(w) << y5 << std::setw(w) << y6 << std::endl;
}
} // namespace nmx::apps::x018