Petites questions - Page 1

J'aimerais savoir s'il y a un moyen d'utiliser la fonction 'expr()' du basic en C:
exemple:
j'ai une chaine de caractères qui contient "DrawStr (5, 60, "Bonjour", A_NORMAL);" et j'aimerais pouvoir faire expr("DrawStr (5, 60, "Bonjour", A_NORMAL);").

J'aimerais aussi savoir comment calculer un PGCD et un PPCM. Dans la doc de TIGCC je n'ai trouvé que ca : enum Tags {...};
A2 GCD_TAG expr2 expr1 gcd
A3 LCM_TAG expr2 expr1 lcm

Je comprends pas trop comment l'utiliser. Si quelqu'un sait l'utiliser, pourait-il m'expliquer.

Merci

MULO

est ce une chaine de caractères : "DrawStr (5, 60, "Bonjour", A_NORMAL);"

Moi j'en vois 2, séparé par des caractères 'B' 'o' 'n' ect ...
Aussi, il n'y a pas de fonction expr() en C, on procède autrement lorsqu'on connait la nature du prob. Explique un peu plus dans quel cas tu veux faire ça et on tachera de trouver une alternative à expr()

Oui c'est vrai c'est un mauvais exemple.
en fait ca ne sera que du style:
"(a&b)|(c&!d)" par exemple.

en fait c'est pour faire un tableau de Karnaught pour ceux qui connaissent. J'ai fait un editeur d'equation (c'est des équations logiques avec des variables et les operateurs OU ET OU_EXCLUSIF).
Et maintenant je veux traduirent l'equation qui est de la forme "(a.b)+(c.d/)" en "(a&b)|(c&!d)" et ensuite faire les calculs pour les differentes valeurs des variables. et pour cela j'ai besoin de expr (a moins que vous voyiez une autre méthode ?)

MULO

Ha non y'a pas de fonction pour ça !

Il va te falloir coder un analyseur syntaxique. Bon courage

Nan si tu te limites aux quatres opérateurs logiques OR/AND/XOR/NOT et le support des expression parenthésées, ça ne devrait pas être trop dur

tu peux le faire facilement en utilisant du pseudo-objet recursif

struct obj{char *str;struct obj *child;}

pour chaque niveau recursivement tu calcule la valeur de l'expression

A ok . Comme je suis un debutant je pense que je vais mettre de coté ce projet.

Sinon pour le PGCD et le PPCM.

J'ai fait une fonction qui prends environ 10sec a me retourner le resultat pour des valeurs avoisinant les 1000. Donc c'est pas du tout satisfaisant.

Est ce que qq1 a une meilleur solution que celle-ci: (ca existe forcement)

int pgcd (int a, int b){
int gcd=0, i=1, sortie = 0;

if (fmod(a,b) == 0) { //Si b divise a, b est le PGCD
gcd = b;
sortie = 1;
}

if (fmod(b,a) == 0) { //Si a divise b, a est le PGCD
gcd = a;
sortie = 1;
}
if ((a-b == 1) || (b-a == 1)) { //S'il y a une difference de 1 (abs(a-b)=1) 1 est le PGCD
gcd = 1;
sortie = 1;
}

while (sortie == 0) { //Sinon on se tape cette super boucle de fou!
if ((fmod(a,i) == 0) && (fmod(b,i) == 0))
gcd = i;
if (i == a || i == b)
sortie = 1;
i++;
}

return gcd;
}

Voila merci

MULO

Déjà je trouve que c'est plus clair comme ça :

int pgcd (int a, int b)
{
  int gcd=0, i=1, sortie = 0;

  if (fmod(a,b) == 0) //Si b divise a, b est le PGCD
  {
    gcd = b;
    sortie = 1;
  }
    
  if (fmod(b,a) == 0) //Si a divise b, a est le PGCD
  {
    gcd = a;
    sortie = 1;
  }
  
  if ((a-b == 1) || (b-a == 1)) //S'il y a une difference de 1 (abs(a-b)=1) 1 est le PGCD
  {
    gcd = 1;
    sortie = 1;
  }    
          
  while (sortie == 0) //Sinon on se tape cette super boucle de fou ! #triso#
  {
    if ((fmod(a,i) == 0) && (fmod(b,i) == 0)) gcd = i;
    if (i == a || i == b) sortie = 1;
    i++;
  }
  
  return gcd;
}

