Problème méthode des trapèzes en C++ pour débutant

**Andromedae** · 08/11/2014, 10h40

Bonjour à toutes et à tous,

Voilà, actuellement en Master 1 de Physique, je dois suivre des cours de programmation en C/C++.
Ayant changé d'Université en septembre, j'arrive dans une faculté où les étudiants en Licence 3 Physique ont appris la programmation en C/C++, ce qui n'était pas mon cas dans mon ancienne fac. Autant dire que je suis un peu perdu, malgré que je bosse avec les pdf de cours.

Nous devons programmer un script sur la méthode des trapèzes. J'ai réussi à définir la surface d'un sous intervalle de ma fonction que j'ai découpé en N sous intervalles de longueur h.
Néanmoins, il faudrait que je puisse généraliser cela en faisant la somme des sous-intervalles.

Mathématiquement, je sais comment faire, mais je n'arrive pas à le retranscrire en programmation.
Je pense qu'il faille que je j'utilise des vecteurs, en sommant avec des indices i et une boucle for, mais j'aurais besoin d'un petit coup de pouce avec explications svp.

Voici mon code actuel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream> 
#include <cmath> 
 
using namespace std ; 
 
#include <cstdlib> 
#include <vector> 
#include "matprod.h" 
#include <fstream>
 
#include <stdlib.h>
 
#define PI 3.14159265 
 
#define DEBUG_MSG cerr << "DEBUG (" << __FILE__ << ", l." << __LINE__ << ") "
 
 
// Création de la fonction f(x)
 
//double f(double x) {
 
//return f(x) = sqrt(x); // f(x) = racine carrée (x)
 
//}
 
int main() {
 
int i,n;
double a,b,h,s1,x;
 
a = 1.0; /* Borne inférieure de l'intervalle */
b = 2.0; /* Borne supérieure de l'intervalle */	
n = 10; /* Nombre d'itération */
 
h = (b-a)/n; /* subdivision de la fonction en n sous intervalles de longueur h */
 
cout<<"J'ai découpé mon intervalle en N intervalles de longueur h = "<<h<<endl;
 
// On souhaite intégrer notre courbe dans un premier temps entre xmin = a et xmin + h
 
s1 = (sqrt(a + h) + sqrt(a))/2;
 
cout<<"La surface de mon premier trapèze est de "<<s1<<endl;
 
return 0;
}

En vous remerciant d'avance,

**bacelar** · 08/11/2014, 11h22

C et C++ sont des langages très différents.

Mettre les différentes valeur dans un std::vector<double> :
http://www.cplusplus.com/reference/vector/vector/

Les additionner avec la fonction numérique accumulate
http://www.cplusplus.com/reference/numeric/accumulate/

**Andromedae** · 08/11/2014, 11h30

Merci pour ta réponse

Oui différents mais peut être pas très différent ?
En tout cas merci des précisions, je vais tester et je reviendrai vers vous si je rencontre une autre difficulté

**ternel** · 09/11/2014, 10h13

Techniquement, quasiment tout code C écrit par un étudiant normal est compilable en C++.

Cependant, le C++ dispose de quelques mécanismes qui change tout.

Les classes, dont les classes standard, comme string, vector et map.
Le RAII, qui est un moyen de protéger des ressources (un fichier ou un pointeur) qu'on trouve en usage par exemple dans string et dans fstream (a peu près)
Les références (telles qui int& bidule) qui évitent la majorité des problèmes des pointeurs.

Je t'invite à lire notre FAQ, qui contient beaucoup d'explication sur comment bien faire les choses.

Par ailleurs, un bon outil est un site qui donne les références du langage. Personnellement, j'utilise cppreference, mais il en existe d'autres comme cplusplus.com.

N'hésite pas à fouiner dedans, ça te permettra de savoir ce qui existe déjà dans le langage.

**koala01** · 10/11/2014, 19h30

Salut,

Envoyé par Andromedae

Merci pour ta réponse

Oui différents mais peut être pas très différent ?

C'est bien là que tu te trompes!!!

A la base, C++ hérite des fonctionnalités de C, mais vouloir faire l'amalgame entre les deux revient à dire que le français est "peut être pas très différent" du latin parlé par Jules Cesar, sous prétexte que le français hérite du latin

Si tu veux, je pourrais utiliser une autre comparaison : d'un coté, un avion de la première guerre, mi bois- mi toile, muni d'un moteur pour le moins simpliste, et de l'autre un avion à réaction hyper sofistiqué

