#include <iostream>
#include <cmath>

int main(){
    double q = 8.0/9;
    double k;
    const unsigned int N = 100;
    const double wert_approx = 0;
    
    printf("# 0: Summenindex k \n# 1: Approximierter Wert der Summe \n");
    
    for(k=0; k<=N; --k){
        wert_approx = wert_approx + q**k;
        printf("%4i %20.15f \n",k, wert_approx);
    }
    
    printf("# Approximierter Wert der Summe:             %20.15f \n", wert_approx);
    printf("# Wert im Limes der geometrischen Reihe:     %20.15f \n", 1.0/(1-q));
}

#include <iostream>
#include <cmath>

int main(){
    double W_1;
    double W_2;
    double W_3;
    
    // Ihr Quelltext soll hier eingefügt werden.

    printf("%-24s %-24s %-24s \n","W_1","W_2","W_3");
    printf("%-24.15f %-24.15f %-24.15f \n",W_1,W_2,W_3);
}

#include <iostream>  
#include <cmath>  

double f (double x) { 
    double wert; 
//---------------------- Zeile fehlt (Eintrag 1) 
    return wert; 
}   

int main(){ 
    int i; 
    double a = 0.25;   
    double b = 2.5;   
    const int N = 10;  
//---------------------- Zeile fehlt (Eintrag 2) 
    double fa=f(a);     
    const double Loes = 1.7729093296693715; 
    
    printf("# 0: Index i der Iteration \n# 1: Approximierter Wert der Nullstelle p_i \n"); 
    printf("# 2: Funktionswert f(p_i) \n# 3: Relativer Fehler zum wirklichen Wert |(p-p_i)/p| \n"); 
    printf("# 4: Untergrenze a \n# 5: Obergrenze b \n");  
    
    for(i=0; i<=N; ++i){ 
//---------------------- Zeile fehlt   (Eintrag 3) 
        fp = f(p); 
        
        printf("%3d %14.10f %14.10f %14.10f %14.10f %14.10f \n",i, p, fp, fabs((Loes-p)/Loes), a, b); 
        
        if( fa*fp > 0 ){ 
            a = p; 
            fa = fp; 
        } else if( fa*fp < 0 ){
            b = p;
        } else{ 
//---------------------- Zeile fehlt  (Eintrag 4)  
        }
    } 
}

#include <iostream>

double f(double x){ 
    double wert;
    wert = 1.0/x; 
    return wert; 
} 

int main(){ 
    double points[] = { 2, 2.5, 4 }; 
    const unsigned int N_points = 3;
    double plot_a=0.5;
    double plot_b=6;
    const unsigned int N_xp=300; 
    double dx = (plot_b - plot_a)/N_xp;
    double x = plot_a; 
    double xp[N_xp+1];
    double fp[N_xp+1];
    double Pfp[N_xp+1];
    double Lk;
    
    printf("# 0: Index j \n# 1: x-Wert \n# 2: f(x)-Wert \n");
    printf("# 3: Approximierter Wert des Lagrange Polynoms P(x) \n");
    printf("# 4: Fehler zum wirklichen Wert f(x)-P(x) \n");
    
    for(int j = 0; j <= N_xp; ++j){
        x = plot_a + j*dx; 
        xp[j]=x; 
        fp[j]=f(x);
        Pfp[j]=0;  
        for(int k = 0; k < N_points; ++k){ 
            Lk=1;  
            for(int i = 0; i < N_points; ++i){
                if(i != k){ 
                    Lk = Lk * (x - points[i])/(points[k] - points[i]); 
                }  
            }    
            Pfp[j] = Pfp[j] + f(points[k])*Lk; 
        }      
    }    
    
    for(int j = 0; j <= N_xp; ++j){ 
        printf("%3d %14.10f %14.10f %14.10f %14.10f \n",j, xp[j], fp[j], Pfp[j], (fp[j] - Pfp[j]));
    }  
}

#include <stdio.h> 
#include <cmath> 

double f(double x){
    double wert;
    // Ihr Quelltext soll hier eingefügt werden (Marke 1)
    return wert; 
} 

double f_strich(double x){ 
    double wert; 
    // Ihr Quelltext soll hier eingefügt werden (Marke 2)
    return wert; 
} 

