Forum TI-Planet.org

Bonjour,

j'ai un souci avec un programme que j'ai crée, mon problème est plus précisément dans une fonction de calcul formel pour des formules complexes (comme je suis un étudiant en Génie civil = Génie calcul) j'ai besoin de répété ce genre d'opération très souvent

alors j'ai crée une fonction (void formule(char *form)) qui reçoit la formule a calculer "quelque soit sa complexité" en chaîne de caractères
et la transforme en une expression dans le estack avec le (push_parse_text (form)) pour l'afficher en pretty print jusqu’à ici tout ce passe bien..ma fonction prend la formule et l'affiche en pretty print, sauf que je dois par la suite remplacer les variables de cette formule par leur valeurs (i.e X^2/(Y+3) doit afficher si X=1 et Y=2 : 1^2/(2+3)) mais quand j'affecte a mes variables X et Y des valeurs en C (i.e int X=2) cela ne change rien dans ma formule et mon programme affiche (X^2/(Y+3))

en gros je veux que cette fonction affiche la formule avec les variables, ensuite avec les variables "remplacer avec leurs valeurs", pour finir et afficher le résultat final. mais je suis coincé, j'ai lu toute les documentation de TIGCC j'ai rien compris pratiquement les tuto ne parle pas de ça je suis confus aidez moi SVP

Voila le code de ma fonction :

Code: Select all

void formule(char *form)
{
   int pos=0,key=0 ;

  TRY
// affichage de la formule  ////////////////

do
  {
    push_parse_text (form);
    WinClr (DeskTop);
    Print2DExpr (Parse2DExpr (top_estack, FALSE), DeskTop, pos, 50);
   
   
     key = ngetchx();
     if (key ==344)
     pos = pos-40;
     if (key ==338)
     pos = pos+40;
   }
  while (key != 264);
// calcule numerique /////////////////////////////
   //je ne sais pas quoi ecrire ici :(
   
  ONERR
    DrawStr (20, 20, "Error!", A_NORMAL);
  ENDTRY
}

ps: j'ai une TI 89 Titanium (et excuser ma façon de s'exprimer je suis nouveau sur le forum)

Affecter des valeurs à des variables dans ton programme C ne changera la sortie du CAS que si tu propages ces variables en utilisant la fonctions appropriée
C'est push_substitute_simplify, éventuellement sa version sans simplification. Je déconseille l'utilisation de la version "such_that", plus complexe et moins bien documentée. Ces fonctions réalisent l'opérateur '|' du TI-BASIC, que tu peux utiliser dans l'écran HOME ou dans un programme BASIC, sous la forme expr("x+y" | x=1 and y=2), qui rendra 3, ou 3., selon le mode.

Petites remarques sur ton code:
* TRY / ONERR / ENDTRY quand tu fais de la programmation CAS, c'est bien;
* tu devrais utiliser les (pseudo-)constantes KEY_* de kbd.h plutôt que des codes de touche non portables comme 344 et 338, sans quoi ton programme, si tu le diffuses, sera difficile à utiliser sur 92+/V200;
* si la fonction à transformer t'est passée sur la ligne de commande, il te faudra vérifier, avec les fonctions et macros d'args.h, que tu as bien reçu une chaîne de caractères, avant de la passer à push_parse_text;
* pour être cohérent entre la partie TRY et la partie ONERR, tu devrais utiliser WinStr et non DrawStr

PS: TIGCC n'est plus maintenu depuis des années. GCC4TI (voir ma signature) a davantage de fonctions, notamment pour le calcul formel, plus d'optimisations, et moins de bugs...

salut, et merci pour votre réponse Mr Lionel je telecharge GCC4TI pour l'instant.

sinon pour la fonction push_substitute_simplify même si ça marche je pourrais jamais crée une fonction qui peut changer le nombre de variable en fonction de l'expression de ma formule, j'aurais aimé si vous partagez plus de détaille a propos de cette fonction, merci d'avance !

même si ça marche je pourrais jamais crée une fonction qui peut changer le nombre de variable en fonction de l'expression de ma formule

push_substitute_simplify() peut être appelée plusieurs fois avec une seule variable à remplacer à chaque fois. Ou alors, il faut modifier la chaîne de caractères derrière le '|' sous forme de chaîne de caractères, avant de passer le tout à push_parse_text() - mais tu auras alors un peu moins de contrôle sur les simplifications.

Il y a au moins deux façons de gérer plusieurs variables à remplacer sans s'embêter: passer au programme l'expression + un argument par substitution, ou passer au programme l'expression + une liste de substitutions. Plus concrètement:

Code: Select all

prg("Y")
prg("X", "X=1")
prg("X+Y", "X=1","Y=2")
prg("X+Y+Z", "X=2","Y=1","Z=3")

Code: Select all

