C Programm: Näherungswert der Leibnitz-Reihe als Referenzparameter übergeben.

[Jasam]

Hallo.

Ich habe hier die Leibnitz-Reihe und muss noch dazu eine Funktion Schreiben wo der Näherungswert der Leibnitz-Reihe als Referenzparameter in die main übergeben wird. Und die Funktion darf keinen Rückgabewert haben.

Leider denke ich immer in zu komplizierten Schritten und habe jetzt ein Blackout. Kann mir einer Helfe.

#include<stdio.h>
#include<math.h>

double gesucht (int n)
{
long int i;
double sum=0.0, term, pi;
for(i=0;i< n;i++)
{
term = pow(-1, i) / (2*i+1);
sum += term;
}
pi = 4 * sum;
return pi;
}

int main()
{
long int n;
double pi;

printf("Wie viele Durchläufe soll es werden? Bitte eingeben:");
scanf("%ld", &n);

pi = gesucht (n);
printf("\nPI = %.6lf", pi);

return 0;
}

 

[Bonanca]

Kannst du die Aufgabenstellung einmal umformulieren?
Oder bin ich gerade der einzige, der nicht wirklich versteht, was die Aufgabe sein soll?

 

[tRITON]

Hausaufgaben Hilfe - Du willst doch was lernen, also wo ist nun dein genaues Problem beim Verständnis? Also ich versteh schon deine Frage aber wenn ich hier deutlicher werde, lernst Du ja nichts. Formulier dein Problem, dann bist Du schon auf dem halben Weg der Lösung

 

[BAGZZlash]

Bitte Code anständig posten, es gibt Code-Tags.

Deine Funktion muss dann vom Typ void sein, darf kein return-Statement enthalten, und braucht zwei Parameter: Neben n noch einen, der den Pointer auf eine in der main deklarierte Variable vom Typ double enthält. In der Funktion befüllst Du dann diese Variable mit Deinem Ergebnis, und so kannst Du den Wert in der main nach Aufruf der Funktion verwenden.

 

[DaysShadow]

Typ void sein, darf kein return-Statement enthalten

Eine void Funktion mit return Statements gibt auch nichts zurück, sondern verlässt nur die Funktion. Widerspräche nicht dem Gefordertem. Funktionen mit frühem Verlassen der Funktion, ob mit oder ohne Rückgabewert, sind auch nicht unüblich.

 

[Renegade334]

muss noch dazu eine Funktion Schreiben wo [...] Referenzparameter in die main übergeben wird. Und die Funktion darf keinen Rückgabewert haben.

Ich denke das fasst es auf das wesentliche zusammen.
Wie wäre es mit einem Pointer?

 

[entropie88]

Ich würde nach "call by value" und nach "call by reference" googeln.

 

[Jasam]

Die Aufgabenstellung war:
1. Version: Eingabewert ist die Anzahl n der Summanden, die in der Leibniz-Reihe ausgewertet
werden. Rückgabewert ist der damit berechnete Näherungswert der Kreiszahl pi.

(das habe ich oben gemacht)

2. Version: Eingabewert ist wieder die Anzahl n der Summanden, die in der Leibniz-Reihe ausgewertet
werden. Aber die Funktion hat keinen Rückgabewert; stattdessen wird der Näherungswert
als Referenzparameter übergeben.

Mein erster Versuch ging schief:

void ref_pi (int *n)
{
    long int i;
    double sum=0.0, term, *pi;
    for(i=0;i< n;i++)
    {
        term = pow(-1, i) / (2*i+1);
        sum += term;
    }
    *pi = 4 * sum;
}

int main()
{
    long int *n;
    double *pi;

    printf("Wie viele Durchläufe soll es werden? Bitte eingeben:");
    scanf("%ld", &n);

    pi = gesucht (n);
    printf("\nPI = %.6lf", pi);

    pi = ref_pi (&n);
    printf("\n ref_pi = %.6lf", pi);

return 0;
}
[automerge]1654158444[/automerge]
Versuch Nr. 2:

#include<stdio.h>
#include<math.h>

double gesucht (int n)
{
    long int i;
    double sum=0.0, term, pi;
    for(i=0;i< n;i++)
    {
        term = pow(-1, i) / (2*i+1);
        sum += term;
    }
    pi = 4 * sum;
return pi;
}