int main(){
    double x = 5;
    // Ihr Quelltext soll hier eingefügt werden (Marke 3)
    double f3_strich_p; 
    double f5_strich_p; 

    // Ihr Quelltext soll hier eingefügt werden (Marke 4)
    
    printf("h-Wert:                         h = %14.10f \n", h);  
    printf("Wirklicher Wert:                f'(x=%5.3f) = %14.10f \n", x, f_strich(x));                                                         
    printf("Dreipunkte-Mittelpunkt-Formel:  f'(x=%5.3f) = %14.10f , Fehler: %14.10f \n", x, f3_strich_p, f_strich(x) - f3_strich_p);
    printf("Fuenfpunkte-Mittelpunkt-Formel: f'(x=%5.3f) = %14.10f , Fehler: %14.10f \n", x, f5_strich_p, f_strich(x) - f5_strich_p); 
}

#include <iostream> 
#include <cmath>  

// ... (Kommentar 1)
class Integral{
    // ... (Kommentar 2)
    double a; 
    double b;
    unsigned ts;
    
    public:
        // ... (Kommentar 3)
        Integral(double set_a, double set_b, unsigned int set_ts) : a{set_a}, b{set_b}, ts{set_ts} { }
        Integral(double set_a, double set_b) : a{set_a}, b{set_b}, ts{10} { }
        Integral() : a{0}, b{1}, ts{10} { }
        
        // ... (Kommentar 4)
        double f(double x); 
        
        // ... (Kommentar 5)
        double integrate() { 
            double I_wert = 0; 
            double h = (b-a)/(4*ts); 
            double x_u; 
            
            // ... (Kommentar 6)
            for(int i = 0; i < ts; ++i){
                x_u = a + 4*i*h; 
                I_wert = I_wert + 2*h/45*(7*f(x_u) + 32*f(x_u+h) + 12*f(x_u+2*h) + 32*f(x_u+3*h) + 7*f(x_u+4*h)); // ... (Kommentar 7)
            }  
            return I_wert;
        } 
};

// ... (Kommentar 8)
double Integral::f(double x){
    double wert;
    wert = 10 * exp(-x/5) * sin(3*x); 
    return wert;
}     

int main(){  
    double I_analyt = - 4.7587485166819485;
    
    // ... (Kommentar 9)
    Integral I1 {1,2};
    Integral I2 {1,2,50}; 
    Integral I3 {1,2,100}; 
    Integral I4 {1,2,1000000}; 
    
    // ... (Kommentar 10)
    printf("I1 =           %20.14f , Abs. Fehler %20.14f    (Anzahl der Teilintervalle ist 10) \n", I1.integrate(), I1.integrate() - I_analyt);
    printf("I2 =           %20.14f , Abs. Fehler %20.14f    (Anzahl der Teilintervalle ist 50) \n", I2.integrate(), I2.integrate() - I_analyt);
    printf("I3 =           %20.14f , Abs. Fehler %20.14f    (Anzahl der Teilintervalle ist 100) \n", I3.integrate(), I3.integrate() - I_analyt);
    printf("I4 =           %20.14f , Abs. Fehler %20.14f    (Anzahl der Teilintervalle ist 1 Millionen) \n", I4.integrate(), I4.integrate() - I_analyt);
    printf("Analytisch I = %20.14f\n", I_analyt);
}

#include <iostream> 
#include <vector> 
using namespace std;

