Wiki du LAMA (UMR 5127) - Contributions [fr]

Approximation numérique de calculs intégraux

2022-05-25T20:10:33Z

Emauti :

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes : les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutés à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes :
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangles consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des points du milieu consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des trapèzes consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode de Simpson consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différente pour le calcul des intégrales : le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n -ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associe à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'intégrale.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière :

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière :

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilité.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, s’il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier ce résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes :

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voire parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre important de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages :

- Il est très facile de la modifier pour, par exemple, passer d’une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des listes de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

Voici les lignes de codes qui permettent cela :

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation :

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi :

- on calcule une liste qui contient l'aire de tous les intervalles créés par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser :

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisables telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction :

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certain calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonction en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencé par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

Voici à quoi ressemble la fonction :

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes :

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes :
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d’une certaine fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réalisé une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créée.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante :

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisées ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R à R====

Nous avons donc réalisé un programme qui réalise cette méthode de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction :

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction :

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réalisé 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérifications, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions :

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réalisé une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction :

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créées, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions ont donc dû être modifiées :

=====Définition de l'espace de travail=====

Nous avons dû revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme :

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieu de 2, nous avons dû revoir leurs créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme :

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérifications, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions :

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quant à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-25T20:10:11Z

Emauti :

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes : les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes :
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangles consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des points du milieu consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des trapèzes consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode de Simpson consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différente pour le calcul des intégrales : le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n -ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associe à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'intégrale.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière :

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière :

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilité.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, s’il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier ce résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes :

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voire parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre important de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages :

- Il est très facile de la modifier pour, par exemple, passer d’une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des listes de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

Voici les lignes de codes qui permettent cela :

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation :

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi :

- on calcule une liste qui contient l'aire de tous les intervalles créés par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser :

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisables telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction :

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certain calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonction en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencé par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

Voici à quoi ressemble la fonction :

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes :

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes :
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d’une certaine fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réalisé une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créée.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante :

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisées ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R à R====

Nous avons donc réalisé un programme qui réalise cette méthode de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction :

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction :

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réalisé 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérifications, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions :

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réalisé une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction :

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créées, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions ont donc dû être modifiées :

=====Définition de l'espace de travail=====

Nous avons dû revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme :

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieu de 2, nous avons dû revoir leurs créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme :

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérifications, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions :

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quant à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-24T13:40:11Z

Emauti : /* Méthode des trapèzes */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des points du milieu consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des trapèzes consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode de Simpson consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

=====Définition de l'espace de travail=====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-24T13:39:59Z

Emauti : /* Méthode de Simpson */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des points du milieu consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode de Simpson consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

=====Définition de l'espace de travail=====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-24T08:52:22Z

Emauti : /* Méthode du point du milieu */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des points du milieu consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

=====Définition de l'espace de travail=====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:22:39Z

Emauti : /* Méthode de Monte-Carlo pour une fonction définie de R² à R */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

====Méthode de Monte-Carlo pour une fonction définie de R² à R====

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

=====Définition de l'espace de travail=====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

=====Création des points dans notre espace de travail=====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

=====Tronc principale de la fonction=====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:22:12Z

Emauti : /* Les méthodes probabilistes */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

=====Création des points dans notre espace de travail=====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

=====Vérification à l'appartenance du point à l'aire de la courbe=====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

=====Division=====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

=====Tronc principale de la fonction=====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:21:43Z

Emauti : /* Méthode de Monte-Carlo pour une fonction définie de R sur R */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R a R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:21:27Z

Emauti : /* La méthode de Monte-Carlo pour une fonction de R sur R² */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====Méthode de Monte-Carlo pour une fonction définie de R sur R====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:20:57Z

Emauti : /* Les programmes de calculs */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les méthodes probabilistes===

====La méthode de Monte-Carlo pour une fonction de R sur R²====

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

=====Définition de l'espace de travail=====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:19:32Z

Emauti : /* Les programmes de calculs */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les méthodes de quadratures===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T20:19:06Z

Emauti :

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

L'ensemble des fonctions et travaux que nous avons réalisés seront ajoutées à la partie annexe de cette page.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

==Annexe==

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-23T09:46:11Z