void ref_pi(int n, double & pi){
   
    long int i;
    double sum=0.0, term, pi;
    for(i=0;i< n;i++)
    {
        term = pow(-1, i) / (2*i+1);
        sum += term;
    }
    pi = 4 * sum;
}

int main()
{
    long int n;
    double pi;

    printf("Wie viele Durchläufe soll es werden? Bitte eingeben:");
    scanf("%ld", &n);

    pi = gesucht (n);
    printf("\nPI = %.6lf", pi);
   
    ref_pi(n, pi);
    printf("\n ref_pi = %.6lf", pi);

return 0;
}

 

[Renegade334]

Ich denke du hast die Verwendung von Pointern noch nicht ganz verstanden.
Wenn deine Lösung mit Rückgabewert funktioniert nehmen wir die mal als Ausgangspunkt:

#include<stdio.h>
#include<math.h>

double gesucht (int n)
{
    long int i;
    double sum=0.0, term, pi;
    for(i=0;i< n;i++)
    {
        term = pow(-1, i) / (2*i+1);
        sum += term;
    }
    pi = 4 * sum;
    return pi;
}

int main()
{
    long int n;
    double pi;

    printf("Wie viele Durchläufe soll es werden? Bitte eingeben:");
    scanf("%ld", &n);

    pi = gesucht (n);
    printf("\nPI = %.6lf", pi);

    return 0;
}

Um nicht mit return zu arbeiten könntest du jetzt deine "gesucht" Funktion ändern und statt return das Ergebnis direkt in die Variable pi schreiben. Dazu muss deine Funktion aber wissen, an welcher Stelle die Variable pi im Speicher liegt. Die Adresse musst du also übergeben.

Ich denke das sollte dir helfen:
https://de.wikibooks.org/wiki/C++-Programmierung/_Weitere_Grundelemente/_Zeiger#Zeiger_und_Funktionen

Vielleicht helfen dir diese Zeilen noch:

void gesucht(int n, double *pi)
  
*pi = 4*sum;

gesucht(n, &pi);

 

[Jasam]

Ich habe vergessen zu erwähnen, dass ich drei versionen von Funktionen brauche. Die erste habe ich gemacht. die zweite muss eine eigene Version sein und nicht in der ersten eingebracht werden.:

Aufgabe:
Implementierung von drei Funktionen zur Berechnung der Näherung
Implementieren Sie drei Versionen einer Funktion zur Berechnung einer Näherung der Kreiszahl pi .
1. Version: Eingabewert ist die Anzahl n der Summanden, die in der Leibniz-Reihe ausgewertet
werden. Rückgabewert ist der damit berechnete Näherungswert der Kreiszahl pi .
2. Version: Eingabewert ist wieder die Anzahl n der Summanden, die in der Leibniz-Reihe ausgewertet
werden. Aber die Funktion hat keinen Rückgabewert; stattdessen wird der Näherungswert
als Referenzparameter übergeben.
3. Version: Eingabewert ist die positive Schranke epsilon; die Leibniz-Reihe wird so lange ausgewertet
bis sich der Näherungswert und die Kreiszahl pi im Betrag um weniger als epsilon
unterscheiden. Rückgabewert ist wieder der berechnete Näherungswert der Kreiszahl pi .
4. Test
Implementieren Sie geeignete Aufrufe der drei Funktionen in main(), um die Funktionen zu
testen.

 

[DaysShadow]

Jo, dann hau rein und leg hier was vor

 

[Topinambur]

schöne Fingerübung,

• Rückgabe per Return,
• Rückgabe via Referenz und
• eine variable Schranke …

Viel Erfolg

 

[Jasam]

Hallo.
Der erste und der zweite Punkt wäre bei mir so:

#include<stdio.h> #include<math.h> double gesucht (int n) { long int i; double sum=0.0, term, pi; for(i=0;i< n;i++) { term = pow(-1, i) / (2*i+1); sum += term; } pi = 4 * sum; return pi; } void ref_pi (int n, double* pi){ long int i; double sum=0.0, term; for(i=0;i< n;i++) { term = pow(-1, i) / (2*i+1); sum += term; } *pi = 4 * sum; } int main() { long int n; double pi; //double rpi; printf("Wie viele Durchläufe soll es werden? Bitte eingeben:"); scanf("%ld", &n); pi = gesucht (n); printf("\nPI = %.6lf", pi); ref_pi(n, &pi); printf("\n\nref_pi = %.6lf", pi); return 0; }

 

