Méthode d'Euler en C++ ??

[paul2121]

Bonjour,

Je dois résoudre à l'aide de la méthode d'Euler l'équation d'un oscillateur harmonique non amorti, i.e. .
Pour appliquer la méthode d'Euler, on la décompose en 2 équations différentielles du premier ordre,



Mais je dois écrire une fonction

void euler(int N, float t, float fonctions[], float dt, void f(int N, float t, float fonctions[],float derivees[]))

où N est le nombre d'équations différentielles à intégrer, t est le temps, "fonctions" un tableau contenant les fonctions à intégrer, dt le pas, et f une fonction qui calcule les dérivées pour l'algorithme.
J'ai réalisé ce qui suit :

#include <iostream>
#include <string>
#include <stdio.h>
#include <fstream>
#include <math.h>
#include <cstdlib>
using namespace std;

void euler(float t, float x[], float u[], float dt, void f(int N, float t, float fonctions[], float derivees[]))
{
	cin >> "Entrer la valeur du pas " >> dt;
	cin >> "Entrer la valeur de x(0) " >> x[0];
	cin >> "Entrer la valeur de x_point(0) " >> u[0];
// 	OU : x[0]=0; u[0]=v0;

	for (t=0;t<100;t=t+dt)
	{
// Ecriture des résultats dans un fichier :
		ofstream ressort("ressort.res");
		ressort << t << " " << x[t] << " " << u[t] << endl;
		TP4.close(); 
// On écrit dans le fichier avant de procéder aux calculs pour ne pas omettre les valeurs initiales de i, x[i] et u[i].
// SCHEMA D'EULER :
		u[t+1]=-w*w*x[t]*dt+u[t];
		x[t+1]= x[t]+dt*u; // Désignation de la i+1-ème case du tableau	
	}

//Calcul des dérivées avec, comme le veut l'énoncé, la fonction f: 
	
	double f(int N, float t, float fonctions[N],  float derivees[N]){
	
		
		derivees[N]=-w*w*x[i]}  // x_point_point = -w²*x.
	
}


int main()
{
	cout << Euler(n,t,fonctions[],dt,f(N,t, fonctions, derivees) << endl; // A remplir plus tard.
	return 0; 
}

Mais je vois mal quel est l'intérêt de la fonction f une fois qu'on a écrit une boucle telle que la mienne (est-elle correcte d'ailleurs ? Est-ce qu'il manque des choses pour que mon programme fonctionne ?), et je ne sais pas trop quoi mettre dans la procédure associée à f.

En espérant obtenir de l'aide, et merci d'avance.
-----

[Chanur]

Je ne comprends absolument rien à ton programme.
Même la syntaxe n'a aucun sens.
Tu as réussis à compiler ça ???

J'imagine que tu as eu un cours de C++, avant qu'on te demande d'écrire un tel programme.
Commence par le relire à tête reposée et écris l'algorithme que tu dois réaliser avant de te lancer tête baissée dans la programmation.

Parce que là, si j'étais mauvaise langue, je dirais que tu as écrit n'importe quoi au pif pour donner l'impression que tu as essayé, en espérant qu'on te donnera la solution ...

[paul2121]

Ah non, je balance pas des programmes vite faits pour avoir la solution, ça fait plus d'une semaine que je me bats avec cette méthode d'Euler ! Et j'ai pas compilé puisqu'il me manque la partie sur f.
Quelle syntaxe est fausse ?? (A part le TP4.close;, j'aurai dû mettre ressort.close(); )
Bon je reprends.
J'ai scindé l'équation différentielle en deux équations du premier ordre. J'ai donc, en faisant l'approximation df/dx~Δf/Δx,

1°) dx/dt~Δx/Δt, soit d'après la première équation.

2°) du/dt~Δu/Δt, soit d'après la seconde.

Où delta t = Δt.

Ce sont précisément les lignes recopiées dans le SCHÉMA D'EULER.
Je demande à l'utilisateur de rentrer les valeurs du pas, de la vitesse et la position initiale avec cin.

Qu'est-ce que vous ne comprenez pas ??

Merci d'avoir répondu.

[Chanur]

Quelle syntaxe est fausse ??

L'utilisation de cin
Le fait d'utiliser un float comme indice d'un tableau
Le fait que TP4 ne soit pas déclaré
Le fait d'utiliser une variable (N) pour dimensionner un tableau
Le fait d'utiliser, dans le main les variables n, t, fonctions, dt ,N, derivees et f sans les avoir déclarées.

