multiplication, division, soustraction et modulo en base x

multiplication, division, soustraction et modulo en base x - Algo - Programmation

Marsh Posté le 28-04-2003 à 00:27:32    

Bonjour, je cherche des algos (les plus optimisés possibles) pour les multiplication, division, soustraction et modulo en base x.
 
je n'espere pas un truc tout fait, mais n'importe quelle piste serait la bienvenue.
 
merci :)


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 28-04-2003 à 00:27:32   

Reply

Marsh Posté le 28-04-2003 à 16:15:24    

drole d'idée ! tu veux pas plutot convertir tes nombres de base x en entier, faire tes calculs, puis revenir en base x ?

Reply

Marsh Posté le 28-04-2003 à 17:33:39    

euh ... en fait je cherche a manipuler des gds nombres. j'ai donc pensé a mettre plusieurs nombres (de type unsigned long en c, donc codés sur 32bits et non signés) les 1 a la suite des autres. pour faire une opération, je dois donc calculer comme si c'etait en base 2^32 il me semble donc ?


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 28-04-2003 à 17:46:11    

oui. moi aussi, j'ai déjà pensé à ce genre d'implémentation, mais j'ai préféré l'implémentation à base de string
 
y a pas de recette miracle. addition et soustraction, à la main
 
mutliplication indienne
et division avec soustraction successive, j'ai pas trouvé d'autres moyens

Reply

Marsh Posté le 29-04-2003 à 09:18:11    

a base de strings ... chaque caractère représente un chiffre de 0 à 9 ou tu as utilisé un caractère comme un nombre de 0 à 255 ? (ou -128 à 127)
 
et sinon pourrais-tu m'expliquer la division par soustraction successive et la multiplication indienne stp ?


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 09:31:15    

tu te souviens comment tu faisais tes multiplications et divisions en primaire?
 
ben tu fais pareil sauf qu'a les faire en base 10 tu les fais
en base x
 
LeGreg

Reply

Marsh Posté le 29-04-2003 à 10:17:48    

c simple tu fais comme à la main (au cm2)  ;)  
 