Ce sont deux avions, certes, et on peut espérer qu'ils voleront tous les deux en toute sécurité... Mais ce n'est pas parce que tu arrive à piloter en toute sécurité ton bi plan mi boi - mi toile que tu arriveras à piloter l'avion à réaction

**Andromedae** · 11/11/2014, 12h48

D'accord merci de ces précieux arguments

En revanche, je n'arrive pas à commencer mon programme du coup en utilisant les std::vector<double> x(taille) par exemple :/

**bacelar** · 11/11/2014, 14h59

std::vector est un conteneur à taille non fixe.
Si la taille est connue à la compilation, un std::array serait peut-être plus adapté.

pour un std::array :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
std::array<double,n> integral_par_partie;
...
integral_par_partie [i] = sqrt(i + h) + sqrt(i))
...
s1 = std::accumulate (integral_par_partie, integral_par_partie+n, 0)

**Andromedae** · 11/11/2014, 15h25

Merci beaucoup ! Je vais tenter de continuer mon programme grâce à votre aide.

**Ehonn** · 11/11/2014, 15h33

Envoyé par bacelar

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::accumulate (integral_par_partie, integral_par_partie+n, 0)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::accumulate(std::begin(integral_par_partie), std::end(integral_par_partie), 0)

**JolyLoic** · 11/11/2014, 21h18

Envoyé par bacelar

std::vector est un conteneur à taille non fixe.
Si la taille est connue à la compilation, un std::array serait peut-être plus adapté.

Même si la taille est connue à la compilation pour l'instant, je n'ai pas l'impression qu'elle ait vocation à l'être tout le temps : Je garderais vector pour l'instant.

**_zzyx_** · 12/11/2014, 09h37

Salut Andromedae,

J'ai été à ta place, puis à celle de tes enseignants. Donc juste quelque remarques

