x039.h

Go to the documentation of this file.

#pragma once

#include "xquad.h"
#include "xdata.h"
#include "xmath.h"
#include "xoutput.h"
#include "xphysics.h"
#include "xtools.h"
#include <gsl/gsl_integration.h>
#include <iostream>
#include <math.h>
#include <stdio.h>

namespace nmx::apps::x039 {

double f(double x, void *params) {
    double alpha = *(double *) params;
    double f = log(alpha * x) / sqrt(x);
    return f;
}

void gslex() {
    //gsl Struktur: Verwaltung von Daten
    gsl_integration_workspace *w = gsl_integration_workspace_alloc(1000);

    //exaktes Ergebnis
    double expected = -4.0;
    //Parameter des Integranden
    double alpha = 1.0;
    //Ausgabewerte der Integrationsroutine
    double result, error;
    //gsl-Funktion(übergibt Integranden an die Integrationsroutine)
    gsl_function F;
    F.function = &f;
    F.params = &alpha;
    //numerische Integration, Integrand hat Singularität
    gsl_integration_qags(&F, 0, 1, 0, 1e-7, 1000, w, &result, &error);
    //Ausgabe der Daten
    printf("result          = % .18f\n", result);
    printf("exact result    = % .18f\n", expected);
    printf("estimated error = % .18f\n", error);
    printf("actual error    = % .18f\n", result - expected);
    printf("intervals       = %zu\n", w->size);

    //Freigabe des workspaces
    gsl_integration_workspace_free(w);
}

static inline auto get_output_stream(const char *name, Format fmt) {
    auto ofs = Output::get_stream("x039", fmt, name);
    return ofs;
}

inline void ex0() {
    //Integrand
    auto fn = [](double x) { return 4.0 / (1 + pow(x, 2)); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //nicht adaptive Integration von fn im Intervall [0,1]
    integral.qng(0, 1);
    //Ausgabe von Ergebnissen
    const double expected = Math::PI;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex1() {
    //Integrand
    auto fn = [](double x) { return log(x) / sqrt(x); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //adaptive Integration von fn (mit Singularitäten)
    //im Intervall [0,1]
    integral.qags(0, 1);
    //Ausgabe
    const double expected = -4;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex2() {
    //Integrand
    auto fn = [](double x) { return exp(-.5 * pow(x, 2)); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //adaptive Integration von fn von -Unendlich bis +Unendlich
    integral.qagi();
    //Ausgabe
    const double expected = 2.5066282746310002;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex3() {
    //Integrand
    auto fn = [](double x) { return exp(-.5 * pow(x, 2)); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //adaptive Integration von fn von 0 bis +Unendlich
    integral.qagiu(0);
    //Ausgabe
    const double expected = 1.2533141373155001;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex4() {
    //Integrand
    auto fn = [](double x) { return exp(-.5 * pow(x, 2)); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //adaptive Integration von fn von -Unendlich bis 0
    integral.qagil(0);
    //Ausgabe
    const double expected = 1.2533141373155001;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex5() {
    //Integrand
    auto fn = [](double x) { return exp(-.5 * pow(x, 2)); };

    //gsl-Klasse
    gsl::CQUADIntegral integral(fn);
    integral.apply(2, 5);

    //Ausgabe
    const double expected = 5.7025405463957006e-2;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

inline void ex6() {
    using Data = Data<5>;
    //Masse
    const auto mass = 10.0;
    //...kommt nach einer Strecke zum Stillstand
    const auto s = 50.0;
    const auto g = gravitation::Earth::g;
    //Datenobjekt zur Speicherung der berechneten Daten
    Data data;
    //Schleife über Werte des Reibungskoeffizienten
    for (auto mu : { 0.1, 0.4, 0.8 }) {
        auto fn = [mu, mass](double x) {
            (void) x;
            return -mu * mass * gravitation::Earth::g;
        };
        // berechne das Integral
        gsl::Integral integral(fn);
        integral.qng(0.0, s);
        const auto v0Exact = sqrt(2 * mu * g * s);
        const auto v0Approx = sqrt(-2.0 / mass * integral.result());
        data += { mass, s, mu, v0Approx, v0Exact };
    }
    //Ausgabe der Daten
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    data.save(ofs, Output::latex);
}

inline void ex7() {
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    const double l = 1.0;
    const double density = 7.7 / 1e-3;

    //Zähler und Nenner
    auto fnnum = [density](double x) { return x * density; };
    auto fnden = [density](double x) {
        (void) x; //avoid warning
        return density;
    };

    //integriere Zähler und Nenner von 0 bis l
    gsl::Integral integralnum(fnnum), integralden(fnden);
    integralnum.qng(0, l);
    integralden.qng(0, l);

    //berechne Ortsvektor und Masse
    const double xcm = integralnum.result() / integralden.result();
    const double m = density * l;

    //Ausgabe
    sout << "mass  =" << m << std::endl;
    sout << "xcm=" << xcm << std::endl;
    sout << "xcm=" << 0.5 * l << " (exact)" << std::endl;
}

inline void ex8() {
    std::ofstream sout = get_output_stream(__func__, Output::terminal);

    //Daten des Halbkreisrings
    const double l = 1;
    const double density = 7.7 / pow(0.1, 3);
    const double radius = l / Math::PI;

    //Zähler der x-Koordinate
    auto fnnumx = [density, radius](double phi) {
        return cos(phi) * density * pow(radius, 2); //
    };

    //Zähler der y-Koordinate
    auto fnnumy = [density, radius](double phi) {
        return sin(phi) * density * pow(radius, 2); //
    };

    // der Nenner
    auto fnden = [density, radius](double x) {
        (void) x; //avoid warning
        return density * radius;
    };

    //Berechne die Integrale
    gsl::Integral integralnumx(fnnumx), integralden(fnden), integralnumy(fnnumy);
    //benötigt epsabs um einen Wert auszugeben.
    integralnumx.qag(0.0, Math::PI, 6, 1e-9);
    integralnumy.qag(0, Math::PI, 6);
    integralden.qag(0, Math::PI, 6);

    //x- und y-Koordinate des Schwerpunktes und Masse
    const double xcm = integralnumx.result() / integralden.result();
    const double ycm = integralnumy.result() / integralden.result();
    const double w = density * l;

    //Ausgabe in Datei
    sout << "w  =" << w << std::endl;
    sout << "xcm=" << xcm << std::endl;
    sout << "ycm=" << ycm << std::endl;
    sout << "xcm=" << 0 << " (exact)" << std::endl;
    sout << "ycm=" << 2 * radius / Math::PI << " (exact)" << std::endl;
}

inline void ex9() {
    using Data = nmx::Data<4>;
    const double mass = 1e3;

    //Funktion über die integriert werden soll
    auto workFn = [](double u) { return 1 / pow(u, 2); };

    //Berechnung des exakten Wertes für das Potential
    auto exactFn = [](double z) { return 1 / z; };

    //Datenobjekt und Ausgabestrom
    Data data;
    std::ofstream ofs = get_output_stream(__func__, Output::latex);

    //Berechne exakten Wert für die potenzielle Energie
    // und das Arbeitsintegral in Einheiten von GM/R
    for (auto u : { 1e1, 1e2, 1e3, 1e4 }) {
        gsl::Integral integral(workFn);
        integral.qagiu(u, 1e-8);
        const auto approxValue = -mass * integral.result();
        const auto exactValue = -mass * exactFn(u);
        const auto error = abs(exactValue - approxValue);
        data += { u, approxValue, exactValue, error };
    }

    //Ausgabe in Datei
    data.save(ofs, Output::latex);
}

inline void ex10() {
    nmx::Data<7> data;
    //Anfangsbedingungen
    const double x0 = 0, v0 = 0;
    const double c1 = 10;
    for (auto c2 : { 1., -3. }) {
        //Beschleunigung
        auto afn = [c1, c2](double t) { //
            return c1 * t + c2 * sqrt(t);
        };
        //Funktionen zur exakten Berechnung von
        // Geschwindigkeit...
        auto vex = [c1, c2, v0](double t) {
            const auto static f1 = 2. / 3.;
            const auto static f2 = 3. / 2.;
            return 0.5 * c1 * pow(t, 2) + f1 * c2 * pow(t, f2) + v0;
        };
        // ... und Ort
        auto xex = [c1, c2, v0, x0](double t) {
            const auto static f1 = 1. / 6.;
            const auto static f2 = 4. / 15.;
            const auto static f3 = 5. / 2.;
            return f1 * c1 * pow(t, 3) //
                   + f2 * c2 * pow(t, f3) + v0 * t + x0;
        };

        // Integrand zur numerischen Berechnung des Ortes
        // berechnet für jedes t intern über numerische Integration
        // die Geschwindigkeit und wird dann zur numerischen
        // Berechnung des Ortes eingesetzt.
        auto vfn = [&afn](double t) {
            gsl::CQUADIntegral integral(afn);
            integral.apply(0, t);
            return integral.result();
        };
        //berechne Daten für t
        for (double tmax : { 10, 20, 30 }) {
            gsl::Integral integral1(afn);
            integral1.qng(v0, tmax, 0, 1e-6);
            gsl::Integral integral2(vfn);
            integral2.qng(x0, tmax, 0, 1e-6);
            data += { c1,
                      c2,
                      tmax,
                      integral1.result(), //
                      integral2.result(),
                      vex(tmax),
                      xex(tmax) };
        }
    }

    //speichere Daten im LaTeX-Format
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    data.save(ofs, Output::latex);
}

inline void ex11() {
    nmx::Data<5> data;

    for (double c1 : { 10, 20 }) {
        for (double c2 : { 0.1, 0.2 }) {
            //Formel zur Berechnung des exakten Werts
            auto fnex = [c1, c2](double v) { //
                return 1 / c2 * log(c1 / (c1 - c2 * v));
            };

            // Integrand des numerischen Integrals
            auto fn = [c1, c2](double v) { //
                return 1 / (c1 - c2 * v);
            };

            //Iteration über die Geschwindigkeiten
            for (double v : { 10, 30 }) {
                gsl::Integral integral(fn);
                integral.qag(0, v, 6, 0, 1e-5);
                data += { c1, c2, v, integral.result(), fnex(v) };
            }
        }
    }

    //Ausgabe in Datei
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    data.save(ofs, Output::latex);
}

inline void ex12() {
    nmx::Data<5> data;
    const double v0 = -6;
    const double m = 2;
    const double F0 = 25, omega = Math::PI / 10;

    auto force = [F0, omega](double t) { //zeitabhängige Kraft
        return F0 * cos(omega * t);
    };

    //exakte Formel für die Geschwindigkeit
    auto vex = [v0, F0, m, omega](double t) { //
        return v0 + F0 / (m * omega) * sin(omega * t);
    };

    for (double t : { 2., 10., 15. }) {
        gsl::Integral integral(force); //numerische Berechnung
        integral.qag(0, t, 6);
        const double vnum = v0 + 1 / m * integral.result();
        data += { t, v0, force(t), vnum, vex(t) };
    }

    //Ausgabe in Datei
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    data.save(ofs, Output::latex);
}

inline void ex13() {
    nmx::Data<5> data;
    const double m = 2;
    const double l0 = 1, v0 = 15;
    const double k = 4;

    auto force = [l0](double x) { //
        return x - l0 * x / sqrt(pow(l0, 2) + pow(x, 2));
    };

    auto vex = [l0, v0, k, m](double x) {
        const static double trm1 = pow(v0, 2);
        const static double trm2 = 2 * k / m;
        const double trm3 = sqrt(pow(l0, 2) + pow(x, 2));
        return sqrt(trm1 - trm2 * (0.5 * pow(x, 2) - l0 * trm3 + pow(l0, 2)));
    };

    auto vnum = [v0, k, m](const auto &intresult) { //
        return sqrt(pow(v0, 2) - 2 * k / m * intresult);
    };

    for (double x : { 1., 2.5, 4. }) {
        gsl::Integral integral(force);
        integral.qng(0, x, 0, 1e-6);
        data += { v0,
                  x,
                  force(x), //
                  vnum(integral.result()),
                  vex(x) };
    }

    //Ausgabe in Datei
    std::ofstream ofs = get_output_stream(__func__, Output::latex);
    ofs << std::setprecision(4);
    data.save(ofs, Output::latex);
}

inline void ex14() {
    //Federkonstante
    const double k = 100;
    //Massen der Blöcke
    const double m1 = 10, m2 = 5;
    //Feder wird um diese Länge gestaucht
    const double l = 20._cm;
    //exakte Formel für die Geschwindigkeit
    auto vex = [k, m1, m2](double x) { //
        return sqrt(k / (m1 + m2)) * x;
    };
    //Integrand
    auto fn = [k, m1, m2](double x) { //
        return k / (m1 + m2) * x;
    };
    //numerische Berechnung des Integrals ohne den Faktor 2
    gsl::Integral integral(fn);
    integral.qng(0, l);
    //Ausgabe in Datei
    std::ofstream ofs = get_output_stream(__func__, Output::terminal);
    ofs << "exact :" << vex(l) << std::endl;
    ofs << "numerical :" << sqrt(2 * integral.result()) << std::endl;
}

inline void ex15() {
    //Integrand
    auto fn = [](double x) { return 1 / sqrt(sin(x)); };
    //gsl-Klasse
    gsl::Integral integral(fn);
    //adaptive integration (mit Singularitäten) im Intervall [0,1]
    integral.qags(0, 1);
    //Ausgabe
    const double expected = 2.0348053;
    std::ofstream sout = get_output_stream(__func__, Output::terminal);
    integral.show_results(sout, expected);
}

template<class T>
inline void show_results(std::ofstream &sout, const T &gslint, double expected) {
    sout << "result         = " << gslint.result() << "\n";
    sout << "exact result   = " << expected << "\n";
    sout << "estimated error= " << gslint.error() << "\n";
    sout << "actual error   = " << abs(gslint.result() - expected) << "\n";
    sout << "intervals      = " << gslint.intervals() << "\n";
}

void gslex_cquad() {
    //gsl Struktur: Verwaltung von Daten
    gsl_integration_cquad_workspace *w = gsl_integration_cquad_workspace_alloc(100);
    //analytisch berechnetes Ergebnis
    double expected = -4;
    //Parameter des Integranden
    double alpha = 1.0;
    //Ausgabewerte der Integrationsroutine
    double result, error;
    //Anzahl der Funktionsauswertungen
    size_t nevals;
    //gsl-Funktion(übergibt Integranden an die Integrationsroutine)
    gsl_function F;
    F.function = &f;
    F.params = &alpha;
    //numerische Integration, Integrand hat Singularität
    gsl_integration_cquad(&F, 0, 1, 0, 1e-7, w, &result, &error, &nevals);
    //Ausgabe der Daten
    printf("result          = % .18f\n", result);
    printf("exact result    = % .18f\n", expected);
    printf("estimated error = % .18f\n", error);
    printf("actual error    = % .18f\n", result - expected);
    printf("intervals       = %zu\n", w->size);

    //Freigabe des workspace
    gsl_integration_cquad_workspace_free(w);
}

} // namespace nmx::apps::x039