Cherche à traduire en C un programme python — Les-mathematiques.net The most powerful custom community solution in the world

Cherche à traduire en C un programme python

Bonsoir
On m'a dit que si l'on connaît l'algorithmique et un langage de programmation, on peut facilement passer à un autre langage. Ce n'est pas le cas pour moi. Mon objectif est de programmer en C les 5 méthodes d'intégration dans un même programme (rectangles à gauche, rectangles à droite, rectangle de milieu, trapèze et Simpson). Je sais le faire en PYTHON, je veux que le programme me demande d'entrer la borne inférieure de l'intégrale, puis la borne supérieure de l'intégrale, puis le nombre n et enfin une fonction. Le résultat qui doit être affiché :
Une valeur approchée de l'intégrale par la méthode des rectangles à gauche est...
Une valeur approchée de l'intégrale par la méthode des rectangles à droite est...
...
Une valeur approchée de l'intégrale par la méthode de Simpson est.
Je débute le C. Est-ce que quelqu’un peut partager avec moi son code en C.
Je partage mon code en python ;  voici ce que j'ai fait et ça marche bien (s'il vous plait c'est très urgent).
def integration(a, b, n, f):
    h = (b-a)/n
    rect_gauche_result = 0
    rect_droite_result = 0
    rect_milieu_result = 0
    
    for i in range(n):
        x = a + i*h
        rect_gauche_result += f(x)*h
        
    for i in range(1, n+1):
        x = a + i*h
        rect_droite_result += f(x)*h
        
    for i in range(n):
        x = a + (i + 0.5) * h
        rect_milieu_result  += f(x)*h
    
    trapeze_result = (rect_gauche_result+ rect_droite_result)/2
    simpson_result =(1/6)*(rect_gauche_result+ rect_droite_result +4*rect_milieu_result)
    
    return  rect_gauche_result, rect_droite_result, rect_milieu_result,trapeze_result, simpson_result

a = float(input("Entrez la valeur de a : "))
b = float(input("Entrez la valeur de b : "))
n = int(input("Entrez le nombre  n  : "))
f = input("Entrez la fonction (exemple : x**2): ")
f = eval("lambda x: " + f)

result_rect_gauche, result_rect_droite, result_rect_milieu, result_trapeze, result_simpson = integration(a, b, n, f)

print("Resultat de la methode des rectangles à gauche : ",result_rect_gauche)
print("Resultat de la methode des rectangles à droite : ",result_rect_droite)
print("Resultat de la methode des rectangles au point milieu  : ",result_rect_milieu)
print("Resultat de la methode des trapezes : ",result_trapeze)
print("Resultat de la methode de simpson   : ",result_simpson)

Edit.  Après je dois améliorer l pour demander au programme de m'afficher  5 graphiques (la méthode, la fonction, les rectangles ou trapèzes ou la courbe de Simpson)
-------------------------------------------------------------------------------------------------------------------------------
Citation :  Je suis Jack 
«1