Isn't it ?

Certes certes.

Mais ca prend toujours autant de temps .

Mais pour t'aider il faut qu'on comprenne ton code


On peut au moins optimiser pas mal l'implémentation :

1- les calculs en virgule flottante sont inutiles ! Remplace tous les fmod par l'opérateur %
2- l'utilisation d'une variable booléenne décidant de l'interruption de la boucle n'est pas une méthode efficace
3- le test (a-b == 1 || b-a == 1) a des chances d'être effectué plus rapidement si on l'écrit (a-b == 1 || a-b == -1) car GCC y reconnaît un motif répété deux fois (a-b) et ne génère qu'une soustraction. Peut-être optimise-t-il aussi (a-b == 1 || b-a == 1) mais dans le doute...

int pgcd (int a, int b)
{
  int gcd=0, i=2;
  
  if (a % b == 0) //Si b divise a, b est le PGCD
    return b;
  
  if (b % a == 0) //Si a divise b, a est le PGCD
    return a;
  
  if (a-b == 1 || a-b == -1) //S'il y a une difference de 1 (abs(a-b)=1) 1 est le PGCD
    return 1;
  
  while (TRUE) //Sinon on se tape cette super boucle de fou ! #triso#
  {
    if ((a % i) == 0 && (b % i) == 0)) gcd= i;
    if (i == a || i == b) return gcd;
    i++;
  }
}

Il y a moyen d'aller encore plus vite en optimisant l'algorithme. Le plus efficace est l'algorithme d'Euclide je crois.

Impressionnant !

Comme quoi en changeant peu de chose (enfin c'est comme ca que je le vois ) ca fait la difference!
Maintenant ca prend environ 0.01 sec (meme pas calculable)

Je vais pouvoir jarter les premiers tests: a-b==1 ... juste laisser la boucle.

Merci beaucoup ca va me faire bien avancé reste plus qu'a ce que je trouve l'algo pour le PPCM

Thibaut : même si normalement GCC optimise ça if (b % a == 0) , il vaut tout de même mieux mettre if (!(b % a))

J'ai testé avec pgcd(12547, 32569) et il me renvoie 0 comme PGCD (PGCD >= 1)

D'ou l'erreur peut elle venir ?

Pim89 : à mon avis non. Ca nuit à la lisibilité alors qu'on sait qu'aujourd'hui tous les compilos optimisent ce test.
De même tu ne me verras jamais écrire x << 3 mais x*8 : tous les compilateurs intègrent cette optimisation de base. Ma devise c'est "pourquoi faire compliqué si on peut faire simple, pour un même résultat"


MULO : je serais tenté de dire que c'est à cause de la valeur 32569, mais elle reste en dessous de la limite 2^16/2, donc

Thibaut >> oui, c vrai, d'où la précision dans mon post que GCC faisait ça. mais bon, maintenant je suis habitué, donc je met mes >> et mes ! partout

D'après le code,

while (TRUE) //Sinon on se tape cette super boucle de fou !   
{
  if ((a % i) == 0 && (b % i) == 0)) gcd= i;
  if (i == a || i == b) return gcd;
  i++;
}

S'il renvoie quelque chose, on sait déjà que (i == a || i == b) est vérifiée. Comme on renvoie gcd qui est égal à i, et que ça renvoie zéro, alors i égale 0.
Donc a égale 0 ou b égale 0.


Si tes paramètres sont bien 12547 et 32569, alors le problème vient d'ailleurs : de la manière dont tu les obtient.

Montre le code de saisie des paramètres.

En fait c'est un test que j'ai fait pour verifier le fonctionnement de la fonction, donc qqpart dans le programme j'appelle simplement la fonction comme ca:
...
res = pgcm(12549, 13494);
sprintf (buffer, "PPCM = %d", res);
WinStrXY(&w1,4,62,buffer);
...