* 80 à 90 % des étudiants en physique (à Bac +3/4) ne font pas la différence entre du C et du C++. Avec un cours de 20h et au mieux un projet on se contente de survoler les bases (Entrée sortie texte sur console et fichier, boucles, fonctions, pointeurs, discrétisation d'intégrales et dérivées, et au mieux une introduction aux classes et à la POO) . Bref, tes enseignants ne t'en voudront pas si tu te prives de certains trucs pratique de C++. Malgré tout, si tu veux persister un peu dans cette voie (informatique scientifique) ne cherche pas à ré-inventer la roue. Il y a des gens bien meilleur que toi qui ont écrit la librairie standard(et d'autres lib) et tu seras pas capable de faire mieux donc n'hésites à t'en servir.

* Avant d'ecrire le code, commence par décomposer le programme en élément simple (écrit un algo quoi) sur papier. Je sais pas (et à prioris toi non plus) dans quel langage tu devras coder une fois diplômé, Savoir concevoir un algo (même simple) c'est une compétence qui te servira que tu codes en C++, Matlab, Python ou n'importe quel autre language. C'est donc plus utile que de connaitre le contenu de std::algorithm. D'ailleurs une partie de l'évaluation portera là dessus (bon évidemment si on t'a donné un document avec l'algo oublie mon explication). Note aussi que pour t'aider il faut savoir ce que tu veux faire (et souvent formaliser sa question sur un forum où autre aide à trouver la réponse)

* L'exercice que tu dois faire demande d'intégrer une fonction . (Donc mettre la fonction à intégrer dans une fonction est peut etre pas mal, en plus ca te simplifiera la vie lorsque tu voudras changer de fonction). Pour le reste tu as pleins d'indices au dessus et pas de questions précises. donc je te laisse y réfléchir

**Andromedae** · 12/11/2014, 17h22

Bonjour,

Merci pour vos informations tout à fait précises

Avec pas mal de temps passé dessus, puis de l'amélioration, voici ce que donne mon programme de méthode des trapèzes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//trapèze
 
#include <iostream>       // flux d'entrée
#include <iomanip>       // manipulateurs        
#include <cstdlib>      //  bibliothèque c standard
#include <math.h>
 
using namespace std;    //permet d'utiliser les flux cin cout
 
int main()
{
    //DECLARATIONS LOCALES
    float a,b,l,somme,integrale;
    int ind,n;
    //ACTIONS
    cout << "Calcul de l'integrale de sinx par la methode des trapezes."<<endl;
    cout << "Donnez les bornes de l'intervalle [a,b] : " << endl;
    cin >> a >> b;
    cout << "Donnez le nombre de points de calcul : ";
    cin >> n;
    l = (b-a)/n;
    somme = 0;
    for (ind = 1; ind <= n-1; ind = ind +1)
    {
        somme = somme + sin(a + ind*l);
    }
    integrale = l*((sin(a) + sin(b))/2 + somme);
    cout << "L'integrale de sinx dans l'intervalle" << "["<<a<<","<<b<<"]"<<" vaut : "<<integrale<<endl;
 
 
    //retour au système d'exploitation
    cout << endl ;
    system("pause");
    return(0);

Plus qu'à refaire la chose pour la méthode de Simpsons

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//Simpson
 
#include <iostream>       // flux d'entrée
#include <iomanip>       // manipulateurs        
#include <cstdlib>      //  bibliothèque c standard
#include <math.h>
 
using namespace std;    //permet d'utiliser les flux cin cout
 
int main()
{
    //DECLARATIONS LOCALES
    float a,b,l,somme,somme2,integrale;
    int i,n;
    //ACTIONS
    cout << "Calcul de l'integrale de sinx par la methode de Simpson."<<endl;
    cout << "Donnez les bornes de l'intervalle [a,b] : " << endl;
    cin >> a >> b;
    cout << "Donnez le nombre de points de calcul : ";
    cin >> n;
    l = (b-a)/n;
    somme = 0;
    for (i = 1; i <= n-1; i++)
    {
        somme = somme + sin(a + i*l);
    }
    for (i = 0; i <= n-1; i++)
    {
        somme2 = somme2 + sin(a + (l/2));
        }
    integrale = (l/6) * (sin(a) + sin(b) + 2*somme + 4*somme2);
    cout << "L'integrale de sinx dans l'intervalle" << "["<<a<<","<<b<<"]"<<" vaut : "<<integrale<<endl;
 
 
    //retour au système d'exploitation
    cout << endl ;
    system("pause");
    return(0);
}

Je ne trouve pas le même résultat donc je dois avoir une erreur dans mon opération mathématique je pense ^^

**ternel** · 13/11/2014, 11h52

Elle est bizarre ton intégrale par trapèze.

C'est quoi ce integrale = l*((sin(a) + sin(b))/2 + somme); après la boucle?

Ça ne colle pas avec mes souvenirs d'intégrales... foi d'ancien physicien

La méthode des trapèzes repose, si mes souvenirs sont bons, sur deux constats:
Premièrement, l'intégrale de f sur un intervalle [a,b] est égale à la somme des intégrales sur les intervales d'une partition de [a,b], c'est à dire sur [a, c1], [c1, c2]... [cn, b]

Deuxièmement, la limite de la différence entre l'intégrale de f sur un intervalle [a,b] et l'aire du trapèze défini par (a,0), (a, f(a)), (b, f(b)) , (b, 0) tend vers 0 quand b-a tend vers 0 (d'après les définitions de la dérivé et de l'intégrale)

Je pense que tu devrais réviser ta formule.

**Celiwan** · 13/11/2014, 14h25

Salut à tous!

Bizarrement, je suis également en master I et... Ce code m'est familier, nous devons être dans la même promotion...

Je viens ici car j'exporte le problème et le sujet à un niveau un peu plus haut : j'aimerais créer un outil intégrateur qui réunit les méthodes trapèze/simpson/monte-carlo en POO, à l'aide d'une classe prenant en argument l'intervalle d'intégration, le pas d'intégration et la fonction à intégrer. Rien de problématique de ce côté, sauf pour la fonction...

Ma question est donc : comment faire pour passer un fonction mathématique en argument d'une méthode de classe?

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <stdio.h>
#include <stdlib.h>
#include "time.h"
#include <iostream>
using namespace std;
 
class integrateur
{
	private :
	double x,y,a,b,f;
 
 
	public :
	// Création de la fonction
	void integrateur(double F);
	//Méthodes d'intégration
	double trapeze(double A, double B);
	double simpson(double A, double B);
	double monteCarlo(double A, double B);
	//Destructeur
	~integrateur();
}

Merci d'avance pour vos réponses!

**bacelar** · 13/11/2014, 14h42

Moi et les math, ça fait 12.

Question assez vague.

Je vois 2 axes de recherches "standard" :
- faire une classe template avec une classe de politics par méthode d'intégration => un objet/classe par méthode d'intégration.
- passer une fonction lambda à la méthode de calcul de l'intégrale, si la signature de la fonction d'intégration est la même quelque-soit la méthode.

Mais de base, je ne suis pas sûr de l'utilité d'une classe dans ces types de calcul.

**_zzyx_** · 13/11/2014, 15h06

Envoyé par Celiwan

Salut à tous!

Bizarrement, je suis également en master I et... Ce code m'est familier, nous devons être dans la même promotion...

Je viens ici car j'exporte le problème et le sujet à un niveau un peu plus haut : j'aimerais créer un outil intégrateur qui réunit les méthodes trapèze/simpson/monte-carlo en POO, à l'aide d'une classe prenant en argument l'intervalle d'intégration, le pas d'intégration et la fonction à intégrer. Rien de problématique de ce côté, sauf pour la fonction...

Ma question est donc : comment faire pour passer un fonction mathématique en argument d'une méthode de classe?

Deux lien pour te montrer comment tu peux passer une fonction en argument :

http://cpp.developpez.com/faq/cpp/?p...qu-un-foncteur

http://cpp.developpez.com/cours/cpp/

Envoyé par bacelar

Mais de base, je ne suis pas sûr de l'utilité d'une classe dans ces types de calcul.

Effectivement, je sais pas si une classe est utile pour si-peu, mais après tout puisque c'est un exercice.

**ternel** · 13/11/2014, 15h12

Sans faire une classe, j'ai composé un exemple "C++esque", je le peaufine un peu, mais voici une piste pour vous guider:
(le using étant une sorte de typedef, disponible depuis C++11 (-std=c++11), et permettant de travailler avec des templates)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace math {
namespace integrals {
 
template <typename FROM, typename TO = FROM>
using integration_f = TO (*)(TO (*f)(FROM x), FROM a, FROM b);
 
template <typename FROM, typename TO = FROM, typename D = FROM> 
TO integrate(TO (*f)(FROM), FROM a, FROM b, D dx, integration_f<FROM, TO> integration) {
	//retourne l'intégrale comme somme des intégrales sur des sous-intervales de taille dx
}
 
} //integrals::
} //math::

Pour donner un pointeur de fonction, il suffit de savoir que le nom d'une fonction est un pointeur vers celle-ci.
ainsi double (*f)(double) = std::sin déclare et initialise un pointeur vers une fonction prenant un double en argument et retournant un double.

**Andromedae** · 13/11/2014, 17h58

Pour te répondre leternel, voici la formule de la méthode des Trapèzes :
Il ne me semble pas l'avoir mal réécrite ?

Nom : dafdb7032beb7d1b1ca7817841aa8221.png
Affichages : 3357
Taille : 2,5 Ko

Celiwan : Peut-être, de quelle fac es tu ?

**ternel** · 14/11/2014, 10h33

Non, en effet, du moins, ca en a l'air.
Et je vois que cette formule a l'avantage de réduire les appels à la fonction à intégrer.

Sinon, tu peux l'écrire autrement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
float trapezes(float(*f)(float), float a, float b) {
	return (b-a) * (f(a) + f(b))/2;
}
 
que tu peux appeler ainsi:
unsigned int n = (b-a)/dx;
 
float somme = 0;
for (int i = 0; i < n; ++i) {
	float that = a + i*dx;
	somme += trapezes(f, that, that + dx);
}

Cette autre forme a l'avantage d'être directement généralisable à d'autres approximations que trapezes(), mais perd un petit peu de performance.

Par exemple, tu peux procéder ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
namespace math {
namespace integrals {
 
//j'utilise _f pour les typedef de fonctions.
 
template <typename FROM, typename TO = FROM>
using unary_f = TO (*)(FROM x);
 
template <typename FROM, typename TO = FROM>
using integration_f = TO (*)(unary_f<FROM, TO>, FROM a, FROM b);
 
template <typename FROM, typename TO = FROM, typename D = FROM> 
TO integrate(unary_f<FROM, TO> f, FROM a, FROM b, unsigned int n, integration_f<D, TO> integration) {
	if (a == b || n == 0) return 0;
	if (a > b) return -integrate(f, b, a, n, integration);
 
	D dx = (b-a)/n;
 
	TO somme = 0;
	for (int i = 0; i < n; ++i) {
		D that = a + i*dx;
		somme += integration(f, that, that + dx);
	}
	return somme + integration(f, a + n*dx, b);
}
}//integrals::
}//math::
 
namespace math {
namespace integrals {
 
template <typename FROM, typename TO = FROM> 
TO trapezes(unary_f<FROM, TO> f, FROM a, FROM b) {
	return (b-a) * (f(a) + f(b))/2;
}
 
}//integrals::
}//math::
using namespace mi = math::integrals
using namespace std;
 
int main() {
    cout << "intégrale de sinus sur [0, 4]" << mi::integrate(sin, 0, 4, 12, mi::trapezes<float>) << endl;
    return 0;
}

Problème méthode des trapèzes en C++ pour débutant

C++

Discussions similaires

Partager

Partager