[BAGZZlash]

Nochmal: Code-Tags.

 

[Jasam]

Da ich es nicht lange mache bitte um Entschuldigung. Ich bin noch neu in der Programmierung.
Kann mir jemand erklären was hier mit epsilon und der Schranke gemeint ist?

"
3. Version: Eingabewert ist die positive Schranke Epsilon; die Leibniz-Reihe wird so lange ausgewertet
bis sich der Näherungswert und die Kreiszahl pi im Betrag um weniger als Epsilon
unterscheiden. Rückgabewert ist wieder der berechnete Näherungswert der Kreiszahl pi ."

Wie ich es verstehe ist Epsilon das hier: #define PI 3.141592654 und man muss dann die beiden pi-Werte von Nr.1 und Nr.2 zusammen addieren. Doch würde da irgendwie keinen Sin für mich ergeben: " um weniger als Epsilon unterscheiden "

 

[pfd]

Bei der näherungsweisen Berechnung von 𝜋 mit einem numerischen Verfahren wird überprüft, ob sich der Betrag der Differenz der letzten beiden Berechnungen um ein epsilon (𝜀) unterscheidet.

𝜀 ist eine positive Zahl nahe bei 0 (NICHT 0), z.B. 𝜀 = 0.000000001


Pseudocode:

solange |wertAlt - wertNeu| >= 𝜀 {
    wertAlt = wertNeu;
    wertNeu = weitere Berechnung von pi
}

Solange der Betrag größer als 𝜀 ist, wurde die numerische Genauigkeit noch nicht erreicht und eine weitere Berechnung wird durchgeführt.
Das wird so oft wiederholt, bis der Betrag der Differenz kleiner als 𝜀 ist.


Betragsfunktion:

         /  x  für x >= 0
   |x| = |
         \ -x  für x < 0

 

[Jasam]

Hallo.
Leider komme ich bei der letzten aufgabe nicht weiter:
Simulation und Auswertung einer Fahrradtour
Verwenden Sie das Feld dfs aus der Aufgabe 1.1 Implementierung einer abschnittsweise definierten
Funktion als die vom Tachometer erzeugte Messreihe ts. Dazu sind die x-Werte der Funktion f (x) als
Strecken in Meter zu lesen und die Funktionswerte als Zeitangaben in Sekunden. Der Umfang des
Reifens beträgt U = 2 m. Die Anzahl der Zeilen N der Matrix data muss entsprechend angepasst werden.
Führen Sie Ihr oben entwickeltes Programm aus, wenn Sie das Feld ts mit dfs initialisieren. Interpretieren
Sie die Matrix data und beschreiben Sie, welche Bewegungsformen Sie in den drei Abschnitten
der Funktion f (x) erkennen.

Kann jemand ein Tipp geben? Ich setze irgend etwas falsch ein. Bitte

//Simulation einer Fahrradtour

#include<stdio.h>
#include<math.h>

//Auswertung der Messdaten eines Tachometers

#define N 651

double f(double x)
{ 
    if(x>=0 && x<=250)
    {      
        return sqrt(10*x);
    }
    if(x>250 && x<=550)
    {      
        return (50+(x-250))/10;
    }  
    if(x>550 && x<=650)
    {      
        return 100-2*sqrt(100-(x-550));
    }
}