Réponses

  • Modifié (20 Jan)
    J'ai demandé à ChatGPT d'écrire la méthode des rectangles à gauche. Voici le résultat sans garanties : 

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

    int main() {
        double a, b, n, h, sum = 0.0;
        char f[100];
        void *evaluator;
        printf("Entrez la borne inférieure de l'intégrale : ");
        scanf("%lf", &a);
        printf("Entrez la borne supérieure de l'intégrale : ");
        scanf("%lf", &b);
        printf("Entrez le nombre de rectangles : ");
        scanf("%lf", &n);
        printf("Entrez la fonction à intégrer : ");
        scanf("%s", f);
        evaluator = evaluator_create(f);
        h = (b - a) / n;
        for (double x = a; x < b; x += h) {
            sum += evaluator_evaluate_x(evaluator, x) * h;
        }
        printf("La valeur de l'intégrale est : %lf\n", sum);
        evaluator_destroy(evaluator);
        return 0;
    }



    De plus il a ajouté les précisions suivantes : 

    Il est possible de permettre à l'utilisateur d'entrer une fonction sous forme de chaîne de caractères en utilisant une bibliothèque telle que <i>libmatheval</i>. Cette bibliothèque permet d'évaluer des expressions mathématiques saisies sous forme de chaînes de caractères...
    Il est important de noter que pour utiliser <i>libmatheval</i>, vous devez installer cette bibliothèque et inclure les fichiers d'en-tête appropriés dans votre programme. En outre, il est important de noter que cette méthode peut être moins précise que d'autres méthodes de calcul d'intégrales et peut avoir des limitations en termes de fonctions prises en charge.

    Voilà gebrane, fais du ChatGPT plutôt que du C... :mrgreen:
  • Bonsoir @raoul.S     C'est qui , quoi ... cette chose   chatGPT, j'étais absent du forum ?
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Ok d'après google c'est une IA, mais!
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Il y a un fil ICI. Tu peux créer un compte et essayer de parler avec. Il est assez fort pour écrire des petits programmes.
  • Au début j'ai cru que c’était une blague de ta part @raoul.S  en lisant parler avec .
    Merci  je vais parler avec ce bot
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Ton code Python est relativement simple, donc tu peux le traduire ligne par ligne en C. Il suffit que tu trouves les syntaxes analogues en C.
  • Je confirme : le script en Python n’utilise pas de classes pythoniques, rien que des nombres manipulables de la même manière en C.
    Sinon, tu peux essayer le module Freeze mais le code rendu en C sera moins facile à lire.
    Algebraic symbols are used when you do not know what you are talking about.
            -- Schnoebelen, Philippe
  • Modifié (21 Jan)
    Bonjour
    Que signifie ce "&nbsp"  dans le code Python ?
    Cordialement,
    Rescassol
    [J'ai supprimé le code "&nbsp" inutile (il spécifie une espace). AD]
  • MrJMrJ
    Modifié (21 Jan)
    En html, c’est l’espace insécable : Non Breakable SPace.
    Je pense que c’est juste un problème d’affichage (ça ne fait pas partie du code).
  • Modifié (21 Jan)
    J'ai un copain qui dans le cadre de son travail utilise déjà chatGPT. L'avis partagé par beaucoup de geeks(technophiles) est que chatGPT permet d'apprendre à faire ce genre de transcription (python à C) sans problème, même si on ne dispose de personne pour nous le montrer.
  • gebrane a dit :
    Bonsoir @raoul.S     C'est qui , quoi ... cette chose   chatGPT, j'étais absent du forum ?
    Bon sang, tu as raté le fil de l'année.

    Pour revenir à ta question, écrire sérieusement en C ne s'improvise pas du tout. D'ailleurs, on dit que quand il est sorti, des gens aurait râlé : "Oh non, encore un assembleur !" ChatGPT a dû beaucoup bosser pour y arriver.
  • Modifié (21 Jan)
    Puisque aucun humain   ne veut traduire mon code Python en C,
     [ mon problème est la syntaxe que je ne parviens pas à corriger pour l'appel et l'utilisation d'une fonction , si vous avez remarqué, mon code Python n'utilise aucune bibliothèque. Je répète donc mon Python est simple, le traduire pose un problème pour moi car il y a toujours des erreurs lors de la compilation ]
    J'ai donc tourné vers le bot indiqué par Raoul. C'est incroyable, ce bot remplacera probablement les meilleurs enseignants en informatique. Pour l'instant, le programme génère des erreurs et chaque fois ce bot les corrige, mais il y a encore des erreurs."
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • DomDom
    Modifié (21 Jan)
    Un enseignant en informatique n’a rien à voir avec un traducteur d’un script d’un langage dans un autre.
    C’est assez dingue de confondre ce qu’est un enseignant avec une personne qui a telle ou telle capacité technique. 
    Les titres des médias (au sens général) au sujet de ce ChatGPT sont très peu pertinents. 
    C’est comme si l’on avait dit jadis qu’un dictionnaire remplacerait un enseignant, ou qu’une encyclopédie remplacerait un enseignant, ou qu’un manuel scolaire du supérieur remplacerait un enseignant, ou qu’une calculatrice remplacerait un enseignant, ou qu’un logiciel de calcul formel remplacerait un enseignant, ou « qu’Internet » remplacerait un enseignant ou qu’un moteur de recherche remplacerait un enseignant. 
    Bref.
  • Modifié (21 Jan)
    Je suis tout-à-fait d'accord avec @Dom, étant enseignant moi-même. Aucune crainte d'ailleurs : Allègre avait essayé de répandre l'idée que l'existence des  calculatrices graphiques réduisait l'intérêt de l'enseignement des mathématiques. Je me rappelle la réaction outrée en autres de Laurent Schwartz, son collègue à l'Académie des sciences. La caravane de l'EN continue néanmoins à passer. L'épisode malheureux du précédent ministre dont j'ai déjà oublié le nom a déjà rejoint les oubliettes de l'histoire de l'EN.
  • gebrane, tu aurais dû poster aussi ton code en C, on l’aurait corrigé.
    Algebraic symbols are used when you do not know what you are talking about.
            -- Schnoebelen, Philippe
  • Non, on aurait demandé au chat venteux, pourquoi s'embêter.
  • Modifié (22 Jan)
    @nicolas.patrois   J'ai ta promesse donc :D.
    Je veux coder  sous C,  et pour ne pas faire long,  la méthode des rectangles à gauche avec  tracé de la fonction et rectangles. Je veux un résultat comme dans l'image où j'ai programmé la méthode ec Python sous l’environnement anaconda.

    Sous C je ne connais pas les bibliothèques que je dois utiliser et les instructions et syntaxe pour définir bien ma fonction f  . Voici un code mais je fixe f égale à x² et je ne sais comment implémenter le tracé de f et les rectangles

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

    double f(double x) {
        return x*x;
    }

    double rectangle_gauche (double a, double b, int n)
        {
        double h = (b - a) / n;
        double sum = 0;
        for (int i = 0; i < n; i++)
        {
            sum += f(a + i*h)*h;
        }
        return sum;
    }

    int main() {
        double a, b;
        int n;
        printf("On cherche une valeur approchée de l'intégrale de x² entre  a et b  ");
        printf("Donner a : ");
        
        scanf("%lf", &a);
        printf("Donner b : ");
        scanf("%lf", &b);
        printf("Donner le nombre de rectangles n : ");
        scanf("%d", &n);

        printf("Une valeur approchée par la méthode des rectangles à gauche est  %lf\n", rectangle_gauche(a, b, n));
    }



    Pour les curieux, vous pouvez copier  et coller ce code dans  ce compilateur en ligne https://www.programiz.com/c-programming/online-compiler/

     Je ne sais pas comment faire pour que le programme lise la fonction. Je ne veux pas utiliser ChatGPT pour ne pas dépendre de lui.
    Ce ChatGPT va créer une nouvelle génération de techniciens et ingénieurs ignorants, mais qui peuvent tout coder. Cela va créer une dépendance plus grave qu'une drogue. Le service étant gratuit au départ, il deviendra payant à l'avenir.



    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • DomDom
    Modifié (21 Jan)
    Encore une fois je ne suis pas d’accord. Cela ne va pas créer des ignorants. Je pourrais redire tous les exemples plus haut… (calculatrice, etc.). 
    En France du moins, on fabrique des ignorants, ça c’est certain mais c’est un autre sujet. 

    Cependant, il est bien possible que cela ne devienne payant. Je le crois peu… mais c’est envisageable. 
  • J'suis perdu dans l'noir comme un chat

    On m'a confié un TP d'analyse numérique Sur la programmation en C,

    C'est l'enfer

    J'plonge dans les livres, les tutos et les forums

    Espérant découvrir les secrets d'ce langage

     Mais chaque ligne d'code me paraît un abîme

     C'est l'enfer

    Et j'me sens comme un naufragé sur un rivage

    Et si demain, j'arrive pas à coder avec aisance

    Et maîtriser ce langage qui me semblait si étrange

    J'code en Python, mon amour, et j'laisse le C pour mes chéris apprentis.

     C'est l'enfer

    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • @Dom Si je ne répond pas à tes criques,  c'est que je suis confus avec les capacités de ce bot, c'est hallucinant. Il y a un chatgpt 4 qui va bientôt arriver plus puissant que cette version 3 
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • gebrane a dit :
    J'ai ta promesse donc :D.
    On≠je. :p
    Algebraic symbols are used when you do not know what you are talking about.
            -- Schnoebelen, Philippe
  • Si le  "on" dans ta phrase   "on l'aurait corriger"  n'est pas @nicolas.patrois , alors Je suis très curieux de voir ce "on" se manifester et je le remercie d'avance
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Ben, « on » concerne les lecteurs du fil, comme d’habitude.
    Quand quelqu’un pose un sujet d’exercice : on lui demande ce qu’il a fait et où il coince.
    Algebraic symbols are used when you do not know what you are talking about.
            -- Schnoebelen, Philippe
  • Amusant d’ailleurs, est-ce un travail à faire ? Est-ce un passe-temps ? Qui doit le faire ce travail ? Qui veut le faire ce passe-temps ?

  • Bon retour de ta retraite monastique, Gebrane.
    --->  ~ Heartbeat Heartbeat ~ www.youtube.com/watch?v=yogaAzfzpkk <---
  • Modifié (22 Jan)
    est-ce un travail à faire ? Oui
    ---------------------------------------
    Est-ce un passe-temps ? Non
    ---------------------------------------
    Qui doit le faire ce travail ? Moi
    --------------------------------------
    Qui veut le faire ce passe-temps ?
    Sont ceux qui ont la compétence, l'expérience et le temps libre.  Sont ceux  qui partagent  leur lumière.  Sont ceux qui ont acquis la sagesse des années et  peuvent transmettre leur savoir avec bienveillance et générosité. Sont ceux qui offrent Leur temps libre comme un cadeau précieux et surtout  avec bonheur . Sont ceux qui éclairent les autres, pour élever les esprits.
    --------------------------------------
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Alors bon travail 😀
  • Modifié (24 Jan)
    Content de te revoir @Positif . Je vais dévier mon propre fil à la demande implicite  de @Dom et @sato
    Je vais préciser dans ce fil la question que je voulais poser pour le jour 21 (j'ai eu un déplacement imprévu). La question, en fait, concerne un théorème qui joue le rôle d'une définition de l'intégrale d'une fonction continue sur un segment [a, b]. Je trouve cette définition élégante, rigoureuse et surtout simple (elle évite les notions de bornes inférieures et supérieures qui rebutent pas mal d'étudiants). Cette définition a été donnée dans un cours que j'ai consulté d'un professeur qui cherchait un consensus réussi entre rigueur et simplicité pour un public qui ne va pas se spécialiser en mathématiques. Il propose cette définition (en fait, un théorème) sans démonstration.
    Soit $f$ une fonction continue sur $[a, b]$ qu'on partage en $n$ segments $[x_i,x_{i+1}]$ à pas égaux $h=\frac {b-a}n$ on note $m_i =\min_{x\in [x_i,x_{i+1}]} f(x)$ et $M_i=\max_{x\in [x_i,x_{i+1}]} f(x)$ et on note $s_n^+$ la somme des aires des rectangles  au dessus de  la courbe : $s_n^+=h\sum_{i=0}^{n-1} M_i$ et $s_n^-$ la somme des aires des rectangles sous la courbe : $s_n^-=h\sum_{i=0}^{n-1} m_i$.
    Théorème-définition : les deux suites $s_n^+$ et $s_n^-$ convergent vers une même limite, que l'on note par définition $\int_a^b f(x) dx  $.
    Question. Démontrer le théorème. Vous pouvez sauter l’étape de prouver que  $\lim_{n \to +\infty} s_n^+- s_n^- = 0$ en utilisant l'uniforme continuité de $f$
    Il faut surtout démontrer que les deux suites sont convergentes, ce qui rend la définition rigoureuse. C'est une définition qu'on doit donner sans démonstration (car le prix à payer est un peu cher, elle s'adresse donc à un public qui ne va pas faire carrière en mathématiques) et (surtout ne pas croire que les deux suites sont adjacentes même si on suppose que $f$ est  positive)  je la trouve meilleure que  la définition qu'on donne  : que l'intégrale d'une fonction continue positive est par définition l'aire sous la courbe ou la définition qui dit que  $\int_a^b f(x) dx = F(b) - F(a)$ avec $F$ une primitive de $f$.
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Modifié (22 Jan)
    C'est pour quand ce travail ?
    ChatGPT sait-il donner une version en Assembleur de la famille x86 ?
  • Modifié (22 Jan)
    Samok c'est un TP que je dois assurer en semestre 2. Chatgpt a donné deux  solutions que je ne peux pas vérifier car il utilise des  bibliothèques que je ne connais pas matheval.h ou muparser.h  Je ne sais pas comment installer ces deux bibliothèques dans mon visual studio code.
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • ça va faire trop tôt pour moi, je n'ai pas encore bouclé ma formation en auto-didacte en assembleur.
  • dpdp
    Modifié (22 Jan)
    Fait à l'arrache en moins de 10 minutes, on peut sans doute faire mieux mais ça donne une idée de comment faire
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct integrale {
        double rect_gauche ;
        double rect_droite ;
        double rect_milieu ;
        double trapeze ;
        double simpson ;
    } integrale ;
    
    integrale integration(double a, double b, size_t n, double (*f) (double)) {
        integrale ni = { .rect_gauche = 0,
                         .rect_droite = 0,
                         .rect_milieu = 0,
                         .trapeze     = 0,
                         .simpson     = 0
                       } ;
    
        double h = (b-a)/n ;
    
        for(size_t i = 0; i < n;   i++) { ni.rect_gauche += f(a+i*h)*h ; }
        for(size_t i = 1; i < n+1; i++) { ni.rect_droite += f(a+i*h)*h ; }
        for(size_t i = 0; i < n;   i++) { ni.rect_milieu += f(a+(i+0.5)*h)*h ; }
    
        ni.trapeze = (ni.rect_gauche + ni.rect_droite)/2 ;
        ni.simpson = (ni.rect_gauche + ni.rect_droite + 4*ni.rect_milieu)/6 ;
    
        return ni ;
    }
    
    double square(double x) {
        return x*x ;
    }
    
    int main(int argc, char **argv, char **env) {
        integrale i = integration(3,4,100, square) ;
    
        printf("gauche: %lf\n", i.rect_gauche) ;
        printf("droite: %lf\n", i.rect_droite) ;
        printf("milieu: %lf\n", i.rect_milieu) ;
        printf("trapeze: %lf\n", i.trapeze) ;
        printf("simpson: %lf\n", i.simpson) ;
    
        return EXIT_SUCCESS;
    }
    
  • Modifié (22 Jan)
    Est-ce que c'est mieux, pareil ou pire de sommer $hf(\xi_i)$ ou bien de sommer les $f(\xi_i)$ avant de multiplier la somme finale par $h$ ?
  • dpdp
    Modifié (22 Jan)
    Je ne sais pas si tu t'adresses à moi @Math Coss, mais si c'est le cas, il suffit de tester (ce que j'ai fais à l'aide d'hyperfine)
    Pour le cas où on somme les $hf(\xi_i)$ on a
      Time (mean ± σ):       3.7 ms ±   0.7 ms    [User: 2.0 ms, System: 0.7 ms]
      Range (min … max):     2.9 ms …  16.5 ms    1000 runs
    l'exécution prend 3.7ms en moyenne.
    Pour le cas où on somme uniquement les $f(\xi_i)$ puis qu'on multiplie finalement par $h$ on a
      Time (mean ± σ):       3.6 ms ±   0.5 ms    [User: 1.9 ms, System: 0.8 ms]
      Range (min … max):     2.8 ms …   7.4 ms    1000 runs
    l'exécution prend... 3.6ms en moyenne.
    En conclusion, au moins ici, la multiplication vaut peanuts ;) et pourtant je n'ai pas une machine de guerre !
  • @dp Merci pour les dix minutes que tu as consacrées à ma question. Tu as lu rapidement et tu n'as pas compris mon problème. Tu as fixé la fonction f à x², mais je sais déjà le coder et nous n'avons pas besoin d'importer une bibliothèque. Ce que je veux, c'est un programme qui permet à l'utilisateur d'entrer sa propre fonction. Un problème de syntaxe.
    Est ce que quelqu'un connait un environnement pour C avec les bibliothèques que j'ai cité plus haut
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • Modifié (22 Jan)
    La question portait aussi un peu sur la précision. Le fait est qu'avec des méthodes en $O(1/n^4)$ au mieux, il faudrait un nombre exagéré de termes pour (au moins $10^8$ ou $10^{9}$ ?) que la précision finale risque d'être atteinte par des considérations sur le quinzième chiffre de chaque calcul. Encore que... si on se met à faire $10^7$ sommes ?
  • dpdp
    Modifié (22 Jan)
    @gebrane Je n'ai rien fixé du tout... tu peux très bien écrire une autre fonction du style $3x^3-198689765876x^2+\sin(x)-e^x$ ou que sais-je... je l'ai appelé square mais tu peux l'appeler $f$ si tu veux.
  • C'est vrai que le fait d'entrer $f$ "en dur" entraîne de devoir compiler chaque fois qu'on change de fonction, ce qui est un problème. Cependant, écrire un interpréteur de formules change radicalement le niveau du problème, même si on finit par dénicher une bibliothèque très sophistiquée. Me semble-t-il. 
  • Modifié (22 Jan)
    @dp Tu n'as pas compris . C'est le programme qui va te demander après exécution d'entrer la fonction f .
    Pour comprendre , peux-tu si tu as l'envie ( pour  comprendre ce que je veux exactement ) de copier mon premier  programme ( premier post)  ( Python) et l’exécuter sur https://www.programiz.com/python-programming/online-compiler/       
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • dpdp
    Modifié (22 Jan)
    On arrive en dehors de ce que sait faire le langage C "par lui même". Pour aller plus loin que que ça, et ne pas hard-coder la fonction, il faut commencer à utiliser ou coder parsers et lexers. Sauf qu'évidement, je ne vais pas faire ça en 10 minutes et j'ai une vie. :D
  • dpdp
    Modifié (22 Jan)
    Si tu veux aller plus loin sur ce terrain en C, tu peux essayer t'amuser avec GNU/bison (ou au moins Yacc)
  • @dp Merci encore une fois pour le temps  consacré. Je m'adresse à ceux qui connaissent déjà utiliser ces bibliothèques .
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • dpdp
    Modifié (24 Jan)
    ÉDIT: oups mauvais copier-coller
    Du coup j'ai cherché un peu et il existe tinyexpr qui pourrait te convenir
    Ça donne quelque chose comme ça
    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "tinyexpr.h"
    
    
    typedef struct integrale_t {
        double rect_gauche ;
        double rect_droite ;
        double rect_milieu ;
        double trapeze ;
        double simpson ;
    } integrale_t ;
    
    
    double integration_rectangle_gauche(const char *f, double a, double b, size_t n) {
        double result = 0 ;
        double h      = (b-a) / n ;
    
        for(size_t i = 0 ; i < n; i++) {
            double x = a+i*h ;
    
            te_variable var = {"x", &x} ;
            te_expr *expr = te_compile(f, &var, 1, 0) ;
    
            assert(expr != NULL && "An error has occurred when generating the function expression.\n") ;
    
            result += te_eval(expr) ;
            te_free(expr) ;
        }
        return result*h ;
    }
    
    double integration_rectangle_droite(const char *f, double a, double b, size_t n) {
        double result = 0 ;
        double h      = (b-a) / n ;
    
        for(size_t i = 1 ; i < n+1; i++) {
            double x = a+i*h ;
    
            te_variable var = {"x", &x} ;
            te_expr *expr = te_compile(f, &var, 1, 0) ;
    
            assert(expr != NULL && "An error has occurred when generating the function expression.\n") ;
    
            result += te_eval(expr) ;
            te_free(expr) ;
        }
        return result*h ;
    }
    
    double integration_rectangle_milieu(const char *f, double a, double b, size_t n) {
        double result = 0 ;
        double h      = (b-a) / n ;
    
        for(size_t i = 0 ; i < n; i++) {
            double x = a+(i+0.5)*h ;
    
            te_variable var = {"x", &x} ;
            te_expr *expr = te_compile(f, &var, 1, 0) ;
    
            assert(expr != NULL && "An error has occurred when generating the function expression.\n") ;
    
            result += te_eval(expr) ;
            te_free(expr) ;
        }
        return result*h ;
    }
    
    
    integrale_t integration(const char *f, double a, double b, size_t n) {
        integrale_t new_integrale = { .rect_gauche = 0,
                                      .rect_droite = 0,
                                      .rect_milieu = 0,
                                      .trapeze     = 0,
                                      .simpson     = 0
                                    } ;
    
        new_integrale.rect_gauche = integration_rectangle_gauche(f,a,b,n) ;
        new_integrale.rect_droite = integration_rectangle_droite(f,a,b,n) ;
        new_integrale.rect_milieu = integration_rectangle_milieu(f,a,b,n) ;
        new_integrale.trapeze = (new_integrale.rect_gauche + new_integrale.rect_droite)/2 ;
        new_integrale.simpson = (new_integrale.rect_gauche + new_integrale.rect_droite + 4*new_integrale.rect_milieu)/6 ;
    
        return new_integrale ;
    }
    
    
    int main(int argc, char **argv, char **env) {
        if(argc != 5)
        {
            fprintf(stderr, "This program takes exactly four arguments.\n") ;
            return EXIT_FAILURE ;
        }
    
        char *f = argv[1] ;
        float a = atof(argv[2]) ;
        float b = atof(argv[3]) ;
        size_t n = atoi(argv[4]) ;
    
        integrale_t integrale = integration(f,a,b,n) ;
        printf("gauche:  %.32lf\n", integrale.rect_gauche) ;
        printf("droite:  %.32lf\n", integrale.rect_droite) ;
        printf("milieu:  %.32lf\n", integrale.rect_milieu) ;
        printf("trapeze: %.32lf\n", integrale.trapeze) ;
        printf("simpson: %.32lf\n", integrale.simpson) ;
    
        return EXIT_SUCCESS;
    }
    Et pour l'utiliser, par exemple pour $f=e^{\cos(x)+\sin(x^2)}-23x^2+17x-194$, $a=2$, $b=4$, $n=10000$,

    programme "e^(cos(x)+sin(x*x))-23*x^2+17*x-194" 2 4 10000
    ce qui retourne
    gauche:  -714.25390610071917762979865074157715
    droite:  -714.35262809591404220554977655410767
    milieu:  -714.27809757559532499726628884673119
    trapeze: -714.30326709831660991767421364784241
    simpson: -714.28648741650249576196074485778809
  • Modifié (22 Jan)
    Bonsoir dp, Tu fais tourner ce programme dans quel IDE, le mien ne reconnais pas 
    tinyexpr.h
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • tinyexpr n'est pas standard en C, c'est une bibliothèque tierce (3rd party dependency).
  • Je vais voir comment l'installer sur mon visual studio code . Merci
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • dpdp
    Modifié (23 Jan)
    Petite remarque. J'ai corrigé les deux erreurs qui s'étaient glissées lors des calculs de rect_droite et rect_milieu et qui donnaient évidement des résultats incohérents (et qui me titillaient). En effet, il est invraisemblable d'avoir rect_milieu =  85.582871 pour $\int_{9}^{10} x^2 \mathrm{d}x$. Enfin, c'est maintenant corrigé ! Si ça intéresse quelqu'un, les erreurs étaient
    • pour rect_droite je démarrais la boucle à $0$ et non pas à $1$ (copier-coller quand tu nous tiens :D)
    • pour rect_milieu, une faute de frappe faisait que je multipliais $i$ par $0.5$ au lieu de l'additionner par ce même $0.5$.
    Enfin, j'ai réécris une dernière fois le code pour qu'il soit plus propre, plus lisible et qu'il gère un minimum les erreurs.
  • @dp je n'arrive pas à installer la bibliothèque , tu travailles sur quel ide et comment tu fais pour installer une bibliothèque
    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
  • D'entrée on voyait que la difficulté, c'était cette instruction eval() : on veut que le programme sache fonctionner avec n'importe quelle fonction, et donc il va devoir 'compiler à la volée' une fonction entrée par l'utilisateur. Le reste, c'est de la petite cuisine du quotidien, basique. Je ne connais pas C, et j'ai cherché sur mon vieux moteur de recherche : fonction eval Python en C   et des trucs comme ça ; j'ai pu voir que d'autres utilisateurs avaient éprouvé le même besoin, mais je n'ai pas trouvé de réponse satisfaisante. Je n'ai pas demandé à ChatGPT.
    Tu me dis, j'oublie. Tu m'enseignes, je me souviens. Tu m'impliques, j'apprends. Benjamin Franklin
  • @lourrran
    lourrran a dit :
    D'entrée on voyait que la difficulté, ... mais je n'ai pas trouvé de réponse satisfaisante. Je n'ai pas demandé à ChatGPT.

    j'ai posé la question au chat voici sa réponse

    Moi

    peux tu me donner l’équivalent en langage C de f = input("Entrez la fonction (exemple : x**2): ")
    f = eval("lambda x: " + f)

    Le chat
    Il n'y a pas d'équivalent direct en C pour la fonction input() de Python, car C est un langage de bas niveau, contrairement à Python qui est un langage haut niveau. Cependant, vous pouvez demander à l'utilisateur de saisir une chaîne de caractères correspondant à la fonction, puis utiliser une bibliothèque tierce comme tinyexpr pour évaluer cette chaîne en tant que fonction mathématique.

    Voici un exemple de code qui demande à l'utilisateur de saisir une fonction sous forme de chaîne de caractères, utilise tinyexpr pour évaluer cette fonction, puis l'applique à un argument donné:

    #include <stdio.h>
    #include <tinyexpr.h>

    int main() {
        char function[100];
        double x, result;

        printf("Entrez la fonction (exemple : x**2): ");
        scanf("%s", function);

        te_variable vars[] = {{"x", &x}};
        te_expr *expr = te_compile(function, vars, 1, 0);

        x = 2;
        result = te_eval(expr);
        printf("f(%lf) = %lf\n", x, result);

        te_free(expr);
        return 0;
    }

    Notez que vous devez installer la bibliothèque tinyexpr et inclure l'en-tête tinyexpr.h pour utiliser les fonctions décrites dans ce code .


    -------------------------------------------------------------------------------------------------------------------------------
    Citation :  Je suis Jack 
Connectez-vous ou Inscrivez-vous pour répondre.
Success message!