voici un exemple d'implémentation en base 2^32, sur du 128 bits, pour l'addition, soustraction, multiplication (je t'ai pas fais la division quand meme!)
 

Code :
  1. #include <stdio.h>
  2. #include <conio.h>
  4. void zero(unsigned int *x)
  5. {
  6. __asm
  7. {
  8.  mov edi,x
  9.  xor eax,eax
  10.  mov ecx,4
  11.  rep stosd
  12. }
  13. }
  15. void mov(unsigned int *x,unsigned int *y)
  16. {
  17. __asm
  18. {
  19.  mov esi,y
  20.  mov edi,x
  21.  mov ecx,4
  22.  rep movsd
  23. }
  24. }
  26. void add(unsigned int *x,unsigned int *y)
  27. {
  28. __asm
  29. {
  30.  mov esi,y
  31.  mov edi,x
  32.  mov eax,[esi]
  33.  add [edi],eax
  34.  mov eax,[esi+4]
  35.  adc [edi+4],eax
  36.  mov eax,[esi+8]
  37.  adc [edi+8],eax
  38.  mov eax,[esi+12]
  39.  adc [edi+12],eax
  40. }
  41. }
  43. void sub(unsigned int *x,unsigned int *y)
  44. {
  45. __asm
  46. {
  47.  mov esi,y
  48.  mov edi,x
  49.  mov eax,[esi]
  50.  sub [edi],eax
  51.  mov eax,[esi+4]
  52.  sbb [edi+4],eax
  53.  mov eax,[esi+8]
  54.  sbb [edi+8],eax
  55.  mov eax,[esi+12]
  56.  sbb [edi+12],eax
  57. }
  58. }
  61. void main()
  62. {
  63. unsigned int a[4],b[4];
  64. int i;
  65. zero(a);
  66. zero(b);
  68. a[3]=0x01234567; a[2]=0x88889999; a[1]=0xaabbccdd; a[0]=0x87654321;
  69. b[0]=0x00010000;
  71. printf("    a = %08X %08X %08X %08X\n",a[3],a[2],a[1],a[0]);
  72. printf("    b = %08X %08X %08X %08X\n",b[3],b[2],b[1],b[0]);
  73. add(a,b);
  74. printf("  a+b = %08X %08X %08X %08X\n",a[3],a[2],a[1],a[0]);
  75. sub(a,b);
  76. printf("a+b-b = %08X %08X %08X %08X\n",a[3],a[2],a[1],a[0]);
  78. // multiplication
  79. unsigned int l00[4],l01[4],l02[4],l03[4];
  80. unsigned int l10[4],l11[4],l12[4],l13[4];
  81. unsigned int l20[4],l21[4],l22[4],l23[4];
  82. unsigned int l30[4],l31[4],l32[4],l33[4];
  84. for (i=0;i<4;i++)
  85. {
  86.  l00[i]=l01[i]=l02[i]=l03[i]=0;
  87.  l10[i]=l11[i]=l12[i]=l13[i]=0;
  88.  l20[i]=l21[i]=l22[i]=l23[i]=0;
  89.  l30[i]=l31[i]=l32[i]=l33[i]=0;
  90. }
  92. __asm
  93. {
  94.  // ligne 0
  95.  mov ebx,b[0]
  96.  mov eax,a[0]
  97.  mul ebx
  98.  mov l00[4],edx
  99.  mov l00[0],eax
  101.  mov eax,a[4]
  102.  mul ebx
  103.  mov l01[8],edx
  104.  mov l01[4],eax
  106.  mov eax,a[8]
  107.  mul ebx
  108.  mov l02[12],edx
  109.  mov l02[8],eax
  111.  mov eax,a[12]
  112.  mul ebx
  113.  mov l03[12],eax
  115.  //ligne 1
  116.  mov ebx,b[4]
  117.  mov eax,a[0]
  118.  mul ebx
  119.  mov l10[8],edx
  120.  mov l10[4],eax
  122.  mov eax,a[4]
  123.  mul ebx
  124.  mov l11[12],edx
  125.  mov l11[8],eax
  127.  mov eax,a[8]
  128.  mul ebx
  129.  mov l12[12],eax
  131.  // ligne 2
  132.  mov ebx,b[8]
  133.  mov eax,a[0]
  134.  mul ebx
  135.  mov l20[12],edx
  136.  mov l20[8],eax
  138.  mov eax,a[4]
  139.  mul ebx
  140.  mov l21[12],eax
  142.  //ligne 3
  143.  mov ebx,b[12]
  144.  mov eax,a[0]
  145.  mul ebx
  146.  mov l30[12],eax
  147. }
  148. mov(a,l00);
  149. add(a,l01);
  150. add(a,l02);
  151. add(a,l03);
  152. add(a,l10);
  153. add(a,l11);
  154. add(a,l12);
  155. add(a,l20);
  156. add(a,l21);
  157. add(a,l30);
  158. printf("  a*b = %08X %08X %08X %08X\n",a[3],a[2],a[1],a[0]);
  159. getch();
  160. }


Message édité par Deaddy le 29-04-2003 à 10:19:09
Reply

Marsh Posté le 29-04-2003 à 12:23:08    

Pour la multiplication à l'indienne, fais une recherche sur google avec Multiplication et Karatsuba.
 
Dans un premier temps, il faut que tu choisisses le mode de réprésentation de tes nombre : Big Endian ou Little Endian.  
 
Le mode Little Endian est celui que nous utilisons tous les jours, par exemple mille deux cents cinquante deux sera érit comme ca : 1252.  
 
En Big Endian, ca donne 2521. Avec une représenation à base de string, ou liste, c'est moins cher en temps pour gérer le propagation de retenue (de proche en proche) plutot que d'aller au fond de ta liste. Tu peux aussi faire une liste doublement chainée avec un pointeur sur la tete et un sur la queue, mais ca fait un peu lourd je trouve :)
 
Je pense qu'en faisant un peu de recherche tu trouveras ton bonheur. Il faut juste s'habituer à faire des opérations dans n'importe quelle base, ca ne change rien :)
 
 
 
Par exemple, A et B sont deux nombres en base X composés des chiffres a4a3a2a1 et b4b3b2b1, on va les additions. Soit r0 la retenue "entrante", nulle.
 