int main(int* args)
{
    double s;
    double fs[651];         //double-Feld fs
    for(int x=0;x<=651;x=x+1)
    {      
        f(x) = fs[x]; //= f(x);   //f(x) = Zeit
        //printf("fs = %f \n", fs[x]);
    }

    double ts[650] = {((fs[x]/2))}; /*vom Tachometer gemessene Zeitdauer pro Reifenumdrehung*/
//2)
    double U = 2; /* Umfang des Reifens U mit 2 initialiesiert*/

//3)
    double data[N][6]; /* 6 Spalten für gemessene und berechnete Größen (ZEILEN VORNE; SPALTEN HINTEN)*/
    
/*4)  aus ts und U werden weitere größen berechnet und in der Matrix gespeichert*/
    double deltaT = 0;
    double v = 0;

    for(int i = 0; i < N ; i++)
    {
        /*ausrechnen der gewünschten Werte von 2.1*/
        deltaT = ts[i];
        data[i][0] = deltaT; //1.0;//TS;
        v = U / deltaT;
        data[i][1] = v;     //2.0;//moment;
        data[i][2] = U;     //3.0;//strecke;
        data[i][3] = ts[i]; //4.0;//Zeit;
        v = (i)/(ts[i]);
        data[i][4] = v; //5.0;//m/s;
        v= (v/1000)*3600;
        data[i][5] = v;//6.0;//km/h;
    }

    if(N < 25) /* Ausgabe der Matrix data in weniger als 25 Zeilen*/
    {
        for(int i = 0; i < N ; i++)
        {
            printf ("Zeile %d: Ts: %f moment: %f strecke: %f Zeit: %f m/s: %f km/h: %f \n", i, data[i][0], data[i][1], data[i][2], data[i][3], data[i][4], data[i][5]);
        }
    }
    else /* Ausgabe der Matrix data in 25 schritten 25.,50.,75., ...*/
    {
        for(int i = 0; i < N ; i+=25)
        {
        printf ("Zeile %d: Ts: %f moment: %f strecke: %f Zeit: %f m/s: %f km/h: %f \n", i, data[i][0],data[i][1],data[i][2],data[i][3],data[i][4],data[i][5]);
        }
    }
return 0;
}

 

[DaysShadow]

@Jasam Ist dir bewusst was f(x) in Zeile 33 überhaupt bedeutet? Für den zweiten Fehler sagt dir die Errormeldung eigentlich was das Problem ist. Auch wenn C Compilerfehlermeldungen nicht immer so einfach zu lesen und verstehen sind ist es diese schon. Hinweis: Welches x benutzt du denn da? Es ist nicht der Wert gemeint, sondern die Variable.

 

[Jasam]

Habe es erstmal so raus:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 651
/* Eine Funktion wird für die drei Formeln und den Jeweiligen Definitionsbereichen erstellt */
double f(double x)
{ 
    if(x>=0 && x<=250)
    {      
        return sqrt(10*x);
    }
    if(x>250 && x<=550)
    {      
        return (50+(x-250))/10;
    }  
    if(x>550 && x<=650)
    {      
        return 100-2*sqrt(100-(x-550));
    }
}

int main()
{
    double ts[N];  //double-Feld fs
    //2)
    double U = 2; /* Umfang des Reifens U mit 2 initialiesiert*/
//3)
    double data[N][6]; /* 6 Spalten für gemessene und berechnete Größen (ZEILEN VORNE; SPALTEN HINTEN)*/
//4) /* aus ts und U werden weitere größen berechnet und in der Matrix gespeichert*/
    double deltaT = 0;
    double v = 0;
    
    for(int x=0;x<=N;x++)
    {      
        ts[x] = f(x);
        //printf("ts = %f \n", ts[x]);
        deltaT = ts[x];
        data[x][0] = deltaT; //1.0;//TS;
        v = U / deltaT;
        data[x][1] = v;     //2.0;//moment;
        data[x][2] = U;     //3.0;//strecke;
        data[x][3] = ts[x]; //4.0;//Zeit;
        v = (U)/(ts[x]);
        data[x][4] = v; //5.0;//m/s;
        v= (v/1000)*3600;
        data[x][5] = v;//6.0;//km/h;
    }
    if(N < 25) // Ausgabe der Matrix data in weniger als 25 Zeilen
    {
        for(int i = 0; i < N ; i++)
        {
            printf ("Zeile %d: Ts: %f moment: %f strecke: %f Zeit: %f m/s: %f km/h: %f \n", i, data[i][0], data[i][1], data[i][2], data[i][3], data[i][4], data[i][5]);
        }
    }
    else // Ausgabe der Matrix data in 25 schritten 25.,50.,75., ...
    {
        for(int i = 0; i < N ; i+=25)
        {
        printf ("Zeile %d: Ts: %f moment: %f strecke: %f Zeit: %f m/s: %f km/h: %f \n", i, data[i][0],data[i][1],data[i][2],data[i][3],data[i][4],data[i][5]);
        }
    }
return 0;
}

 

[Jasam]

Noch eine letzte Frage.
Ich versuche die insgesammt zurück gelegte Zeit nach jedem ablauf zu adieren und da kommt mit verschiedenen Formeln immer nicht die addierten zeiten raus. auch bei a = a+i . Da muss bei Zeit: erste Zahl 1 die zweite 1+4 = 5 die dritte 5+3 = 8 und vierte 8+5 =13.