[A voir en vidéo sur Futura]

[Chanur]

J'oubliais : la multiplication d'un float par un pointeur : x[t+1]= x[t]+dt*u;

[paul2121]

L'utilisation de cin
Le fait d'utiliser un float comme indice d'un tableau
Le fait que TP4 ne soit pas déclaré

Pour le TP4, c'est corrigé. Pour le float, ok.

J'oubliais : la multiplication d'un float par un pointeur : x[t+1]= x[t]+dt*u;

Ah mais je voulais juste multiplier par des nombres, pas des pointeurs !... Comment faire ?

L'utilisation de cin

Effectivement j'ai voulu aller trop vite, j'aurai dû taper :

cout << "Entrer la valeur de x(0) : ";
    cin >> x[0];

Le fait d'utiliser une variable (N) pour dimensionner un tableau

Bon, j'oublie cette variable pour le dimensionnement.

En déclarant tout ce qu'il faut, ça donne ça (un peu retravaillé):

// EULER POUR RESSORT SIMPLE.

#include <iostream>
#include <string>
#include <stdio.h>
#include <fstream>
#include <math.h>
#include <cstdlib>
using namespace std;
#define w 1


void euler(int t, float x[], float u[], float dt, void f(int N, int t, float dt, float x[], float u[]))
{
	cout >> "Entrer la valeur du pas " ;
        cin >> dt; 
	cout >> "Entrer la valeur de x(0) "
        cin >> x[0]; 
	cout >> "Entrer la valeur de x_point(0) " ;
        cin >> u[0];

	for (t=0;t<100;t=t+dt)
	{
		ofstream ressort("ressort.res");
		ressort << t << " " << x[t] << " " << u[t] << endl;
		ressort.close();
		
// On écrit dans le fichier avant les calculs 		
// pour ne pas omettre les valeurs initiales de 
// 		i, x[i], u[i].

// SCHEMA D'EULER
		u[t+1]=dt*w*w*x[t]+u[t];
		x[t+1]= x[t]+dt*u[t]; // Désignation de la i+1-ème case du tableau	
	}

// Calcul des dérivées de u et x :
	
	void f(int N, int t, float dt, float x[], float u[]) // u est le tableau des dérivées, et x le tableau des fonctions (les anciens "derivees" et "fonctions")
	{

		u[t+1]=-w*w**dt*x[t]+u[t];
		x[t+1]= x[t]+dt*u; // Me semble faux...
	
	}
	

}

	
int main()
{
	int i; 
        int N; float t;  
        float x[] ; int dt; float u[]; 
 	cout >> "Entrer à nouveau la valeur du pas " ;
        cin >> dt; 
	cout >> "Entrer à nouveau la valeur de x(0) "
        cin >> x[0]; 
	cout >> "Entrer à nouveau la valeur de x_point(0) " ;
        cin >> u[0];
	for (i=0;i<100;i++)
	{
		temps[i]=i*dt;// Tableau de temps (pour tracer la solution)
		f(N,t,dt,x[i],u[i]);	

cout << Euler(N,t,x[],dt,u[]) << endl;
	}
	return 0; 
}

Comprenez-vous mieux ?
Le reste est-il correct (surtout pour f) ?

[Chanur]

Donc là, ton compilateur ne donne plus d'erreur ?

Commence par exprimer ce que tu cherches à faire dans un langage simple (en pseudo-code, par exemple).
Ensuite, traduis ça en C++. Le compilateur est ton ami : il te dis gentiment où il y a des erreurs. Il suffit de le lui demander.

Parce que moi, quand j'essaie de compiler, j'ai deux page d'erreurs, et la plupart sont évidentes :
- la syntaxe de cout
- la définition de la fonction f au milieu de la fonction euler
- les points-virgule qui manquent
- les variables pas déclarées
- les tableaux définis sans donner leur dimension
- le fait d'essayer de déréférencer un float (u[t+1]=-w*w**dt*x[t]+u[t]
- l'appel d'une fonction non définie (Euler)
- ...

Il faut essayer de deviner ce que tu crois avoir compris du C++, pour en déduire ce que tu essaies de programmer et, de là deviner où tu te trompes (si tu te trompes), sans avoir ni énoncé, ni pseudo code, ni programme à tester.
J'ai pas de boule de cristal ...

