Discussion :

[rteuteu55]

Bonjour,

je cherche à créer une fonction d'addition en c.
vous allez me dire que ça existe déjà mais je veux la créer pour de grands nombres sans utiliser la librairie BigNum ou autre grosse librairie.

pour faire simple mes nombres son sous la forme de tableau d'octet de taille différente.

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
char a[5]={0x23,0x45,0X67,0x89,0x01};
char b[2]={0x14,0x59};
char c[sizeof(a+1)]; // sizeof à définir ...
 
c = addition(a,b);

le probléme est que je ne vois pas du tout comment structurer ma fonction.
si j'utilise des pointeurs ...

Ma contrainte et d'utiliser des nombres sous la forme de tableau car je suis sur un microcontroleur 8bit.

je n'ai pas trouvé grand chose sur si ce n'ai l'addition bit à bit avec une retenu mais je ne vois pas comment créer une fonction avec.

[Sve@r]

Bonjour,

je cherche à créer une fonction d'addition en c.
vous allez me dire que ça existe déjà mais je veux la créer pour de grands nombres sans utiliser la librairie BigNum ou autre grosse librairie.

pour faire simple mes nombres son sous la forme de tableau d'octet de taille différente.

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
char a[5]={0x23,0x45,0X67,0x89,0x01};
char b[2]={0x14,0x59};
char c[sizeof(a+1)]; // sizeof à définir ...
 
c = addition(a,b);

le probléme est que je ne vois pas du tout comment structurer ma fonction.
si j'utilise des pointeurs ...

Ma contrainte et d'utiliser des nombres sous la forme de tableau car je suis sur un microcontroleur 8bit.

je n'ai pas trouvé grand chose sur si ce n'ai l'addition bit à bit avec une retenu mais je ne vois pas comment créer une fonction avec.

Faut faire comme au primaire
1) tu traites tes 2 tableaux "a" et "b" en partant de la fin pour revenur au début
2) chaque élément du tableau est additionné et tronqué à un chiffre et stocké dans le tableau c. S'il y a une retenue issue de l'élément précédent tu l'additionnes aussi

Intuitivement moi je stockerais mes nombres dans l'autre sens pour pouvoir traiter le tableau en partant du début vers la fin (mais j'ai pas vraiment réfléchi aux avantages et inconvénients)...

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
char a[5]={0x23,0x45,0X67,0x89,0x01};
char b[2]={0x14,0x59};
char c[sizeof(a+1)]; // sizeof à définir ...

Il y a un problème sur ce sizeof : a+1 est une expression du type adresse et sizeof(a+1) renvoie la taille de ce type donc la taille d'un pointeur. sans doute voulais-tu écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sizeof(a)+1

qui est le (nombre de bytes du tableau a) + 1;

[rteuteu55]

en effet pour le sizeof !

sinon voila où j'en suis ... ce n'est pas joli à voir ... !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
char a[5]={0x23,0x45,0X67,0x89,0x01};
char b[2]={0x14,0x59};
char c[sizeof(a)+1]; 
 
addition(a,b,c);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
addition (char* a, char* b,char* c)
{
  int tailleA=sizeof(&a);
  int tailleB=sizeof(&a);
  int nbIteration=0;
  int i=0;
 
  bool x,y,z,r,rOld; //=0 
 
  if (tailleA>=tailleB) nbIteration=tailleB;
  else nbIteration=tailleA;
 
  while (i<=tailleA || i<=tailleB)
  {
    rOld=r;
    if (i<=nbIteration)
    {
      x=bit i de a; //comment le récuperer?
      y=bit i de b; //comment le récuperer?
      z=rOld^x^y; // z= bit résultant de la somme
      r= // a retrouver ... r= retenu.
    } else {
      x=bit de a ou b suivant le nombre le plus grand.
      z=rOld^x;
      r=rOld&x;
    }
    i++
    c[]= // intégrer z sur le bon bite
  }
}

[diogene]

Décidemment, tu as des problèmes avec sizeof :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  int tailleA=sizeof(&a);

ces sizeof vont donner la taille d'une adresse, soit la taille d'un pointeur, pas du tout la taille des tableaux passés en arguments.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x=bit i de a; //comment le récuperer?

Par exemple, avec un masque en utilisant un ET bit à bit (opérateur &)

[Sve@r]

Décidemment, tu as des problèmes avec sizeof :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  int tailleA=sizeof(&a);

ces sizeof vont donner la taille d'une adresse, soit la taille d'un pointeur, pas du tout la taille des tableaux passés en arguments.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x=bit i de a; //comment le récuperer?

Par exemple, avec un masque en utilisant un ET bit à bit (opérateur &)

Tu décales a vers la droite de "i - 1" bits. Le bit "i" devient donc le dernier que tu récupères via un masque sur l'octet 00000001
x=(a >> (i - 1)) & 0x01

[Jean-Marc.Bourguet]

1/ utilise des unsigned char, pas des char
2/ Ne travaille pas bit a bit: coeur de la boucle avec des unsigned char:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
   sum = a[i] + b[i] + carry;
   res[i] = sum % (UCHAR_MAX+1);
   carry = sum / (UCHAR_MAX+1);

Tu peux utiliser plus grand qu'unsigned char pour les chiffres tant que tu as un type pour sum capable de representer exactement la somme de deux chiffres. Generalement, on veut la multiplication aussi donc on prend le type qui a la taille moitie du plus grand unsigned. Si on n'a que l'addition a faire, on peut faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
   res[i] = a[i] + b[i] + carry;
   carry = (DIGIT_MAX-a[i] < b[i]) || (DIGIT_MAX-carry < a[i]+b[i]);

mais il faudrait mesurer pour voir si c'est reellement plus efficace. Attention, mon expression pour carry est ecrite pour ternir compte des cas limites; il y a peut-etre moyen de la simplifier, mais c'est pas immediat (en particulier supprimer la premiere partie du test
n'est pas une simplification valide).