prg("Y")
prg("X", {"X=1"})
prg("X+Y", {"X=1","Y=2"})
prg("X+Y+Z", {"X=2","Y=1","Z=3"})

La première façon de faire n'est accessible qu'en C/ASM, les programmes BASIC ne gérant pas les arguments variables. La différence entre les deux façons de faire est minime.
Tu pourrais également demander à l'utilisateur de rentrer des expressions après le démarrage de ton programme, mais c'est plus de travail.

Aussi, pourrais-tu nous décrire ton besoin complet, à la fois en termes de fonctions et en termes de contraintes éventuelles ? C'est à dire, ce que doit faire ton programme, et si tu as vraiment besoin, par exemple, de vitesse d'exécution.
Je pose la question car pour l'instant, je n'ai pas encore compris exactement pourquoi tu fais un programme C plutôt qu'un programme BASIC
On peut parfois faire mieux en utilisant des fonctions plus bas niveau que le BASIC (c'était le cas de ma réécriture en C d'une implémentation du delta^2 d'Aitken), mais le développement du code C/ASM prend nettement plus de temps, et le programme C/ASM est en général plus gros qu'un programme BASIC lisible (= avec des espaces et des noms de variables qui font bien plus d'une lettre).

Lionel Debroux wrote:Aussi, pourrais-tu nous décrire ton besoin complet, à la fois en termes de fonctions et en termes de contraintes éventuelles ? C'est à dire, ce que doit faire ton programme, et si tu as vraiment besoin, par exemple, de vitesse d'exécution.
Je pose la question car pour l'instant, je n'ai pas encore compris exactement pourquoi tu fais un programme C plutôt qu'un programme BASIC
On peut parfois faire mieux en utilisant des fonctions plus bas niveau que le BASIC (c'était le cas de ma réécriture en C d'une implémentation du delta^2 d'Aitken), mais le développement du code C/ASM prend nettement plus de temps, et le programme C/ASM est en général plus gros qu'un programme BASIC lisible (= avec des espaces et des noms de variables qui font bien plus d'une lettre).

Comme je le disais, je suis un étudiant en génie civil et ça m'arrive très souvent de rencontré des formules de calcule trop long là ou je dois remplacer une dizaine/voir vingtaine de variable et réécrire la formule . je me suis mis alors a crée un programe en TI basic mais il m'a fallu quelques secondes pour réaliser que TI-BASIC simplifie toujours les expression qu'on lui donne, et parce-que moi j'ai besoin de remplacer les valeur dans ma formule sans changer quoi que se soit, je tant ma chance avec le C qui me parait beaucoup plus vaste que le TI-BASIC
et puisque ce genre de formule est utilisé dans plusieurs modules, j'ai préféré crée une fonction qui prend seulement l'expression de la formule en "string" et l’évalue en 3 étapes :

1) Affichage de la formule tel qu'elle est (i.e X^2/(2+1)) en pretty print bien sure ^^
2) Affichage de la formule on remplacent les variables mais sans aucune simplification mathématique c.a.d pour X=6 (6^2/(2+1))
3) Affichage de résultat finale en valeur approx (donc pour mon exemple 12)

PS: dans l’étape (2) je veux que ma fonction récupére les variable de ma fonction main

Mécanique statique? Donc tu va devoir gérer entre 2 et 6 inconnues?

gildasd wrote:Mécanique statique? Donc tu va devoir gérer entre 2 et 6 inconnues?

non pas tout a fait ça, oui parfois des problème de la statique (RDM surtout) mais plus de formule de vérification (reglementaire) du genre Mcr "photo jointe" et parfois de la dynamique des structure Help please

Compris. L'absence de simplification est donc vraiment importante dans ton cas d'utilisation, et il te faut en effet la puissance de l'accès plus bas niveau, en premier lieu push_substitute_no_simplify() certainement, que je n'ai jamais utilisée mais qui doit s'utiliser comme les deux autres...

Avec 10 - 20 variables à substituer, rien que le fait de rentrer les paires {nom, valeur} des variables est du boulot. Est-ce que des dialogs te sembleraient pratiques ?

Lionel Debroux wrote:Compris. L'absence de simplification est donc vraiment importante dans ton cas d'utilisation, et il te faut en effet la puissance de l'accès plus bas niveau, en premier lieu push_substitute_no_simplify() certainement, que je n'ai jamais utilisée mais qui doit s'utiliser comme les deux autres...

Avec 10 - 20 variables à substituer, rien que le fait de rentrer les paires {nom, valeur} des variables est du boulot.

J'avoue que ça va prendre du temps mais si vous avez une meilleur solution a proposer je suis preneur

Lionel Debroux wrote: Est-ce que des dialogs te sembleraient pratiques ?

là j'ai pas compris par contre ^^

"dialogs" = Boîtes de dialogue du langage TI-Basic.