[paul2121]

Si malheureusement, plein d'erreurs...
Je ne comprends pas ce que vous ne comprenez pas : il s'agit simplement de résoudre l'équation du ressort donnée dans le premier post avec la méthode d'Euler. Tout est très clair dans ma tête.
Pour la fonction f emboîtée dans la fonction euler, je n'étais pas sûr, vu que dans les arguments de euler, il y a f. Mais il me semble pourtant que c'est bon, parce que si f fait partie des arguments de euler, on ne peut pas la mettre en dehors de la procédure euler. (?)
Pour les points-virgules (après deux cout) et la syntaxe de cout, ce sont de simple étourderies, qui sont dues à des copier/coller.

L'appel d'une fonction non définie (Euler)

Hein ? Mais Euler est définie dans le void, et ensuite on peut s'en servir dans le int main, non ?

Désormais, je réécrirais x[N], t[N] et u[N] !

- le fait d'essayer de déréférencer un float (u[t+1]=-w*w**dt*x[t]+u[t]

Je n'essaye pas de déréférencer le float, mais je veux juste faire mon produit -w²*x !!!

Que mettre dans la procédure de f ? C'est ça ma grande question... Comment calculer les dérivées de u et x aux temps dt, 2dt, 3dt etc... ? Parce que dans le schéma d'Euler elles sont déjà calculées...
La dérivée de u est en effet -w²*x, et la dérivée de x est u.

Il faut essayer de deviner ce que tu crois avoir compris du C++, pour en déduire ce que tu essaies de programmer et, de là deviner où tu te trompes (si tu te trompes), sans avoir ni énoncé, ni pseudo code, ni programme à tester.
J'ai pas de boule de cristal ...

Je ne fais du C++ que depuis début septembre, donc je sais pas grand-chose. Je connais les bas : les librairies, les cout/cin, les boucles, les pointeurs, les tableaux, les fonctions, les types.

Puisque vous le demandez, voilà l'énoncé complet (je vous invite à passer l'explication de la méthode d'Euler) :

"Ecriture du programme pour un oscillateur harmonique.


Les équations que nous résoudrons seront en fait des équations différentielles du deuxième ordre et
on utilisera pour commencer la méthode d’Euler : c’est la plus simple.
On part d’un système d’équations différentielles du premier ordre :