Emauti : /* Le calcul de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Chaque méthode possède une formule pour calculer leur erreur. Elle est définie par le rang de leur méthode, par la fonction dont on cherche l'intégrale et par la taille de l'intervalle où l'on calcule l'integralle.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:59:11Z

Emauti : /* Le calcul de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Cette fonction peut être décrite de la manière suivante:

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:58:10Z

Emauti : /* La fonction d'affichage de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

====La fonction d'affichage de l'erreur====

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

=====La fonction de calcul=====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

=====La fonction d'affichage=====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:57:13Z

Emauti : /* La fonction d'affichage */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

Pour une toutes les méthodes que nous avons à notre disposition, nous réalisons le calcul des erreurs commises par la machine selon un nombre de points qui varie.
Pour chacun de ces calculs, nous associons ces résultats avec chacune des méthodes utilisé ainsi que le logarithme du nombre de points utilisé pour chacun des calculs d'erreurs.
Enfin, nous affichons le résultat sous forme de graphique.

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:50:41Z

Emauti : /* La fonction de calcul */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

Cette fonction ce découpe en plusieurs étapes:

Pour un i allant de 0 à un certain nombre, nous réalisons les étapes suivantes:
- on récupère une liste de point découpant un intervalle <math>[a,b]</math> en i points
- on calcule l'intégrale d'une certaines fonction sur notre intervalle précédent
- on regarde l'écart entre la valeur obtenue par le calcul et la vraie valeur de l'intégrale de la fonction sur l'intervalle <math>[a,b]</math>
- on calcul de log de chacun de ces écarts
Puis nous renvoyons une liste des résultats obtenues.

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:43:02Z

Emauti : /* L'écriture des fonctions utilisables */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

Ces fonctions sont assez particulières, car elles utilisent une bibliothèque particulière de Python, qui se nomme numpy (ici représenté par le np).

Cette bibliothèque permet d'appliquer un certains calcul (ici sinus et exponentiel) sur une liste de valeur, ce que les fonctions sinus et exponentiel de la bibliothèque math de python ne permet pas.

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:17:24Z

Emauti : /* Liste de différentes méthodes étudiée */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(\frac{minimum Intervalle + maximum Intervalle}{2})</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

Le changement de la position du calcul du point "d'ancrage" du rectangle par rapport à la méthode des rectangles permet à cette fonction d'être aussi précise pour les fonctions polynomiales de degré 1 car l'erreur commise à gauche du point d'ancrage est le même à droite du point d'ancrage.

====Méthode des trapèzes====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 1. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{f(a) + f(b)}{2}</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode de Simpson====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction polynomiale de degré 2. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur <math> \frac{(b-a)}{6} \left[ f(a) + 4 f\left(\frac{a+b}2\right) + f(b) \right]</math> (ou a et b représentent les extrémités de l'intervalle de travail) et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T16:03:47Z

Emauti : /* Méthode des rectangles */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier, dans lesquels nous faisons l'hypothèse que notre fonction est une fonction constante. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur
<math>f(minimum Intervalle)</math> et de largeur la taille de l'intervalle. La somme de l'aire de ses intervalles est une approximation de l'intégrale de la fonction de travail sur notre intervalle de travail <math>[a, b]</math>.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T15:48:00Z

Emauti : /* Le calcul de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = - \frac{(b-a)^3}{12} f''(\eta), \quad \eta \in [a,b]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T15:47:16Z

Emauti : /* Le calcul de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-22T15:47:00Z

Emauti : /* Le calcul de l'erreur */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<center><math>E(f) = \frac{(b-a)^2}{2} f'(\eta), \quad \eta \in [a,b].</math></center>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T15:53:19Z

Emauti : /* Les programmes de calculs */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul pour un nombre de points donnés et une fonction de travail donnée.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T15:52:39Z

Emauti : /* Points faibles de la méthode */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.
- Ce nombre de point à calculer force le programme à être intrinsèquement (tous du moins, si on utilise le code que nous avons créé comme expliqué plus bas).

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:58:29Z

Emauti : /* L'écriture des fonctions utilisables */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:Sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Fichier:Sinus.png

2022-05-18T12:58:07Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:57:55Z

Emauti : /* L'écriture des fonctions utilisables */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:Exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Fichier:Exponentielle.png

2022-05-18T12:57:36Z

Emauti :

Fichier:MethodeMC2var.png

2022-05-18T12:55:19Z

Emauti :

Fichier:VerificationMonteCarlo2var.png

2022-05-18T12:54:03Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:53:50Z

Emauti : /* Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:53:16Z

Emauti : /* Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:CreationEspaceTravailMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:MethodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:52:30Z

Emauti : /* Définition de l'espace de travail */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:RecuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:CreationEspaceTravailMonteCarlo2var.png

2022-05-18T12:52:20Z

Emauti :

Fichier:RecuperationCoordoneeMonteCarlo2var.png

2022-05-18T12:52:13Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:51:50Z

Emauti : /* Tronc principale de la fonction */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:MethodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:MethodeMC.png

2022-05-18T12:51:28Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:50:38Z

Emauti : /* Division */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:DivisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:DivisionMonteCarlo.png

2022-05-18T12:50:27Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:50:04Z

Emauti : /* Vérification à l'appartenance du point à l'aire de la courbe */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:VerificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:VerificationMonteCarlo.png

2022-05-18T12:49:37Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:48:47Z

Emauti : /* Définition de l'espace de travail */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:CreationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:CreationEspaceTravailMonteCarlo.png

2022-05-18T12:48:30Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:48:03Z

Emauti : /* Les programmes de calculs */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:creationEspaceTravailMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:47:32Z

Emauti : /* Définition de l'espace de travail */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:RecuperationCoordoneeMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:creationEspaceTravailMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Fichier:RecuperationCoordoneeMonteCarlo.png

2022-05-18T12:47:12Z

Emauti :

Approximation numérique de calculs intégraux

2022-05-18T12:46:26Z

Emauti : /* La fonction d'affichage */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:afficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:recuperationCoordoneeMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:creationEspaceTravailMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:46:04Z

Emauti : /* La fonction d'affichage */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:fonctionAfficheErreurIntegrale.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:recuperationCoordoneeMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:creationEspaceTravailMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]