Si b1+a1+r0 = RES >= X, alors on garde le reste de la division entiere entre RES et X, sinon, on garde RES. La retenue suivante est alors le résultat est celui de la division entiere de RES et X. Et ainsi de suite...
 
Un petit exemple, avec 2 nombres en base 10.
 
 


  15
+ 8
---
 
5 + 8 = 13 > 10,  On garde RES mod X = 3 et on génére une retenue de 13/10 = 1.
1 + 1 = 2
 
=> 23 :)


 
Voilà le principe !
 
@+


Message édité par Evadream -jbd- le 29-04-2003 à 12:24:23
Reply

Marsh Posté le 29-04-2003 à 14:14:26    

pour l'addition, j'y etais deja arriver avec du code (tres peu portable car que en BigEndian) : j'avais aussi un pricinpe de retenue : lorsque j'ajoute le nombre de gauche de chaque nombre, je stock le résultat dans une variable de 64bits, et les 32 bits 'bas' font le résultat, et les 32 'hauts' font la retenue.
 
legreg : je risque de faire un dépassement de capacité avec une multiplication comme en primaire : lorsque je multiplie 2 long, la valeur doit etre tenue ds un int64. le probleme est que si les 2 long ont déja la valeur max, l'int64 aussi. si il y a une retenue, bam ...


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 14:15:01    

(je me plonge de suite dans le décryptage du code asm ... :) )


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 14:15:01   

Reply

Marsh Posté le 29-04-2003 à 14:17:27    

en tout cas merci beaucoup pour vos réponses :)


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 19:12:40    


un peu d'explication sur mon post précedent
// addition
add     dest,src        : dest=dest+src
                        s'il y a dépassement CF=1 (carry flag), 0 sinon
 
adc     dest,src        : dest=dest+src+CF
                        s'il y a dépassement CF=1 (carry flag), 0 sinon
 
CF(2)           CF(1)           CF(0)
 
a[3]            a[2]            a[1]            a[0]
b[3]            b[2]            b[1]            b[0]
---------------------------------------------------------
a[3]+b[3]+CF    a[2]+b[2]+CF    a[1]+b[1]+CF    a[0]+b[0]
 
 
CF(3) perdu (pourrait servir à detecter le depassement)
 
 
//soustraction
sub     dest,src        : dest=dest-src
                        s'il y a dépassement CF=1 (carry flag), 0 sinon
 
sbb     dest,src        : dest=dest-src-CF
                        s'il y a dépassement CF=1 (carry flag), 0 sinon
   
même principe que pour l'addition
 
 
 
// multiplication
 
mul     dest          : R = EDX:EAX = eax * dest
                        eax, edx, dest: 32 bits
                        R = EDX:EAX : 64 bits
                        EDX=HI(R) , EAX=LO(R)
   
   
        A3              A2              A1              A0
x      B3              B2              B1              B0
---------------------------------------------------------------
+        0               0            HI(X00)         LO(X00)     = l00
+        0            HI(X01)         LO(X01)            0         = l01  
+     HI(X02)         LO(X02)            0               0         = l02
+     LO(X03)            0               0               0         = l03
---------------------------------------------------------------
+        0            HI(X10)         LO(X10)            0         = l10
+     HI(X11)         LO(X11)            0               0         = l11
+     LO(X12)            0               0               0         = l12
---------------------------------------------------------------
+     HI(X20)         LO(X20)            0               0         = l20
+     LO(X21)            0               0               0         = l21
---------------------------------------------------------------
+     LO(X30)            0               0               0         = l30
---------------------------------------------------------------
 
 
 
Xij = Aj * Bi (64bits)  
lij : resultat (128bits) d'une multiplication élémentaire (cf ci-dessus)
 
le résultat de la multiplication est la somme de tous les lij.


Message édité par Deaddy le 29-04-2003 à 19:44:10
Reply

Marsh Posté le 29-04-2003 à 19:19:55    

au secours le formattage !!
(j'ai essayé fixed cpp, et leurs combinaisons mais rien)
 
[edit] ouf j'ai réussi (après un quart d'heure de padding avec des espaces)


Message édité par Deaddy le 29-04-2003 à 19:34:03
Reply