Pour info je me suis souvenu de mon cours de TS le PPCM c'est tres simple quand on a le PGCD : PPCM(a,b) = (a*b)/PGCD(a,b)

Mais la pareil: avec ces deux 'enormes' nombres ca renvoie un nombre negatif dans les 1000 et quelques (ou plutot 1000 moins quelques ).

Si ton algo est bon (j'ai la flemm: de vérifier), alors il y a un bug dans TIGCC

Tu peux poster le '.s' généré par TIGCC ? merci

Le .s ca se trouve ou ca ?
Il y a une option pour generer ca ?
je n'ai trouvé aucun .s

Mais ca doit surement venir de moi. Une fois sur deux mon prog me fait planter la calc (un plantage assez original en plus).

Sinon, l'algorithme d'Euclide est beaucoup plus rapide et peut s'implémenter de manière récursive. Tu connais la récursivité ? c'est passionnant Tu as l'algo d'Euclide ?

Oui oui je connais l'algo d'Euclide. c'est vrai ca peut etre moins compliqué

Maintenant mon probleme c'est le PPCM car pour des nombres comme 500 et 1000 pour le PPCM il faut les multiplier et diviser par le PGCD et 500*1000 ca fait trop (enfin je sais pas... la TI accepte des chiffres plus grand ?)


Sinon, voila le fichier .s

.file "spelab.c"
#NO_APP
.data
tigcc_compiled.:
.set _A_LINE,0xA000
#APP
/* Main Startup Code */
.even
.set __min_num_ROM_CALLs__,0x3CC
.ifdef __test_for_calc_num__
.err
.endif
.set __test_for_calc_num__,1
.xdef _main
_main:
move.l 0xC8,%a0
/* Calculator Detection */
moveq #1,%d0
move.l %a0,%d1
and.l #0x400000,%d1
jbne __calc_in_d0__
clr.w %d0
move.l (%a0,0x2F*4),%a1 /* ScrRect */
cmp.b #200,2(%a1)
jblt __calc_in_d0__
moveq #3,%d0
__calc_in_d0__:
cmp.w #__test_for_calc_num__,%d0
jbeq __calc_is_OK__
pea.l __wrong_calc__
jbra __display_message_and_exit__
__calc_is_OK__:
/* Minimum AMS Version Check */
cmp.l #__min_num_ROM_CALLs__,(%a0,-4) /* TIOS_entries */
jbcc __ams_version_is_OK__
__ams_version_not_OK__:
pea.l __ams_too_low__
__display_message_and_exit__:
move.l (%a0,0xE6*4),%a0 /* ST_helpMsg */
jsr (%a0)
addq.l #4,%sp
jmp _ROM_CALL_51 /* ngetchx */
__ams_version_is_OK__:
jbsr __main
rts
.xdef __save__sp__
.even
__save__sp__:
.long 0
.even
__wrong_calc__:
.asciz "Wrong calculator model"
.even
__ams_too_low__:
.ascii "AMS "
.ascii "1.01"
.asciz " or higher needed"
.even
#NO_APP
.globl _comment
.data
_comment:
.ascii "SpeLab v0.0.1 by MULO" //La grande classe
#APP
.xdef _ti92plus
/* Include Patch: _detect_calc_ */
/* Include Patch: _test_for_specific_calc_ */
/* Include Patch: _test_for_92p_ */
/* Include Patch: _dont_need_calculator_var_ */
/* Include Patch: _MIN_AMS_required_ */
/* Include Patch: _MIN_AMS_1_01_ */
/* Include Patch: doors_patch */
/* Include Patch: no_retval */
/* Include Patch: save_the_sp */
/* Include Patch: doors_no_very_simple_main */
/* Include Patch: complex_main */
.set MT_TEXT,0x8000
.set MT_XREF,0x9000
.set MT_ICON,0xA000
.set MT_CASCADE,0x4000
.data
.even
.LC15:
.word 40
.word 20
.word 200
.word 100
#NO_APP
.LC0:
.ascii "SPELAB"
.LC1:
.ascii "1.Base (conversion de nombres)"
.LC2:
.ascii "2.Systeme (avec PGCD et PPCM)"
.LC3:
.ascii "a.systeme avec a+b=? et PGCD(a,b)=?"
.LC4:
.ascii "b.systeme avec axb=? et PGCD(a,b)=?"
.LC5:
.ascii "c.systeme avec a+b=? et PPCM(a,b)=?"
.LC6:
.ascii "d.systeme avec axb=? et PPCM(a,b)=?"
.LC7:
.ascii "e.systeme avec PGCD(a,b)=? et PPCM(a,b)=?"
.LC8:
.ascii "3.Autre (Euclide, Nbre 1er)"
.LC9:
.ascii "a.Algorithme d'Euclide"
.LC10:
.ascii "b.Nombre premier ?"
.LC11:
.ascii "4.About"
.LC12:
.ascii "5.Quitter"
.LC14:
.ascii "A propos de SPELAB"
.LC16:
.ascii "SPELAB v0.2.C"
.LC17:
.ascii "By MULO"
.LC18:
.ascii "6 Aout 2002"
.LC19:
.ascii "Programme pour la specialit351"
.LC20:
.ascii " Maths de terminale:"
.LC21:
.ascii "PGCD, PPCM, Nbre premier"
.LC22:
.ascii "Algorithme d'Euclide"
.LC23:
.ascii "PPCM = %d"
.LC13:
.ascii "Ca marche pas encore :þ"
.even
.globl __main
__main:
#APP
move.l %sp,__save__sp__
#NO_APP
link.w %a6,#-108
movm.l #0x1f3c,-(%sp)
clr.w -98(%a6)
move.w #130,%d5
move.w %d5,-100(%a6)
move.w %d5,%d4
move.w %d5,-102(%a6)
move.w %d5,-104(%a6)
move.w #50,-106(%a6)
move.w %d5,%d6
move.w %d5,-108(%a6)
move.w #60,%a5
moveq.l #70,%d7
.L12:
jbsr _ROM_CALL_19E
move.w #2,-(%sp)
lea _ROM_CALL_18F,%a3
jbsr (%a3)
move.w #1,-(%sp)
pea .LC0
move.w #10,-(%sp)
move.w #84,-(%sp)
lea _ROM_CALL_1A9,%a2
jbsr (%a2)
move.w #1,-(%sp)
jbsr (%a3)
move.w #1,-(%sp)
pea .LC1
move.w #30,-(%sp)
move.w #5,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
pea .LC2
move.w #40,-(%sp)
move.w #5,-(%sp)
jbsr (%a2)
lea (34,%sp),%sp
clr.w -(%sp)
jbsr (%a3)
move.w #1,-(%sp)
pea .LC3
move.w -100(%a6),-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
pea .LC4
move.w %d5,-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
pea .LC5
move.w -102(%a6),-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
lea (32,%sp),%sp
move.w #1,-(%sp)
pea .LC6
move.w %d4,-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
pea .LC7
move.w -104(%a6),-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
jbsr (%a3)
move.w #1,-(%sp)
pea .LC8
move.w -106(%a6),-(%sp)
move.w #5,-(%sp)
jbsr (%a2)
lea (32,%sp),%sp
clr.w -(%sp)
jbsr (%a3)
move.w #1,-(%sp)
pea .LC9
move.w -108(%a6),-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
pea .LC10
move.w %d6,-(%sp)
move.w #10,-(%sp)
jbsr (%a2)
move.w #1,-(%sp)
jbsr (%a3)
move.w #1,-(%sp)
pea .LC11
move.w %a5,-(%sp)
move.w #5,-(%sp)
jbsr (%a2)
lea (34,%sp),%sp
move.w #1,-(%sp)
pea .LC12
move.w %d7,-(%sp)
move.w #5,-(%sp)
jbsr (%a2)
jbsr _ROM_CALL_51
move.w %d0,%d3
lea (10,%sp),%sp
cmp.w #49,%d0
jbeq .L15
.L5:
cmp.w #50,%d3
jbeq .L16
.L6:
cmp.w #51,%d3
jbeq .L17
.L7:
cmp.w #52,%d3
jbeq .L9
cmp.w #97,%d3
jbeq .L9
.L8:
cmp.w #53,%d3
jbeq .L11
cmp.w #264,%d3
jbne .L2
.L11:
move.w #1,-98(%a6)
jbra .L2
.even
.L9:
pea .LC14
move.w #4120,-(%sp)
pea .LC15
lea (-96,%a6),%a3
move.l %a3,-(%sp)
jbsr _ROM_CALL_1E
move.w #1,-(%sp)
move.l %a3,-(%sp)
lea _ROM_CALL_13,%a2
jbsr (%a2)
move.l %a3,-(%sp)
jbsr _ROM_CALL_1
move.w #2,-(%sp)
move.l %a3,-(%sp)
jbsr (%a2)
pea .LC16
move.w #4,-(%sp)
move.w #22,-(%sp)
move.l %a3,-(%sp)
lea _ROM_CALL_26,%a4
jbsr (%a4)
lea (42,%sp),%sp
clr.w -(%sp)
move.l %a3,-(%sp)
jbsr (%a2)
pea .LC17
move.w #15,-(%sp)
move.w #65,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
pea .LC18
move.w #23,-(%sp)
move.w #58,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
pea .LC19
move.w #32,-(%sp)
move.w #4,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
lea (38,%sp),%sp
move.l #.LC20,(%sp)
move.w #40,-(%sp)
move.w #4,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
pea .LC21
move.w #48,-(%sp)
move.w #4,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
pea .LC22
move.w #56,-(%sp)
move.w #4,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
lea (36,%sp),%sp
move.w #500,-(%sp)
move.w #1000,-(%sp)
jbsr ppcm
move.w %d0,-(%sp)
pea .LC23
lea (-20,%a6),%a2
move.l %a2,-(%sp)
jbsr _ROM_CALL_53
move.l %a2,-(%sp)
move.w #62,-(%sp)
move.w #4,-(%sp)
move.l %a3,-(%sp)
jbsr (%a4)
jbsr _ROM_CALL_51
move.l %a3,-(%sp)
jbsr _ROM_CALL_B
lea (30,%sp),%sp
jbra .L8
.even
.L17:
move.w #130,%d5
move.w %d5,-100(%a6)
move.w %d5,%d4
move.w %d5,-102(%a6)
move.w %d5,-104(%a6)
move.w #50,-106(%a6)
move.w #60,-108(%a6)
moveq.l #68,%d6
move.w #76,%a5
moveq.l #86,%d7
jbra .L7
.even
.L16:
move.w #50,-100(%a6)
moveq.l #58,%d5
move.w #66,-102(%a6)
moveq.l #74,%d4
move.w #82,-104(%a6)
move.w #90,-106(%a6)
move.w #130,%d6
move.w %d6,-108(%a6)
move.w #100,%a5
moveq.l #110,%d7
jbra .L6
.even
.L15:
pea .LC13
jbsr _ROM_CALL_E6
move.w #130,%d5
move.w %d5,-100(%a6)
move.w %d5,%d4
move.w %d5,-102(%a6)
move.w %d5,-104(%a6)
move.w #50,-106(%a6)
move.w %d5,%d6
move.w %d5,-108(%a6)
move.w #60,%a5
moveq.l #70,%d7
addq.l #4,%sp
jbra .L5
.even
.L2:
tst.w -98(%a6)
jbeq .L12
movm.l -144(%a6),#0x3cf8
unlk %a6
rts

>> il faut les multiplier et diviser par le PGCD et 500*1000 ca fait trop (enfin je sais pas... la TI accepte des chiffres plus grand ?)
Ca n'a pas de rapport avec la TI mais avec le codage des nombres déclare-les comme des long et tu pourras "monter" jusqu'à 2147483648


Je regarde le .s

J'ai tous essayé et je me suis arrété sur 'unsigned long int res;' et le compilateur m'indique toujours 'integer overflow in expression'

Montre le code.

Ha oui, le .s que tu m'a passé est très bizarre : y'a pas la fonction dedans tu as programmé ton truc en plusieurs fichiers .c ? il faut que tu postes le .s correspondant au .c qui contient la focntion.

Si tu veux ralonger tes nombres -> unsigned long long int c'est du 64 bits Si ça suffit pas, ben c'est plus compliqué... soit tu implémentes un systeme de grands nombres, soit tu réutilises le format BN de la TI (jusqu'à2040 bits), mais c'est plutôt foireux.

Oui j'ai essayé avec unsigned long long int mais ca marche pas et ca suffit tres largement pour le calcul que je veux faire, donc l'erreur vien d'ailleurs.

Oui en effet j'ai fait un sous programme je compte l'utiliser assez souvent dans mn prog

Ben c'est le .s de ce sous-programme qu'il me faut !

Excuse moi, voila:
     .file     "arithmetic.c" #NO_APP      .data tigcc_compiled.:      .set _A_LINE,0xA000 #APP      /* Include Patch: _dont_detect_calc_ */      /* Include Patch: _MIN_AMS_required_ */      /* Include Patch: _MIN_AMS_1_01_ */      /* Include Patch: doors_patch */      /* Include Patch: no_retval */      /* Include Patch: save_the_sp */      /* Include Patch: doors_no_very_simple_main */      /* Include Patch: complex_main */      .set MT_TEXT,0x8000      .set MT_XREF,0x9000      .set MT_ICON,0xA000      .set MT_CASCADE,0x4000 #NO_APP      .data      .even      .globl     pgcd pgcd:      link.w %a6,#0      movm.l #0x1e20,-(%sp)      move.l 8(%a6),%d6      move.l 12(%a6),%d4      moveq.l #0,%d5      moveq.l #1,%d3 .L8:      lea __umodsi3,%a2      move.l %d3,-(%sp)      move.l %d6,-(%sp)      jbsr (%a2)      addq.l #8,%sp      tst.l %d0      jbne .L5      move.l %d3,-(%sp)      move.l %d4,-(%sp)      jbsr (%a2)      addq.l #8,%sp      tst.l %d0      jbne .L5      move.l %d3,%d5 .L5:      cmp.l %d3,%d6      jbeq .L7      cmp.l %d3,%d4      jbeq .L7      addq.l #1,%d3      jbra .L8      .even .L7:      move.l %d5,%d0      movm.l -20(%a6),#0x478      unlk %a6      rts      .even      .globl     ppcm ppcm:      link.w %a6,#0      movm.l #0x1e20,-(%sp)      move.l 8(%a6),%d5      move.l 12(%a6),%d4      moveq.l #1,%d6      moveq.l #1,%d3 .L16:      lea __umodsi3,%a2      move.l %d3,-(%sp)      move.l %d5,-(%sp)      jbsr (%a2)      addq.l #8,%sp      tst.l %d0      jbne .L13      move.l %d3,-(%sp)      move.l %d4,-(%sp)      jbsr (%a2)      addq.l #8,%sp      tst.l %d0      jbne .L13      move.l %d3,%d6 .L13:      cmp.l %d3,%d5      jbeq .L15      cmp.l %d3,%d4      jbeq .L15      addq.l #1,%d3      jbra .L16      .even .L15:      move.l %d4,-(%sp)      move.l %d5,-(%sp)      jbsr __mulsi3      addq.w #4,%sp      move.l %d6,(%sp)      move.l %d0,-(%sp)      jbsr __udivsi3      addq.l #8,%sp      movm.l -20(%a6),#0x478      unlk %a6      rts

Je ne vois aucune erreur ! ça doit venir de l'algo Tu as essayé avec d'autres grandes valeurs ?


Et je vois que tu as déclaré toutes les variables en tant que unsigned long : tu as dû perde pas mal de vitesse !

unsigned long long pgcd(unsigned long long a, unsigned long long b)
{
 unsigned long long r;
 while (1) {
  if (!(r=a%b)) return b;
  a=b;
  b=r;
 }
}

Et on ne peut pas afficher des long longs avec printf (parce que la fonction vcbprintf qui est à la base de printf est dans AMS et ne respecte pas le standard C99 - c'est du C89 seulement).