Approximation numérique de calculs intégraux

2022-05-18T12:45:49Z

Emauti : /* La fonction d'affichage */

Les calculs intégraux sont de nos jours beaucoup utilisés pour la création et la modification de modélisation d'éléments, ou permettre l'analyse de fonctions. Ces calculs sont parfois compliqués et nécessitent parfois beaucoup de travail. Pour nous aider, il nous est possible d'utiliser des machines qui peuvent réaliser ces calculs à notre place.

Pour cela, il nous faut construire des méthodes de calculs qui nous permettrons de réaliser ces calculs. Nous traiterons ici de 2 types de méthodes: les méthodes de quadratures de Gauss et les méthodes probabilistes.

==Les méthodes de quadratures==

===Explication ===

Les méthodes de Quadrature de Gauss permet de remplacer le calcul d'une intégrale par la somme pondérée prise en certains points du domaine d'intégration.

Selon les fonctions qui sont entrées en paramètre, ainsi que le degré de précision que nous souhaitons obtenir, il existe différentes méthodes pour permettre les calculs d'intégrations.

===Liste de différentes méthodes étudiée===

Nous étudierons ici plusieurs méthodes:
- la méthode des rectangles
- la méthode du point du milieu
- la méthode des trapèzes
- la méthode de Simpson

====Méthode des rectangles====

La méthode des rectangle consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f(minimum Intervalle)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode du point du milieu====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un rectangle de longueur ''f((maximum Intervalle + minimum Intervalle)/2)'' et de largeur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces carrés permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode des trapèzes====