Marsh Posté le 29-04-2003 à 19:28:50    

BlackGoddess a écrit :


legreg : je risque de faire un dépassement de capacité avec une multiplication comme en primaire : lorsque je multiplie 2 long, la valeur doit etre tenue ds un int64. le probleme est que si les 2 long ont déja la valeur max, l'int64 aussi. si il y a une retenue, bam ...


 
eh oh ! je parle de multiplication en base x
pas de multiplication en base long !
 
LeGreg

Reply

Marsh Posté le 29-04-2003 à 22:07:26    

merci Deaddy pour l'explication lol, j'avais du mal a comprendre le code :)
 
pour la multiplication avec l'algo Karatsuba, je suis tjs en train d'essayer de comprendre ... je vais bien finir par y arriver :)


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 22:14:05    

Le truc qu'il faut comprendre pour Karatsuba, c'est la gain d'une multiplication par rapport au raisonnement naif, ce n'est pas juste le fait de faire ca par dichotomie qui te permet de gagner en complexité. ( Théoriquement, on passe d'un complexité quadratique  une complexité en n^1.57 si mes souvenirs sont bons)
 
A+

Reply

Marsh Posté le 29-04-2003 à 22:15:05    

ché aps j'ai pas la calculette mais je dirai log2(n)

Reply

Marsh Posté le 29-04-2003 à 22:20:50    

n^(log en base de 2 de 3), j'ai retrouvé le résultat !
 
Edit : il doit surement y avoir plusieurs implémentations de Karatsuba, le résultat que j'ai donné correspond à la seule que j'ai vu, ptetre la version pédagogique :)


Message édité par Evadream -jbd- le 29-04-2003 à 22:23:33
Reply

Marsh Posté le 29-04-2003 à 22:24:54    

sur? ça fait beaucoup quand meme. moi je maintiens un cout logarithmique

Reply

Marsh Posté le 29-04-2003 à 22:34:43    

En me basant sur cette page :
 
http://gersoo.free.fr/docs/karat/kar.html
 
Ce que j'ai dit semble correct !

Reply

Marsh Posté le 29-04-2003 à 22:37:48    

ah je croyais que tu parlais de ma méthode indienne

Reply

Marsh Posté le 29-04-2003 à 22:43:07    

[:alphat] Je n'avais pas compris. En fait depuis le début je pense que méthode indienne = Karatsuba :D

Reply

Marsh Posté le 29-04-2003 à 22:53:28    

++Taz pourrais-tu décrire la méthode indienne alors stp ?


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 29-04-2003 à 23:25:55    

Code :
  1. def multIndienne(a, b):
  3.     def multR(x, y):
  4.         print x, y
  5.         if x==1:
  6.             return y
  7.        
  8.         if x%2==0:
  9.             return multR(x/2, y*2)
  10.         else:
  11.             return y + multR((x-1)/2, y*2)
  13.     if a<b:
  14.         return multR(a, b)
  15.     else:
  16.         return multR(b, a)


 
c'est comme ça que c'est fait en hardware, par ce que %2, *2 et /2 sont trivial, le reste c'est une additiob
 
et la il me semble bien que c'est log2(n), avec n la plus petite des 2 operandes

Reply

Marsh Posté le 29-04-2003 à 23:42:45    

d'accord, merci :)


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 30-04-2003 à 00:21:53    

pour le modulo, j'ai pensé faire la division (vu que c'est des entiers, mon algo arrondi a l'entier inférieur), puis refaire la multiplication et voir la difference.
 
par exemple :
 
a mod b  
-> c = a/b
   d = c*b
   resultat = a-d
 
existe-t-il une manière plus optimisée ?


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 30-04-2003 à 02:57:57    

BlackGoddess > j'ai du mal à saisir l'intérêt de ta manip en fait :/
 
++Taz > J'ai tenté d'implémenter sur des listes de caractères la multiplication indienne, mais ca me donne des trucs comme ca :
 
En rouge Karatsuba et en vert la méthode Indienne. En abscisse, la taille des entiers, et en ordonnée le temps en secondes.
 
Voici pour des grands entiers avec moins de 1000 digits, on sent  que l'indienne faiblie :
 