dy_l(t)=f_l(t,{y_l'}), quelque soit l.

On cherche donc un ensemble de fonctions (inconnues) y_l(t) à partir de leur dérivée,
f_l(t,{y_l'}) dont l’expression analytique en fonction de la variable d’intégration t et de la
valeur des fonction y_l' est connue.
La méthode d’Euler établit une discrétisation du temps : t -> i dt où i est un entier,
et :
y_l(t + dt) = y_l(t) + f_l(t, y1(t), . . .) dt


Ecrire une fonction :

void euler(int n, float t, float y[], float dt, void f(int, float, float[], float[]))

(Le y d'ici correspond à x dans le cas de l'équation du ressort)

où :

– n est un scalaire entier contenant le nombre d’équations différentielles à intégrer.
– t est un scalaire réel contenant la valeur du temps au pas d’intégration courant.
– dt est un scalaire réel contenant la valeur du pas d’intégration.
– y est un tableau réel dont la dimension est le nombre d’équations différentielles du
premier ordre résoudre. Il contient les valeurs courantes des fonctions à intégrer (y'(t)
avec les notations ci-dessus). En sortie, euler doit placer le résultat du pas d’intégration
courant, c’est-à-dire les nouvelles valeurs des y` dans le même tableau y.
– f est le nom de la fonction qui calcule les dérivées utilisées par euler (par exemple
deriv).
Le programme de simulation doit donc comporter deux parties en plus de la fonction
euler :
– un programme principal qui se charge des entrées-sorties (lecture des paramètres du
calcul sur le clavier ou dans un fichier, au choix, écriture des résultats dans un fichier en
vue d’un tracé à l’aide de gnuplot ou tout autre programme de ce genre). Ce programme
principal doit appeler euler dans une boucle sur le temps.
– une fonction qui calcule les dérivées des fonctions à intégrer avec euler.

Les paramètres utilisées par cette fonction sont, dans l’ordre,

– un scalaire entier contenant le nombre d’équations différentielles à intégrer.
– un scalaire réel contenant la valeur du temps au pas d’intégration courant.
– un tableau réel dont la dimension est le nombre d’équations différentielles, contenant
les valeurs courantes des fonctions à intégrer.
– un deuxième tableau réel de même dimension, dans lequel ce sous-programme doit placer
les valeurs des dérivées.

B– Vérifications et détermination du pas de temps.

On pourra choisir w = 1. Tracer, pour t appartenant à [0, 50], x(t) et x'(t) avec dt = 0.01.
Conditions initiales : x(0) = 0.1, x'(0) = 0. Est-ce que le résultat est acceptable ? Sinon, essayer avec
dt = 0.001, voire moins. "

[Chanur]

Donc tu dois écrire une fonction euler (...)
ET une fonction f() qui calcule la dérivée.

Comme on passe la fonction f() en paramètre à la fonction euler(), il faut qu'elle soit définie au moment ou on lance euler().
Ca n'a pas de sens de la définir à l'intérieur de la fonction euler()

Je n'invente rien :

Le programme de simulation doit donc comporter deux parties en plus de la fonction euler :
– un programme principal qui se charge des entrées-sorties (lecture des paramètres du
calcul sur le clavier ou dans un fichier, au choix, écriture des résultats dans un fichier en
vue d’un tracé à l’aide de gnuplot ou tout autre programme de ce genre). Ce programme
principal doit appeler euler dans une boucle sur le temps.
– une fonction qui calcule les dérivées des fonctions à intégrer avec euler.

Quand aux erreurs du compilateurs, on peut en faire ce qu'on veut.
Une possibilité est de les corriger, par exemple ...

[paul2121]

Je les corrige actuellement.
Quant à vous, pourriez-vous répondre à mes questions ??

[fred1599]

Hein ? Mais Euler est définie dans le void, et ensuite on peut s'en servir dans le int main, non ?

Et pourtant non elle ne l'est pas, Euler != euler

Peux-tu expliquer ce 5ème paramètre de cette fonction ? Que veut faire ton enseignant avec ceci: void f(int, float, float[], float[]), sachant que void est un type pour indiquer que l'on ne retourne rien.

[paul2121]

Ce que j'ai compris depuis le début, c'est que f était un argument de euler au même titre que dt, N etc...
A mon avis, f calcule les dérivées nécessaires pour effectuer les itérations (i->i+1), i.e. calcule u point et x point.
Void ne retourne rien, mais il fait quand même une procédure sur f, qu'on réutilisera dans le int main.
Que voulez-vous dire en déclarant que euler n'est pas définie dans le void ? Pour moi il n'y a pas à dire, à un moment du void, d'exécuter l'instruction euler(dt, N etc...), puisque justement on la définit via ce void. Après quoi il suffirait dans le main d'écrire : cout << euler(dt, N etc...) << endl; et alors on aurait la résolution.

[Chanur]

Ce que j'ai compris depuis le début, c'est que f était un argument de euler au même titre que dt, N etc...

Oui.
Et quand on appelle euler(), les arguments qu'on lui passe doivent être des variables déclarées auparavant. Même si l'argument est une fonction.

A mon avis, f calcule les dérivées nécessaires pour effectuer les itérations (i->i+1), i.e. calcule u point et x point.

Oui. C'est ce que dit l'énoncé. (Par ailleurs f n'est pas un nom très parlant. Tu devrais suivre la suggestion de l'énoncé et l'appeler deriv. Mais ça ne change rien)

Void ne retourne rien, mais il fait quand même une procédure sur f, qu'on réutilisera dans le int main.

Cette phrase ne veut rien dire. "void" est un mot clef du langage C qui sert pour déclarer une fonction ne retournant pas de valeur, un pointeur dont on ne dit pas vers quoi il pointe ou une fonction sans paramètres.

Que voulez-vous dire en déclarant que euler n'est pas définie dans le void ?

Rien, puisque ça ne veut rien dire et que je n'ai pas dit ça. En particulier l'expression "dans le void" n'a aucune signification.

Pour moi il n'y a pas à dire, à un moment du void, d'exécuter l'instruction euler(dt, N etc...), puisque justement on la définit via ce void.

?
Le chmurglugs brlagrveux choinrgue dans la trilotrop.

Après quoi il suffirait dans le main d'écrire : cout << euler(dt, N etc...) << endl; et alors on aurait la résolution.

Oui.

[paul2121]

J'ai modifié considérablement mon programme, j'en suis venu à écrire :

// EULER POUR RESSORT SIMPLE.

#include <iostream>
#include <string>
#include <stdio.h>
#include <fstream>
#include <math.h>
#include <cstdlib>
using namespace std;
#define w 1
#define N 2

void euler(float t, float y[N], float dt, void f(float dt, float t, float y[N]))
{


		/////////// Calcul des dérivées par une fonction f : //////

		double deriv[N];// Tableau des dérivées de taille 2 : 
		f(y, deriv[N]); 
		{
		deriv[0]=y[1];
		deriv[1]=-w*w*y[0];
		}
		
		// Schéma d'Euler : 
		
		y[0]=y[0]+deriv[0]*dt;// ou y[0]+=deriv[0]*dt
		y[1]=y[1]+deriv[1]*dt;
		ofstream ressortbis("ressortbis.res");
		ressortbis << y[0] << " " << y[1] << endl;
		ressortbis.close();

	}





int main()
{
	int i;
// 	float deriv[N];--> Inutile
	float y[N];
	float t;float dt;
// 	void z=f(y[N],deriv[N]);// Comment déclarer f ??
	cout << "Entrer la valeur du pas " ;
    cin >> dt;
	cout << "Entrer la valeur de x(0) " ;
	cin >> y[0];
	cout << "Entrer la valeur x_point(0) " ;
	cin >> y[1];
	for (i=0;i<100;i++)// "Appelle Euler par une boucle sur le temps". On fait la boucle sur i, mais, 
		// précédemment, avec le schéma d'Euler, on a tout défini de telle sorte que les valeurs
// 		calculées soient x(dt), x(2dt), x(3dt), etc, de même pour x_point.
	{

cout << euler (t,y,dt,f) << endl;

	}
	return 0; 
}

Mais le compilateur me dit qu'en écrivant

f(y, deriv[N]); 
		{
		deriv[0]=y[1];
		deriv[1]=-w*w*y[0];
		}

j'essaie de convertir un float en un float*, et je ne comprends pas comment changer mon code.
Il me dit aussi, quand il exécture le cout du main, que f n'a pas été déclarée, mais comment je peux faire ? Comment rappeler que f est le void du début ?

[Chanur]

Je reprends ton programme en ajoutant mes remarques en bleu.

// EULER POUR RESSORT SIMPLE.

#include <iostream>
#include <string>
#include <stdio.h>
#include <fstream>
#include <math.h>
#include <cstdlib>
using namespace std;
#define w 1
#define N 2

void euler(float t, float y[N], float dt, void f(float dt, float t, float y[N]))
{


        /////////// Calcul des dérivées par une fonction f : //////

        double deriv[N];// Tableau des dérivées de taille 2 : 
        f(y, deriv[N]); Cette ligne lance la fonction f passée en argument à la fonction euler,
en lui donnant : 
- le pointeur y comme valeur pour dt,
- le float "deriv[N]" comme valeur pour t,
- et en ne donnant pas de valeur à y.
        {
        deriv[0]=y[1];           Ces deux lignes calculent deriv[0] et deriv[1]. Elle font partie de la fonction euler()
        deriv[1]=-w*w*y[0];  Le fait de les encadrer d'accolades ne change rien.
        }
Je présume que ce que tu voulais faire c'est définir f.
Mais ce n'est pas à l'intérieur de la fonction euler() que la définition devrait être
(pourquoi faire : on lui passe déjà la déclaration comme argument)
        // Schéma d'Euler : 
        
        y[0]=y[0]+deriv[0]*dt;// ou y[0]+=deriv[0]*dt
        y[1]=y[1]+deriv[1]*dt;
        ofstream ressortbis("ressortbis.res");
        ressortbis << y[0] << " " << y[1] << endl;
        ressortbis.close();

    }





int main()
{
    int i;
//     float deriv[N];--> Inutile
    float y[N];
    float t;float dt;
//     void z=f(y[N],deriv[N]);// Comment déclarer f ??
    cout << "Entrer la valeur du pas " ;
    cin >> dt;
    cout << "Entrer la valeur de x(0) " ;
    cin >> y[0];
    cout << "Entrer la valeur x_point(0) " ;
    cin >> y[1];
    for (i=0;i<100;i++)// "Appelle Euler par une boucle sur le temps". On fait la boucle sur i, mais, 
        // précédemment, avec le schéma d'Euler, on a tout défini de telle sorte que les valeurs
//         calculées soient x(dt), x(2dt), x(3dt), etc, de même pour x_point.
    {

cout << euler (t,y,dt,f) << endl;
Ici, f() n'est pas connue. Même si sa déclaration dans euler() avait été correcte,
elle ne serait pas visible en dehors de la fonction où tu l'as déclarée.
Pourquoi veux tu absolument que la définition de f() soit dans euler() ?
C'est rare de déclarer une fonction à l'intérieur d'une autre et ça m'étonne que ton cours dise ça.
D'autre part, tu essaies d'envoyer dans "cout" le retour d'une fonction qui ne retourne rien,
puisqu'elle est de type "void" ...

    }
    return 0; 
}

[andreuxyoupi]

(Désolé pour le retard)
En effet, f n'était pas dans euler, mais c'est ce que je croyais avoir compris dans l'énoncé (et ça ne me choquait pas autant qu'aujourd'hui). J'ai donc corrigé tout ce qu'il faut.
Le fin mot de cette pénible histoire, ça aura été ce programme-là, qui compile sans problèmes :

#include <iostream>
#include <string>
#include <stdio.h>
#include <fstream>
#include <math.h>
#include <cstdlib>
using namespace std;


/////////// Calcul des dérivées par une fonction f : //////

//double deriv[N]=Tableau des dérivées de taille N : 
void derivation(int N, float t, float y[], float dy[]) 
{
double w;
dy[0]=y[1];// deriv[i]=dy[i]
dy[1]=-w*w*y[0];
}

// Schéma d'Euler : 
void euler(int N, float t, float y[], float dt, void f(int, float, float[],float []))

{
float dy[N];
derivation(N,t,y,dy);
y[0]=y[0]+dy[0]*dt;
y[1]=y[1]+dy[1]*dt;
ofstream ressortbis("ressortbis.res");
ressortbis << y[0] << " " << y[1] << endl;
ressortbis.close();

}

int main()
{

int N=2; // Deux équations différentielles à intégrer.
int i;
double w=1.;


float y[N];
float t;float dt;

cout << "Entrer la valeur du pas " ;
    cin >> dt;
cout << "Entrer la valeur de x(0) " ;
cin >> y[0];
cout << "Entrer la valeur x_point(0) " ;
cin >> y[1];

for (i=0;i<100;i++)// "Appelle Euler par une boucle sur le temps". On fait la boucle sur i, mais, 
// précédemment, avec le schéma d'Euler, on a tout défini de telle sorte que les valeurs
// calculées soient x(dt), x(2dt), x(3dt), etc, de même pour x_point.
{

euler (N,t,y,dt,derivation);

}
return 0; 
}

Mais je tenais quand même à vous remercier, un très grand merci à tous ceux qui ont répondu !!

[fred1599]

Désolé, mais où est l'utilisation de f dans cette fonction ci-dessous ?

void euler(int N, float t, float y[], float dt, void f(int, float, float[],float []))

{
float dy[N];
derivation(N,t,y,dy);
y[0]=y[0]+dy[0]*dt;
y[1]=y[1]+dy[1]*dt;
ofstream ressortbis("ressortbis.res");
ressortbis << y[0] << " " << y[1] << endl;
ressortbis.close();

}

[andreuxyoupi]

f ou derivation, c'est la même fonction, dans euler est placée une fonction f quelconque, mais on se doute qu'on va la remplacer par derivation.

[fred1599]

Certes, question où j'attendais cette réponse, donc ma question est: À quoi sert le paramètre void f dans la fonction euler ?

[Chanur]

Moi, quand je compile, j'obtiens :

euler.cpp: In function ‘int main()’:
euler.cpp:40:8: attention : unused variable ‘w’ [-Wunused-variable]
euler.cpp: In function ‘void derivation(int, float, float*, float*)’:
euler.cpp:18:16: attention : ‘w’ is used uninitialized in this function [-Wuninitialized]
euler.cpp: In function ‘int main()’:
euler.cpp:58:28: attention : ‘t’ may be used uninitialized in this function [-Wuninitialized]

Enfin je dis ça, je dis rien, hein ...