Le mécanisme d'un logiciel de calcul formel - Page 2

lol

> Ceci dit, le projet est open-source, tu peux porter tes améliorations plutôt que troller sans fondement.
En effet, mais tu fais exprès de l'inviter à faire quelque chose que tu sais très bien qu'il ne fera pas, vu qu'il préférera bosser sur TIGCC (même s'il n'y fait pas grand chose)
Et tu es un vilain programmeur qui maintient la confusion dans les esprits: "open source" est un terme caca (c'est un fait !) parce que beaucoup trop vaste. Ton projet est mieux qu'open-source, voyons: il est sous La Seule Vraie Licence Vraiment Libre (GPLv3)

(Comment exploser encore plus un topic, qui a commencé à partir dans le décor de nouveau à la suite d'une intervention de Kevin, comme le topic traitant d'ETP Studio Open Source dans Actu - Divers et nombre de topics plus vieux )

Tant qu'on est lancé dans les trolls, je participe à l'ambiance :

squalyl (./24) :
on verra vite l'intéret quand il y aura un compilateur on calc. oui, ça c'est un vapor, mais quand elle se condensera, elle sera contente d'avoir un analyseur maison!

Tu parles d'un compilateur de quel langage ? Pour le C, il existe déjà un compilateur C embarqué qui marche très bien, téléchargeable en 1 clic sur le site de Pollux.

je parle d'ETP, qui est le sujet de conversation de ce thread, à l'inverse du C...

OK. C'est d'ailleurs dommage qu'il ait été codé en C++. Une source en C aurait permis la création d'un binaire sur TI68k.

Thibaut (./33) :
Tant qu'on est lancé dans les trolls,

d'un autre coté, est-ce qu'il ne serait pas plus profitable d'en sortir, des trolls en question, et de revenir au sujet ?

[edit] cross

./35 : sauf que si c'était pas l'objectif au départ (et manifestement ça ne l'était pas), se mettre à coder en C au lieu du C++ c'est perdre quand même pas mal de confort... (et de temps) :/

Je suis d'accord.

onur (./29) :
Ceci dit, le projet est open-source, tu peux porter tes améliorations plutôt que troller sans fondement.

Écoute, je suis en principe intéressé par un essai d'adaptation de ton frontend en un frontend GCC. (Ton backend 68k est un jouet totalement jetable par contre.) Le problème est que tu n'as pas compris qu'un projet de développement ouvert a peu d'intérêt si tu es le seul à comprendre ce que tu as écrit. Là:
* il n'y a pratiquement pas de commentaires,
* tu as réinventé la roue pour tokéniseur et parseur au lieu d'utiliser des générateurs qui prennent en entrée une représentation lisible des regexes et grammaires; du coup, si par exemple on veut changer quelque chose dans tes tokens, on est obligé d'effectuer des modifications sur toute la source (parce que oui, une telle modification peut complètement changer l'automate de reconnaissance que tu as choisi de coder en dur) au lieu de corriger un seul regex Flex et
* il y a des tonnes de répertoires où la seule manière de savoir ce qu'est dedans est la méthode trial&error.
GCC est déjà difficilement maintenable, mais là ton projet est pire, alors qu'il est loin d'avoir les fonctionnalités de GCC, voire même les fonctionnalités que tu prévois. Je n'ose pas imaginer ce que ça va donner comme bordel quand ton projet sera fini.

Maintenant, il y a peut-être moyen que moi, je m'en sorte avec le code source tel qu'il est maintenant (mais il faudra aussi que j'y trouve un intérêt; là, j'ai l'impression que le mieux pour aboutir à un frontend GCC maintenable pour ton langage, c'est de repartir une fois de plus de zéro), mais quelqu'un qui a moins d'expérience en C/C++ (et aussi en maintenance de code non maintenable ) que moi (et ce sont sans doûte les personnes les plus susceptibles d'être intéressées par ETP) sera totalement perdu.

Le code est comprehensible par n'importe qui qui se connait en compilation, joue pas l'ignorant.

Bah, tu connais combien d'experts en compilation ici? Toi, moi, Pollux, qui d'autre?
Un nouveau développeur n'aura forcément pas ton expérience en termes de compilation (et encore moins la mienne), tu présupposes beaucoup trop d'expertise là.

Quant aux problèmes de maintenabilité, voilà encore un exemple: tu nous codes un parseur maison, mais nulle part n'y a-t'il écrit quelle grammaire il est censé parser! Pour savoir ça, il faut suivre tout ton code et reverse-engineerer la grammaire. Où est ta grammaire en EBNF? Si tu avais utilisé Bison, elle y serait automatiquement. Mais même pour ton recursive descent maison, des commentaires avec la grammaire en EBNF ne feraient pas de mal! Si tu as codé ça sans avoir de grammaire formelle du tout, je ne peux que réitérer que c'est de la bidouille!

Kevin, arrête d'insulter les autres et leur travail ! Tu te prends pour qui ?? Si t'es pas content du sors de ce sujet, mais respecte un peu l'effort, le travail, le talent des autres.
De plus :

Kevin Kofler (./41) :
Bah, tu connais combien d'experts en compilation ici? Toi, moi, Pollux, qui d'autre?

Toi, expert en compilation ? Tu n'as jamais écrit de compilateur. Quand tu auras fait un travail aussi imposant et aussi complexe que celui des codeurs de GCC, ou que Pollux que tu cites, on pourra en reparler

Un nouveau développeur n'aura forcément pas ton expérience en termes de compilation (et encore moins la mienne), tu présupposes beaucoup trop d'expertise là.

Bravo pour ta non-modestie, voir ta prétention.

En même temps je pense qu'il a quand même une bonne expérience de la compilation.

Onur > C'est possible que tu donnes ta grammaire en EBNF ?

Sasume (./43) :
En même temps je pense qu'il a quand même une bonne expérience de la compilation.

Même si il était expert en compilation, son attitude resterait inacceptable vis à vis du travail d'Onur, Thibaut a raison...

lol merci pour toutes ces réponses. Franchement, vous m'aidez fort bien.

NON, je ne vais pas programmer. C'est un dossier que je rends fin de mois et le présenter oralement. Moi étant plus spécialisé hardware, la programmation pour moi c'est au dessus.
Je vais regarder tout cela cette après-midi. Je ne manquerai pas de vous demander des infos ou me faire corriger qqch Mais normalement, je devrai m'en sortir seul

Merci @ tous et bon dimanche.

Sasume (./43) :
En même temps je pense qu'il a quand même une bonne expérience de la compilation.

Onur > C'est possible que tu donnes ta grammaire en EBNF ?

J'ai les graphes d'état sur papier quelque part, faut que je retrouve.

Thibaut (./42) :
Toi, expert en compilation ?

Je maintiens le portage TIGCC de GCC depuis 2002.

Tu n'as jamais écrit de compilateur.

Alors déjà j'ai écrit un compilateur simple dans un cours de compilateurs à l'université. (En revanche, ça a été avec Lex et Yacc (imposé, mais j'aurais de toute façon choisi de les utiliser si on m'avait laissé le choix). Je suis tout à fait capable d'écrire un scanneur et parseur maison, mais Lex/Flex et Yacc/Bison simplifient de loin la tâche et le code est plus lisible.) Mais contrairement à Onur, je n'ai pas la prétention de considérer un tel compilateur jouet prêt à l'emploi pratique. Et ensuite, il ne faut pas avoir écrit un compilateur tout seul pour s'y connaître, on peut aussi travailler sur un projet de compilateur beaucoup plus grand (et donc plus utile en pratique!) comme je le fais.

Quand tu auras fait un travail aussi imposant et aussi complexe que celui des codeurs de GCC

Je pense que pas mal des développeurs de GCC ne font pas plus que moi. (Bien sûr, il y en a qui le font, mais ils sont payés pour ça!) C'est le nombre qui compte. Ce n'est pas du tout le modèle de développement "loup solitaire"! Et tu sous-estimes de loin mon travail, je suis tout seul sur le portage TIGCC de GCC!

Un nouveau développeur n'aura forcément pas ton expérience en termes de compilation (et encore moins la mienne), tu présupposes beaucoup trop d'expertise là.

Bravo pour ta non-modestie, voir ta prétention.

J'ai 5 années d'expérience en compilateurs, Onur 2 années.

Tu n'as pas l'air de comprendre la différence entre:
* travail et connaissances. (Il n'y a pas que ce que j'ai écrit qui est important, mais aussi ce que j'ai lu et maintenu.)
* travail fourni et résultat obtenu. (Un problème que Onur a aussi, il me dit toujours qu'il a travaillé plus sur ETP que moi sur TIGCC, c'est possible, mais ça ne change pas que son résultat est moins bon parce qu'il réinvente la roue!)

(EDIT: Il manquait "que" dans "Il n'y a pas que ...")

Kevin Kofler (./39) :
Écoute, je suis en principe intéressé par un essai d'adaptation de ton frontend en un frontend GCC. (Ton backend 68k est un jouet totalement jetable par contre.) Le problème est que tu n'as pas compris qu'un projet de développement ouvert a peu d'intérêt si tu es le seul à comprendre ce que tu as écrit. Là:
* il n'y a pratiquement pas de commentaires,
* tu as réinventé la roue pour tokéniseur et parseur au lieu d'utiliser des générateurs qui prennent en entrée une représentation lisible des regexes et grammaires; du coup, si par exemple on veut changer quelque chose dans tes tokens, on est obligé d'effectuer des modifications sur toute la source (parce que oui, une telle modification peut complètement changer l'automate de reconnaissance que tu as choisi de coder en dur) au lieu de corriger un seul regex Flex et
* il y a des tonnes de répertoires où la seule manière de savoir ce qu'est dedans est la méthode trial&error. GCC est déjà difficilement maintenable, mais là ton projet est pire, alors qu'il est loin d'avoir les fonctionnalités de GCC, voire même les fonctionnalités que tu prévois. Je n'ose pas imaginer ce que ça va donner comme bordel quand ton projet sera fini.

Là, tu apportes des éléments. En faire un frontend GCC est une très bonne idée, bravo. Effectivement les specs manquent, je pense que devant cette bonne volonté de ta part Onur va se faire un plaisir de ressortir ses brouillons. Dans cette situation un parseur yacc/bison sera en effet bien plus pratique. Il ne s'agit plus de dénigrer le travail effectué mais de le seconder et de le faire évoluer. Bravo.

Thibaut (./42) :
Toi, expert en compilation ? Tu n'as jamais écrit de compilateur. Quand tu auras fait un travail aussi imposant et aussi complexe que celui des codeurs de GCC, ou que Pollux que tu cites, on pourra en reparler

ceci est une phrase de trop Thibaut, Tu sais comme moi qu'il n'est pas très utile de jeter de l'huile sur le feu!
Déja tu ne sais pas tout ce qu'a fait chacune des personnes concernées (quand même pour patcher un compilateur aussi complexe que gcc, il faut autant de compréhension que pour en écrire un, surtout que les modifications apportées sont loin d'être triviales)

Soyons donc clairs:
- pour le projet en l'état, le parseur maison est parfait car customisé est plus simple
- si on a envie d'en faire un frontend gcc, il est largement conseillable de le reprendre en C/bison/yacc.
Je pense qu'Onur sera intéressé par toutes les propositions, s'il s'agit d'aides à l'amélioration, et qu'on ne le braque pas !

message à tout le monde: il ne s'agit pas de se critiquer mutuellement, mais
- pour le gens qui sont dans le sujet, d'apporter des idées constructives, donc merci Kevin
- pour les "observateurs" genre Thibaut, Lionel, etc... ce serait mieux de pas jeter de l'huile sur le feu, rappeler les vieux démons passés, lancer des attaques perso, etc... Je sais que vous allez y faire attention!

Quel diplomate!!

Je suis ok.

je sais pas.

mais en tout cas je trouve triste de voir plein de gens compétents perdre leur temps en se tapant dessus à cause de comportements immatures passés.
Il y a tellement de choses à faire!

> mais en tout cas je trouve triste de voir plein de gens compétents perdre leur temps en se tapant dessus à cause de comportements immatures passés.
Pas toujours aussi passés que ça, même si l'intensité a diminué.
> Il y a tellement de choses à faire!
Oui, voir ce que je viens de poster dans le topic "frère" de celui-ci dans Actu-Divers

La derniere phrase de ./8 et le post ./9 ont été de trop dans ce topic, mea culpa.

Si vous voulez bien, on continue le débat uniquement dans le topic "frère" dans actu-divers, puisque Magical42 a eu sa réponse now.

onur (./52) :
Si vous voulez bien, on continue le débat uniquement dans le topic "frère" dans actu-divers, puisque Magical42 a eu sa réponse now.

Entièrement d'accord, nous sommes totalement hors sujet ici.

Topic sur ETP: topics/100946-etp-studio-open-source

Bonsoir à tous.

Question à onur. Merci pour ton exemple
Dans ton arbre de tokens (lors de l'analyse syntaxique), tu proposes ceci

             +-<sqrt >-(
             |         +-<474 >
      +-<- >-|
      |      |      +-<c >
      |      +-</ >-|
      |             +-<b >
-<+ >-|
      |      +-<5 >
      +-<* >-|
             +-<32 >

Ne penses-tu pas que la solution est celle-ci conernant l'expression mathématique 32*5+b/c-sqrt(474) ?

      +-<- >-+-<sqrt >-<474 >
      |
      |      +-<c >
      +-</ >-|
      |      +-<b >
-<+ >-|
      |      +-<5 >
      +-<* >-|
             +-<32 >

Bonne soirée

heu... ton "+" a trois opérandes là ?

Les deux arbres représentent la même expression, mais les opérateurs de onur (+, -, *, /) sont binaire, toi tu as un + ternaire par exemple, et ton moins est unaire.
Après c'est toi qui choisis ce qui t'arrange : tu peux gérer des opérateurs à plus de 2 opérandes et considérer qu'une soustraction est une addition d'un nombre négatif

Je pense que l'arbre devrait plutôt ressembler à ça :

      +-<sqrt >-(
      |         +-<474 >
-<- >-|
      |             +-<c >
      |      +-</ >-|
      |      |      +-<b >
      +-<+ >-|
             |      +-<5 >
             +-<* >-|
                    +-<32 >

Pour cet exemple, l'arbre d'onur est équivalant, mais si on inverse le plus et le moins, la priorité des opérateurs n'est pas respectée.

Ah oui en effet, je vois très bien.
Les opérations les plus importantes, dites prioritaires, se font en bas et on remonte jusqu'à la racine ou sommet de cet arbre pour les opérations simples (additions et soustractions).
D'accord je vois l'enjeu. Si une expression mathématique a des parenthèses imbriquées, ou que l'analyse linéaire en ajoute pour obtenir le niveau de priorité, on trouvera ces opérations prioritaires tout en bas de l'arbre.

Je vois bien cet aspect là. Et d'autres questions me viennent à l'esprit. Après m'avoir illustré le fonctionnement avec un calcul numérique (exemple d'onur), comment le logiciel peut interprêté ces expressions suivantes :

# Avec une matrice [A]*[B] contenant n lignes et p colonnes. Exemple.

+-      -+                                 +-                        -+
|  2   3 |    +-                -+      |  11    4   -1   13    |
|  0   7 | *  |  1   2   1   5 |  = |  21    0   -7      7  |
| -5   1 |     | 3   0  -1   1 |      |  -2  -10   -6  -24 |
+-      -+    +-               -+     +-                          -+  

Le traitement formel se fera lui aussi en arbre ou alors si on sait que n lignes et p colonnes constiuent une matrice, un logiciel mathématique utilisera les propriétés d'un tableau ?


# Avec une fonction mathématique pour calculer la primitive d'une intégrale suivante

             +- 0
             |         -2x+2
f(x) =  |      -e         dx
             |
           -+ -1
 
                                                                       -2x+2
sachant que la primitive de x |--> -e     

                                         1   2-2x
est la fonction  x |--> - e 
                                         2

                                           2   4
                                         e   e
La réponse est F(x) = - - -
                                         2   2 

Merci et bonne journée.
Dav

Euh, ton truc est illisible, pourrais-tu utiliser http://prettyprint.free.fr (ou un service similaire) s'il te plaît?

pour les matrices, tu peux dire que l'opération + est capable d'opérer sur des types complexes, et parser les matrices. Bof.

poiur le calcul formel c'est mieux.
Imagine l'arbre à partir des parenthèses

f(x) = integrale(expression,variable,min,max)
=integrale(moins(exp(expression)),x,-1,0)

=integrale(
     moins(
          exp(
               somme(
                    produit(-2,x),
                    2)
          )
     ),
     x,
     -1,
     0)

et après tu parcours l'arbre.

je dois calculer une intégrale(fonction,variable,min,max)

dans l'arbre, tu vas remplacer cette expression par le sous arbre:
soustraction(evaluation(primitive(fonction,vaiable),max), evaluation(primitive(fonction,variable),min)

puis tu recommences à parcourir l'arbre

il faut maintenant calculer une soustraction de deux expressions

on commence par la premiere

il faut calculer une evaluation, donc remplacer une variable par une valeur et faire les simplifications

l'expression est une primitive. Il faut calculer l'expression correspondante.
tu ressors tes livres de maths pour calculer

primitive( exp(-2x+2) , x)
la primitive d'une exponentielle c'est quoi?

exp(u(x)) -> ?
je sais plus