http://evadream.free.fr/files/hfr/karaindi2.png  
 
Voici pour des grands entiers avec moins de 5000 digits :
 
http://evadream.free.fr/files/hfr/karaindi.png
 
Je me suis basé sur ton algo et j'ai implémenté ca à la suite d'un projet sur Karatsuba fait en OCaml, voic un bout de code, qui se calque sur ce que tu as donner :
 

Code :
  1. let multI a b =
  2.  
  3.    let rec multR(x, y) =
  4.        match x with
  5.         | Zero -> Zero
  6. | Num(1,Zero) -> y
  7. | _ ->
  8.  begin
  9.           if ( (modBin2 x) = 0) then multR( (binDiv2 x), (binMult2 y) )
  10.           else let newres = multR( binDiv2(binMinus1 x), binMult2 y)
  11.                     in add_with_carry(y, newres, 0, 2)
  12.       end
  13.    in
  15.    let res = compareNumber a b in
  17.    if res = -1 then
  18.        multR(a, b)
  19.    else
  20.        multR(b, a);;

 
 
modBin2, binMult2, binMinus1 et binDiv2 sont implémentées de la facon suivante :
 

Code :
  1. let modBin2 a =
  2. match a with
  3.     | Zero -> 0
  4.     | Num(a,_) -> if a = 0 then 0 else 1     
  7. let binMult2 a =
  8. zero(a,1)  (*ajout des zeros en tete (Big Endian) *)
  11. let binDiv2 a =
  12. match a with
  13.  | Zero -> Zero
  14.  | Num(a, Num(r,s) ) -> Num(r,s) (* decal à droite, donc à gauche en BigEndian *)
  15.  | Num(a,Zero) -> Zero
  17. let binMinus1 a =      (* pour faire le -1 *)
  18. match a with
  19.  | Zero -> failwith "never append"
  20.  | Num(a,r) -> Num(0,r)


 
 
MMmmmm... en tapant je réfléchis à compareBigInteger qui coute cher, mais elle n'est executé qu'une seule fois... (elle part au fond de la liste et la remonte jusque trouvé deux digits différents)...
 
Je vois pas trop comment améliorer cà, ca semble moins performant que Karatsuba.  
 
Si tu as le temps, vois tu ou ca pourrais coincé ?
 
Merci à toi !
 
@+


Message édité par Evadream -jbd- le 30-04-2003 à 02:59:42
Reply

Marsh Posté le 30-04-2003 à 08:56:05    

ben c'est un problème d'implémentation, par ce que ln(n)/ln(2) < n*ln(2)
 
le truc c que si tu fournit pas de décalage rapide, la méthode n'a plus d'interet. cependant, tu vois que ça a quand meme un bonne efficité: c'est un bon cas pour faire un strategy pattern avec une factory
 
edit: le mieux ça serait que tu utilises un profiler pour voir ou ça coince.
 
le truc sera sans doute de reduire tes appels à Num. J'ai du mal à te lire, mais si ta division est entiere, tu peux allègrement te passer soustraction. c'est déjà àa de gagner


Message édité par Taz le 30-04-2003 à 09:26:23
Reply

Marsh Posté le 30-04-2003 à 12:55:53    

je n'arrive pas à faire de division ni de modulo :(
 
j'ai entendu parler de l'algorithme de newton
http://www.haypocalc.com/grandnbr/division.php
mais je n'ai pas compris :(
 
sinon, par soustractions successives, imaginons un tres grand nombre à diviser par 2, si on fait une boucle qui enleve 2 a chaque fois au dividende et rajoute 1 au quotien, jusqu'à ce que le diviseur (2) soit supérieur au dividende, ca prend un temps enorme ... je suppose qu'il doit etre possible de faire justement des divisions triviales par 2 pour n'importe quel diviseur, mais je n'arrive pas a trouver d'algo ...


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 30-04-2003 à 13:19:15    

++Taz a écrit :

ben c'est un problème d'implémentation, par ce que ln(n)/ln(2) < n*ln(2)
 
le truc c que si tu fournit pas de décalage rapide, la méthode n'a plus d'interet. cependant, tu vois que ça a quand meme un bonne efficité: c'est un bon cas pour faire un strategy pattern avec une factory
 