La méthode du point du milieu consiste à créer une suite d'intervalles régulier. Nous utiliserons le point le plus petit de chaque intervalle pour créer un trapèze dont l'une des longueur est égale à ''f((maximum Intervalle)'', l'autre côté égal à ''f(minimum Intervalle)'' et de hauteur la taille de l'intervalle. Selon les méthodes de quadratures, la somme de l'aire de tous ces trapèzes permet d'approximer la valeur de l'intégrale de la fonction f.

====Méthode de Simpson====

test 252

===Différence entre les méthodes===

La plus grande différence entre toutes les méthodes est la précision des différentes méthodes atteintes avec un nombre d'intervalles donné.

Chacune de ces méthodes permet une précision différentes pour le calcul des intégrales: le nombre d'intervalle nécessaire pour obtenir un résultat de même précision est donc différent selon les méthodes.

Par exemple, la méthode de Simpson nécessitera un nombre d'intervalle plus petit que la méthode des rectangles pour que le résultat soit suffisamment précis.

===Les programmes de calculs===

====Le programme général====

Avant le calcul de notre intégrale, nous devons indiquer à notre fonction la taille des intervalles que nous allons calculer.

Pour cela, nous utilisons la bibliothèque numpy de Python, qui nous permet de créer des liste de nombres espacé d'une certaine valeur, toujours identique, et dépendant du nombre d'éléments dans la liste.

voici les lignes de codes qui permettent cela:

[[Fichier:calculIntervals.png]]

Le programme de calcul des différentes intégrales selon un nombre d'intervalle donné suit une procédure qui est toujours la même, malgré la méthode utilisée qui est différente.

Voici le programme de calcul après optimisation:

[[Fichier:troncPrincipal.png]]

Cette procédure fonctionne ainsi:

- on calcule une liste contenant l'aire de tous les intervalles créé par une méthode donnée pour une fonction donnée
- on additionne tous les éléments de cette liste
- on renvoie le résultat de cette fonction

====L'écriture des méthodes====

Chacune des méthodes que nous souhaitons utiliser sont ensuite implémenté dans le code.

Voici une liste des différentes méthodes que nous avons pu réaliser:

=====Méthode des rectangles=====

[[Fichier:methodeRectangle.png]]

=====Méthode du point du milieu=====

[[Fichier:methodePointMilieu.png]]

=====Méthode des trapèzes=====

[[Fichier:MethodeTrapeze.png]]

=====Méthode de Simpson=====

[[Fichier:MethodeSimpson.png]]

====L'écriture des fonctions utilisables====

Pour terminer, nous pouvons recréer les différentes fonctions utilisable telles que sinus, cosinus ou exponentielle.

Voici 2 exemples de telles fonction:

[[Fichier:exponentielle.png]]

[[Fichier:sinus.png]]

===Le calcul de l'erreur===

Toutes ces méthodes possèdent un taux d'erreur qui varie selon le nombre et la taille des intervalles utilisées ainsi que l'erreur intrinsèque de la méthode. L'erreur d'une fonction se calcule en partie sur la dérivé n ème de la fonction de travail, qui peut, selon certaines, être égal à 0 si on les associes à une certaine méthode.

Le calcul de l'erreur d'une fonction se définie ainsi:

<math>f(xi) + (x - xi)f^(n)(ui) , ui ∈[xi, xi + h]</math>

Ou n représente le n de la dérivé n ème de la fonction.

Pour la méthode des rectangles, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(0)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de base est une constante.

En comparaison, pour la méthode des trapèzes, le calcul de l'erreur s'écrit de cette manière:

<math>f(xi) + (x - xi)f^(2)(ui) , ui ∈[xi, xi + h]</math>

Après analyse du calcul, on peut remarquer qu'il est exact pour toute fonctions dont la formule de sa dérivée seconde est une constante.

===La fonction d'affichage de l'erreur===

Pour pouvoir réaliser une véritable comparaison entre ces erreurs, nous avons réalisé un programme qui calcul et trace sur un graphique l'évolution des erreurs de chaque fonctions en fonction du nombre de points utilisés pour faire les intervalles.

====La fonction de calcul====

Nous avons donc commencer par créer une fonction qui calcule le taux d'erreur d'une fonction selon le nombre de point qui à servit à faire le calcul.

voici à quoi ressemble la fonction:

[[Fichier:fonctionCalculErreur.png]]

test 252

====La fonction d'affichage====

Telle quelle, ces listes ne nous donnent pas beaucoup d'informations.

Nous avons donc réaliser une fonction supplémentaire qui nous permet d'afficher un graphe qui compare les différentes fonctions entre elles.

Voici la fonction ainsi créé.

[[Fichier:fonctionAfficheErreur.png]]

test 252

==Les méthodes probabilistes==

===Explication:===

Il existe une autre manière de réaliser le calcul d'une intégrale qui utilise la probabilitée.

Nous étudierons ici la méthode de Monte-Carlo.
Elle consiste, en quelques mots, à "jeter" des points sur un espace de définition donné, puis de vérifier, pour chaque point, si il appartient ou pas à l'aire sous la fonction. Nous réalisons ensuite une division du nombre de points qui appartiennent à cette aire par le nombre de point total que nous avons placé dans l'espace de travail.

Cela nous donnera la part de notre espace de travail qui est occupé par l'aire de la courbe de la fonction.

Il suffit ensuite de multiplier se résultat par l'aire de notre espace de travail pour obtenir une approximation de la valeur de l'intégrale d'une fonction pour un intervalle donnée.

===Points faibles de la méthode===

Cette méthode parait simple et facile d'utilisation en apparence, mais possède plusieurs problèmes:

- l'espace de travail doit être recalculer lors de chaque nouveau calcul pour bien correspondre à l'espace de définition de la fonction utilisée. En effet, si l'espace de calcul est trop petit ou trop grand, il sera impossible de calculer correctement, voir parfois d'espérer obtenir un résultat qui peut fonctionner correctement.
- Cette méthode peut réaliser en théorie n'importe quel calcul d'intégrale, mais nécessite toujours un nombre importants de point pour être vraiment efficace, et ce nombre augmente très vite par rapport à la taille de l'intervalle de travail.

===Points forts de la méthode===

Mais, malgré ces quelques problèmes, cette fonction possède plusieurs gros avantages:

- Il est très facile de la modifier pour, par exemple, passé d'une fonction définie de R à R à une fonction définie de R² à R.
- Si l'espace de travail est bien définie, et que le nombre de points que nous utilisons pour réaliser les calculs est assez grand, il est possible de réaliser n'importe quel calcul d'intégrale sur n'importe quelle fonction en entrée.

===Les programmes de calculs===

Nous avons donc réalisé un programme qui réalise cette méthodes de calcul.

====Définition de l'espace de travail====

Nous commençons tous d'abord par créer notre espace de travail selon l'intervalle ou nous souhaitons calculer notre intégrale ainsi que la fonction que nous allons utiliser.

Voici le code de cette fonction:

[[Fichier:recuperationCoordoneeMonteCarlo.png]]

====Création des points dans notre espace de travail====

Nous avons ensuite créé une fonction qui permet de terminer la création de notre espace de travail, en créant une liste de différend points placer aléatoirement appartenant à notre espace de travail.

Voici le code de cette fonction:

[[Fichier:creationEspaceTravailMonteCarlo.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Après cela, nous avons réaliser 2 fonctions de vérification pour connaitre l'emplacement d'un point par rapport à la courbe de notre fonction et à l'abscisse du graphique.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo.png]]

====Division====

Nous avons aussi réaliser une dernière fonction, qui permet de réaliser la division du nombre de point dans l'aire de la fonction par le nombre de points qui ont été mis sur l'espace de travail total.

Voici le code de cette fonction:

[[Fichier:divisionMonteCarlo.png]]

====Tronc principale de la fonction====

Une fois toutes ces fonctions créé, nous les avons associées toutes ensemble pour créer la fonction finale, qui permet de calculer l'intégrale d'une fonction selon un nombre de points à placer à l'intérieur ainsi que d'une fonction d'étude.

Voici le code de cette fonction.

[[Fichier:methodeMC.png]]

===Annexe: Méthode de Monte-Carlo pour une fonction définie de R² à R===

Dans le cadre de notre recherche sur la méthode de Monte-Carlo, nous avons pu réaliser une fonction qui, en exploitant le même fonctionnement que la fonction de Monte-Carlo, mais qui prend cette fois-ci une fonction définie de R² vers R.

Plusieurs fonctions on donc du être modifiées:

====Définition de l'espace de travail====

Nous avons du revoir la définition de notre espace de travail pour qu'il puisse créer un espace utilisable pour une fonction à 2 variables.

Voici le code de ce programme:

[[Fichier:recuperationCoordoneeMonteCarlo2var.png]]

====Création des points dans notre espace de travail====

Les points possédants désormais 3 coordonnées au lieux de 2, nous avons du revoir leur créations ainsi que leur positionnement dans l'espace de travail.

Voici le code de ce programme:

[[Fichier:creationEspaceTravailMonteCarlo2var.png]]

====Vérification à l'appartenance du point à l'aire de la courbe====

Les fonctions de vérification des points doivent aussi être modifier pour pouvoir obtenir correctement les valeurs rechercher.

Nous avons donc, grâce à ces vérification, obtenir le nombre de points qui appartiennent à l'aire de la courbe.

Voici le code de ces fonctions:

[[Fichier:verificationMonteCarlo2var.png]]

====Tronc principale de la fonction====

Le tronc principal, quand à lui, doit prendre en compte les nouvelles fonctions réalisées.

Voici le code de cette fonction.

[[Fichier:methodeMC2var.png]]