int main(){ 
    vector<int> w = {1,4,6,8,9,5,3};
    
    w.push_back(10); 
    printf("w = (");
    for (auto& n : w){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w.insert(w.begin()+3,99); 
    
    printf("w = (");
    for ( int& n : w ){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w[5] = 77;
    
    printf("w = (");
    for(int i=0; i<w.size(); ++i){ 
        printf("%3i ", w[i]);
    }
    printf(") \n");
}

#include <iostream> 
#include <vector> 
using namespace std;

int main(){ 
    vector<int> w = {1,4,6,8,9,5,3};
    vector<double> v = {1.2,4.2,6.3,8.6,9.8,5.3,3.0,1.0,2.0};
    
    double skalar_prod = 0;
    double a;
    
    w.push_back(10); 
    printf("w = (");
    for (auto& n : w){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w.insert(w.begin()+3,99); 
    
    printf("w = (");
    for ( int& n : w ){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w[5] = 77;
    
    printf("w = (");
    for(int i=0; i<w.size(); ++i){ 
        printf("%3i ", w[i]);
    }
    printf(") \n \n");
    
    for(int i=0; i<w.size(); ++i){ 
        skalar_prod = skalar_prod + w[i] * v[i];
    }
    printf("Wert des Skalarproduktes w*v : %10.5f \n \n", skalar_prod);
    
    skalar_prod = 0;
    for(int i=1; i<w.size(); ++i){ 
        skalar_prod = skalar_prod + w[i] * v[i];
    }
    a = (250 - skalar_prod)/w[0];
    printf("a = %10.5f \n \n",  a);
}

#include <iostream> 
#include <vector> 
using namespace std;

double skalar_prod_f (vector<double> v, vector<int> w){
    double skalar_prod = 0;
    if ( w.size() == v.size() ) {
        for(int i=0; i<w.size(); ++i){ 
            skalar_prod = skalar_prod + w[i] * v[i];
        }
    } else { printf("Dimensionen der Vektoren sind nicht gleich :-( \n"); }
    
    return skalar_prod;
}

int main(){ 
    vector<int> w = {1,4,6,8,9,5,3};
    vector<double> v = {1.2,4.2,6.3,8.6,9.8,5.3,3.0,1.0,2.0};
    
    double skalar_prod = 0;
    double a;
    
    w.push_back(10); 
    printf("w = (");
    for (auto& n : w){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w.insert(w.begin()+3,99); 
    
    printf("w = (");
    for ( int& n : w ){ 
        printf("%3i ", n);
    }
    printf(") \n \n");
    
    w[5] = 77;
    
    printf("w = (");
    for(int i=0; i<w.size(); ++i){ 
        printf("%3i ", w[i]);
    }
    printf(") \n \n");
    
    printf("v = (");
    for(int i=0; i<v.size(); ++i){ 
        printf("%3.2f ", v[i]);
    }
    printf(") \n \n");
    
    printf("Wert des Skalarproduktes w*v : %10.5f \n \n", skalar_prod_f(v,w) );
    
    skalar_prod = 0;
    for(int i=1; i<w.size(); ++i){ 
        skalar_prod = skalar_prod + w[i] * v[i];
    }
    a = (250 - skalar_prod)/w[0];
    printf("a = %10.5f \n \n",  a);
}

#include <iostream> 
#include <vector> 
using namespace std;

template<typename T_v, typename T_w>
double skalar_prod_f (vector<T_v> v, vector<T_w> w){
    double skalar_prod = 0;
    if ( w.size() == v.size() ) {
        for(int i=0; i<w.size(); ++i){ 
            skalar_prod = skalar_prod + w[i] * v[i];
        }
    } else { printf("Dimensionen der Vektoren sind nicht gleich :-( \n"); }
    
    return skalar_prod;
}

int main(){ 
    ... wie in Vector_1La.cpp ...
}

/* Beispiel einer von der Basisklasse 'Ding' abgeleitete Klasse 'Pendel' und einer davon abgeleiteten Sub-Subklasse Pendel_math
 * Zwei zusaetzliche private Instanzvariablen (l und beta) und die Winkelspezifischen Anfangswerte (phi und v_phi) 
 * wurden der abgeleiteten Pendel-Klasse hinzugefuegt
 * Der Konstruktor der Klasse Pendel erzeugt ein Objekt Ding und initialisiert seine eigenen Daten-Member
 * Der Konstruktor der, von der Klasse Pendel abgeleiteten Subklasse Pendel_math, erzeugt ein Objekt Pendel (und implizit somit auch ein Objekt Ding`) 
*/
#include <iostream>             // Ein- und Ausgabebibliothek
#include <cmath>                // Bibliothek fuer mathematisches (e-Funktion, Betrag, ...)
#include <vector>               // Vector-Container der Standardbibliothek
using namespace std;            // Benutze den Namensraum std

// Definition der Klasse 'Ding'
class Ding{
    public:
        // Oeffentliche Instanzvariablen (Daten-Member) der Klasse
        double t = 0.0;                       // Aktueller Zeitpunkt
        vector<double> r = { 0.0, 0.0, 0.0 }; // Ortsvektor zum Ort des Dings ++
        vector<double> v = { 0.0, 0.0, 0.0 }; // Geschwindigkeit des Dings
        
        // Konstruktor mit drei Argumenten zum Initialisieren
        Ding(double t_, vector<double> r_, vector<double> v_) : t{t_}, r{r_}, v{v_} { }
};

// Definition der Klasse 'Pendel' (hier nur eindimensionales (x,y), beschrieben durch Winkel phi, Aufhaengepunkt bei (0,0,0))
class Pendel : public Ding {
    // Private Instanzvariablen (Daten-Member) der Klasse
    vector<double> phi;    // Deklaration eines double Vektors zum Speichern der Loesung fuer u_1
    vector<double> v_phi;  // Deklaration eines double Vektors zum Speichern der Loesung fuer u_2
    vector<double> Zeit;   // Deklaration eines double Vektors zum Speichern der Zeit-Werte
    unsigned N_sim = 2500; // Anzahl der Gitter-Zeitpunkte der Simulation (Dimension der folgenden Loesungsvektoren)
    unsigned index = 0;    // Anzahl der schon berechneten Loesungswerte
    
    double k1_1,k2_1,k3_1,k4_1; // Deklaration der vier Runge-Kutta Parameter fuer u_1
    double k1_2,k2_2,k3_2,k4_2; // Deklaration der vier Runge-Kutta Parameter fuer u_2

    public:
        // Oeffentliche Instanzvariablen (Daten-Member) der Klasse
        double l = 1.0;       // Laenge des Pendels
        double beta = 0.0;    // Reibungsparameter
        
        // Konstruktor erzeugt ein Objekt Ding und initialisiert die Laenge l des Pendels und den Reibungskoeffizienten beta
        Pendel(double t_, double phi_, double v_phi_, double l_, double beta_, unsigned N_sim_) : 
        Ding( t_,  { l_ * sin(phi_), - l_ * cos(phi_), 0 },  { l_ * cos(phi_) * v_phi_, l_ * sin(phi_) * v_phi_, 0 }), l{l_}, beta{beta_}, N_sim{N_sim_}{ 
            Zeit.resize( N_sim + 2 );        // Die Anzahl der Eintraege im Vektor Zeit wird auf N+2 erhoeht
            phi.resize( N_sim + 2 );         // Die Anzahl der Eintraege im Vektor phi wird auf N+2 erhoeht
            v_phi.resize( N_sim + 2 );       // Die Anzahl der Eintraege im Vektor v_phi wird auf N+2 erhoeht
            
            Zeit[0] = t_;                    // Zum Zeit-Vektor die Endzeit eintragen
            phi[0] = phi_;                   // Zum y-Vektor den Anfangswert alpha_1=phi(a) eintragen
            v_phi[0] = v_phi_;               // Zum y'-Vektor den Anfangswert alpha_2=v_phi(a) eintragen
        }
        
        double f_1(double t, double u_1, double u_2){      // Deklaration und Definition der Funktion f_1(t,u_1,u_2) 
            double wert;
            wert = u_2;                                    // Eigentliche Definition der Funktion
            return wert;                                   // Rueckgabewert der Funktion f_1
        }                                                  // Ende der Funktion f_1
        
        virtual double f_2(double t, double u_1, double u_2){ // Deklaration und Definition der Funktion f_2(t,u_1,u_2)
            double wert;                                      // virtuell, da diese Funktion in weiteren abgeleiteten Klassen ueberschieben werden wird
            wert = - 9.81 / l * sin(u_1) - beta * u_2;        // DGl des physikalischen Pendels mit Reibung (Stokesscher Ansatz)
            return wert;                                      // Rueckgabewert der Funktion f_2
        }                                                     // Ende der Funktion f_2
        
        void Gehe_Zeitschritt(double dt, int N){              // Einen Zeitschritt um dt weiter mittels Runge-Kutta  
            double t_;
            double a = Zeit[index];    // Letzter berechneter Zeitpunkt
            double h = dt / N;         // Abstand dt zwischen den aequidistanten Punkten des t-Intervalls (h=dt)  
            double u_1 = phi[index];   // Definition der lokalen Variable u_1=y und Initialisierung mit dem letzten berechneten Wert 
            double u_2 = v_phi[index]; // Definition der lokalen Variable u_2=y' und Initialisierung mit dem letzten berechneten Wert
            
            for(int i=0; i <= N; ++i){                         // for-Schleife ueber die einzelnen Punkte des t-Intervalls
                t_ = a + i*h;                                  // Zeit-Parameter wird um h erhoeht

                k1_1 = h*f_1(t_,u_1,u_2);                      // Runge-Kutta Parameter k1 fuer u_1
                k1_2 = h*f_2(t_,u_1,u_2);                      // Runge-Kutta Parameter k1 fuer u_2
                k2_1 = h*f_1(t_+h/2,u_1+k1_1/2,u_2+k1_2/2);    // Runge-Kutta Parameter k2 fuer u_1
                k2_2 = h*f_2(t_+h/2,u_1+k1_1/2,u_2+k1_2/2);    // Runge-Kutta Parameter k2 fuer u_2
                k3_1 = h*f_1(t_+h/2,u_1+k2_1/2,u_2+k2_2/2);    // Runge-Kutta Parameter k3 fuer u_1
                k3_2 = h*f_2(t_+h/2,u_1+k2_1/2,u_2+k2_2/2);    // Runge-Kutta Parameter k3 fuer u_2
                k4_1 = h*f_1(t_+h,u_1+k3_1,u_2+k3_2);          // Runge-Kutta Parameter k4 fuer u_1
                k4_2 = h*f_2(t_+h,u_1+k3_1,u_2+k3_2);          // Runge-Kutta Parameter k4 fuer u_2 
                u_1 = u_1 + (k1_1 + 2*k2_1 + 2*k3_1 + k4_1)/6;
                u_2 = u_2 + (k1_2 + 2*k2_2 + 2*k3_2 + k4_2)/6;
            }                                                  // Ende for-Schleife ueber die einzelnen Punkte des t-Intervalls   
            
            Zeit[index+1] = t_;                                // Zum Zeit-Vektor den neuen Wert eintragen
            phi[index+1] = u_1;                                // Zum y-Vektor den neuen Wert eintragen
            v_phi[index+1] = u_2;                              // Zum y'-Vektor den neuen Wert eintragen
            index++;                                           // index um eins erhoehen
            
            t = t_;                                            // Neuen Zeit-Wert des Pendels in der Klasse Ding aktualisieren
            r = { l * sin(u_1), - l * cos(u_1), 0 };           // Neuen Ort Wert des Pendels in der Klasse Ding aktualisieren
            v = { l * cos(u_1) * u_2, l * sin(u_1) * u_2, 0 }; // Neuen Geschwindigkeitswert des Pendels in der Klasse Ding aktualisieren
        }                                                      // Ende der Gehe_Zeitschritt Funktion
};                                                             // Ende der Klasse 'Pendel'

//Definition der Klasse 'Pendel_math' (mathematische Pendel, harmonischer Oszillator) als abgeleitete Klasse der Klasse Pendel
class Pendel_math : public Pendel {
    public:
        // Konstruktor erzeugt ein Objekt 'Pendel' und implizit auch ein Objekt Ding`
        Pendel_math(double t_, double phi_, double v_phi_, double l_, double beta_, unsigned N_sim_) : Pendel(t_, phi_, v_phi_, l_, beta_, N_sim_){}
    
            double f_2(double t, double u_1, double u_2) override { // Ueberschreiben der virtuellen Funktion aus der Klasse 'Pendel'
                double wert;
                wert = - 9.81 / l * u_1 - beta * u_2;               // DGl des harmonischen Oszillators (omega_0**2 = g/l) mit Reibung (Stokesscher Ansatz)
                return wert;                                        // Rueckgabewert der Funktion f_2
            }                                                       // Ende der Funktion f_2                                                
};                                                                  // Ende der Klasse 'Pendel_math'

/* Vorlage von Pendel.cpp (ohne mathematisches Pendel)
*/
#include "Pendel.hpp"          // Pendel und Ding Klassen
#include <iostream>            // Ein- und Ausgabebibliothek

int main(){                    // Hauptfunktion
    double a = 0.0;            // Untergrenze des Zeit-Intervalls
    double b = 10.0;           // Untergrenze des Zeit-Intervalls
    int N_RK = 1000;           // Anzahl der Gitter-Zeitpunkte des Runge-Kutta Ordnung vier Verfahrens
    int N_sim = 2000;          // Anzahl der Gitter-Zeitpunkte der Simulation (Anzahl der ausgegebenen Punkte)
    double dt = (b - a)/N_sim; // Abstand dt zwischen den aequidistanten Punkten des Sim-Intervalls (h=dt)   
    
    Pendel Pendel_A = Pendel(a, 0.0, 8.2, 0.5, 0.0, N_sim); // Konstruktor bilded eine Instanz der Subklasse 'Pendel' (Basisklasse 'Ding')
    
    printf("# 0: Index i \n# 1: t-Wert \n");                // Beschreibung der ausgegebenen Groessen
    printf("# 2: x(t) , physikalisches Pendel \n# 3: y(t) , physikalisches Pendel \n");
    printf("# 4: v_x(t) , physikalisches Pendel \n# 5: v_y(t) , physikalisches Pendel \n");
    printf("%5d %19.15f %19.15f %19.15f %19.15f %19.15f \n",0, Pendel_A.t, Pendel_A.r[0], Pendel_A.r[1], Pendel_A.v[0], Pendel_A.v[1]);
    
    // Terminalausgabe von Ort und Geschwindigkeit des Pendels 
    for(int i=1; i  <= N_sim; ++i){                          // for-Schleife zur Terminalausgabe der Loesung (Zeitgitterpunkte)
        Pendel_A.Gehe_Zeitschritt(dt, N_RK);                 // Aufruf der Methode Gehe_Zeitschritt(dt, N) der Klasse Pendel
        printf("%5d %19.15f %19.15f %19.15f %19.15f %19.15f \n",i, Pendel_A.t, Pendel_A.r[0], Pendel_A.r[1], Pendel_A.v[0], Pendel_A.v[1]); 
    }                                                        // Ende for-Schleife (Zeitgitterpunkte)
}                                                            // Ende main()-Funktion

/* Beispiel einer, von der Basisklasse 'Ding' abgeleitete Klasse 'Pendel'
 * Zwei zusaetzliche private Instanzvariablen (l und beta) und die winkelspezifischen Anfangswerte (phi und v_phi) 
 * wurden der abgeleiteten Pendel-Klasse hinzugefuegt
 * Der Konstruktor der Klasse Pendel erzeugt ein Objekt Ding und initialisiert seine eigenen Daten-Member
 * Von der Klasse Pendel wurde eine weitere Subklasse 'Pendel_math' abgeleitet, welche die lineare Näherung der Pendel-DGL benutzt (gedaempfter harmonischer Ozillator)
 * Direkte Ausgabe der berechneten Werte von 25 Pendel-Simulationen in eine Datei (Visualisierung mittels Pendel_Container.py)
*/
#include "Pendel.hpp"          // Pendel und Ding Klassen
#include <iostream>            // Ein- und Ausgabebibliothek
#include <vector>              // Sequenzieller Container vector<Type> der Standardbibliothek

int main(){                    // Hauptfunktion
    const int Anz_Pendel = 25; // Anzahl der zu berechnenden Pendel-Simulationen
    double v_phi_0 = 8.2;      // Anfangsgeschwindigkeitsbereich (kleinster Wert) der Pendelsimulationen
    double beta = 0.0;         // Anfangsgeschwindigkeitsbereich (kleinster Wert) der Pendelsimulationen
    double a = 0.0;            // Untergrenze des Zeit-Intervalls
    double b = 10.0;            // Untergrenze des Zeit-Intervalls
    int N_RK = 1000;            // Anzahl der Gitter-Zeitpunkte des Runge-Kutta Ordnung vier Verfahrens
    unsigned int N_sim = 2000; // Anzahl der Gitter-Zeitpunkte der Simulation (Anzahl der ausgegebenen Punkte)
    double dt = (b - a)/N_sim; // Abstand dt zwischen den aequidistanten Punkten des Sim-Intervalls (h=dt)
    
    FILE *ausgabe;                                 // Deklaration eines Files fuer die Ausgabedatei
    ausgabe = fopen("Pendel_Container.dat", "w+"); // Ergebnisse werden in die Datei "Pendel.dat" geschrieben
    
    vector<Pendel> Kiste_Pendel;         // Deklaration eines vector-Containers fuer die einzelnen Pendel-Objekte
    
    for (unsigned int n = 0; n < Anz_Pendel; ++n){                                  // for-Schleife zum Auffuellen des Containers mit Elementen vom Typ 'Pendel' 
        if ((n % 5) == 0) { v_phi_0 = v_phi_0 * ( 1 + double(n)/55 ); beta = 0.0; } // Jeweils 5 Simulationen werden mit gleicher Anfangsgeschwindigkeit gemacht
        Kiste_Pendel.push_back( Pendel {a, 0.0, v_phi_0, 0.5, beta, N_sim} );       // Initialisierung der Pendel-Objekte
        beta = beta + 0.2;                                                          // Der Parameter beta der Reibung wird veraendert
    }
    
//    Pendel_math Pendel_B = Pendel_math(a, 0.0, 8.2, 0.5, 0.0, N_sim); // Konstruktor bilded eine Instanz der Sub-Subklasse Pendel_math 
    
    // Beschreibung der in die Ausgabedatei "Pendel.dat" ausgegebenen Groessen 
    fprintf(ausgabe, "%10s %20s %20s %20s %20s %20s %20s %20s \n", "# Index i", "t-Wert", "x(t), Pendel 1", "y(t), Pendel 1", "v_x(t), Pendel 1", "v_y(t), Pendel 1", "x(t), Pendel 2", "...");
    
    // Zeitliche Simulation 
    for(int i=0; i  <= N_sim; ++i){                              // for-Schleife  ueber die Zeitgitterpunkte der Simulation 
        fprintf(ausgabe, "%10d %20.12f ",i,  Kiste_Pendel[0].t); // Ausgabe des Zeit-Indexes und der aktuellen Zeit in die Ausgabedatei
        for (auto& n : Kiste_Pendel){                            // Bereichsbasierte for-Schleife ueber die einzelnen Pendel-Objekte
            fprintf(ausgabe, "%20.12f %20.12f %20.12f %20.12f ",n.r[0], n.r[1], n.v[0], n.v[1]); // Ausgabe der Orts- und Geschwindigkeitswerte des Pendel-Objektes in die Ausgabedatei
            n.Gehe_Zeitschritt(dt, N_RK);                        // Aufruf der Funktion Gehe_Zeitschritt(...)
        }                                                        // Ende for-Schleife (Pendel-Objekte)
        fprintf(ausgabe, "\n");                                  // Neue Zeile in der Ausgabedatei
    }                                                            // Ende for-Schleife (Zeitgitterpunkte)
    fclose(ausgabe);            // Schliessen der Ausgabedatei
}                    // Ende main()-Funktion

# Python Programm zum Visualisieren der Daten des Pendel_Container.cpp Programms, 
# Mathematisches vs. physikalisches Pendel ohne Reibung
# Es werden hier mehrere Bilder der zeitlichen Entwicklung des Systems in einem Ordner 'Bilder' gespeichert
# !!!! Sie muessen vor der Ausfuehrung des Programms den Ordner Bilder erstellen !!!!
# Die einzelnen Bilder kann mann dann mittels des folgenden Terminalbefehls zu einem Video binden:
# ffmpeg -framerate 200 -i './Pendel_%04d.jpg' -s 800x800  Pendel.mp4 
# (die Framerate ergibt sich durch N_sim/b = 1000/5)
# Mehrere unterschiedliche Pendelsimuationen werden in einem vector-Container gespeichert

import matplotlib
import matplotlib.pyplot as plt         # Python Bibliothek zum Plotten (siehe https://matplotlib.org/ )
import numpy as np                      # Python Bibliothek fuer Mathematisches (siehe https://numpy.org/ )

grid_dim = 5
Anz_Pendel = grid_dim*grid_dim

data = np.genfromtxt("./Pendel_Container.dat")  # Einlesen der berechneten Daten von Pendel.cpp

#for it in range(len(data[:,0])):      # for-Schleife fuer die zeitliche Entwicklung der Dinge in der Kiste
for it in range(3):  
    print(it)                         # Terminalausgabe der Erstellung des i-ten Bildes
    fig, axs =  plt.subplots(nrows=grid_dim, ncols=grid_dim, constrained_layout=False, figsize=(20,20)) 
    
    n=0
    for ax in axs.flat: 
        ax.cla()
        ax.axis('off')
        ax.set_xlim(-0.6, 0.6)                              # Limitierung der x-Achse
        ax.set_ylim(-0.6, 0.6)                              # Limitierung der y-Achse
        
        ax.scatter( 0, 0, s=5, marker='o', c="black")                                   # Zeichnen des Pendel-Koerpers
        ax.scatter( data[it,2+n*4], data[it,3 +n*4], s=70, marker='o', c="blue")        # Zeichnen des Pendel-Koerpers
        ax.plot( [0 , data[it,2+n*4]] , [0 , data[it,3 +n*4]] ,c="black",linewidth=0.8) # Zeichnen der Pendel-Stange
        
        n=n+1

    # Bild-Ausgabe mit Speicherung eines individuellen Iteration-Namens
    pic_name = "./Bilder/" + "Pendel_Container_" + "{:0>4d}".format(it) + ".jpg"
    plt.savefig(pic_name, dpi=200,bbox_inches="tight",pad_inches=0.05,format="jpg")
    plt.close()