edit: le mieux ça serait que tu utilises un profiler pour voir ou ça coince.
 
le truc sera sans doute de reduire tes appels à Num. J'ai du mal à te lire, mais si ta division est entiere, tu peux allègrement te passer soustraction. c'est déjà àa de gagner


 
Merci pour tes remarques.
Num n'est pas une fonction, mais juste un descripteur du type récursif Num.
 
Pour les décalagages rapides, je ne pense pas pouvoir aller plus rapidement, ces opérations ayant un cout en 0(1).
 
(Re)Edit : Bin2Mult est maintenant aussi en O(1).
 
Je vais voir ca avec un profiler, ca va me permettre d'en utiliser un pour la première fois en caml :)
 
@+


Message édité par Evadream -jbd- le 30-04-2003 à 13:33:43
Reply

Marsh Posté le 30-04-2003 à 16:14:24    

BlackGoddess a écrit :

je n'arrive pas à faire de division ni de modulo :(
 
j'ai entendu parler de l'algorithme de newton
http://www.haypocalc.com/grandnbr/division.php
mais je n'ai pas compris :(
 
sinon, par soustractions successives, imaginons un tres grand nombre à diviser par 2, si on fait une boucle qui enleve 2 a chaque fois au dividende et rajoute 1 au quotien, jusqu'à ce que le diviseur (2) soit supérieur au dividende, ca prend un temps enorme ... je suppose qu'il doit etre possible de faire justement des divisions triviales par 2 pour n'importe quel diviseur, mais je n'arrive pas a trouver d'algo ...

j'en parlais avec nraynaud l'autre jour: apparemment il n'existe pas d'algorithme vraiment bon pour la division

Reply

Marsh Posté le 30-04-2003 à 16:44:43    

ah :(
 
est-il possible de trouver le reste d'une division sans la faire ?


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 30-04-2003 à 17:26:13    

je pense pas. cela dit si je relis ta question, ç ame parait evident que non

Reply

Marsh Posté le 30-04-2003 à 20:33:40    

je demande juste lol, il me semblait aussi, mais des fois que qq1 connaisse un algo :)


---------------
-( BlackGoddess )-
Reply

Marsh Posté le 30-04-2003 à 20:58:38    

Oui si c'est une division par une puissance de x
si x est la base dans laquelle le nombre est exprimé..
 
Ceci dit si tu reflechis bien ca veut dire que
la division a deja ete faite (une division par puissance de x pour obtenir le chiffre correspondant).
 
Sinon en base x tu peux aussi obtenir le reste
de la division par (x-1) en faisant la somme des chiffres de ce nombre dans cette base.
 
LeGreg

Reply

Marsh Posté le 21-11-2003 à 21:32:22    

pour la division (avec des soustractions successives):
petit exemple:
14/3:
_ 14-3=11 (1 soustr)
_ 11-3=8  (2soustr)
_ 8-3=5   (3soustr)
_ 5-3=2    (4soustr, reste 2)
--> donc 14/3=4 (car on a effectué 4soustr) , reste 2
 
de plus on a 14%3 (modulo) ==2
 
++

Reply

Marsh Posté le 21-11-2003 à 21:34:49    

maicaisupair, moi qui croyais que tu uppais pour me fêter mon anniversaire un peu en retard ...

Reply

Marsh Posté le 21-11-2003 à 22:04:13    

euh... ton anniv en tant que Taz, en tant qu'ex modo, ou dans la vie civile???
dans tous les cas, bon anniv :D

Reply

Marsh Posté le 28-11-2003 à 22:24:28    

pour une addition binaire:
vous en pensez quoi???
 
donc on fait res = A + B

Code :
  1. somme <- 0
  2. retenue <- 0
  3. pour i<-0 à n+1 faire
  4.   somme <- A[i] ^ B[i];   // ^ c un xor
  5.   res[i] <- somme ^ retenue;
  6.   retenue <- (A[i] & B[i]) ^ retenue;   // & c un et
  7. fin pour


 :hello:


Message édité par Riot le 28-11-2003 à 22:25:25
Reply

Marsh Posté le 29-11-2003 à 21:36:21    

c si nul que ça??? :?

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed