Discussion :

[djbad]

voila je dois faire un programme pour multiplier deux nombres représentés en base 10 et en virgule flottante entre eux

Merci de m'aider

[djbad]

ah oui j'oubliais il faut normaliser de facon n'avoir qu'un chiffre à gauche de la virgule du resultat
merci encore

[Invité]

Bonjour,

Tu peux nous en dire plus sur la façon dont sont stockés les nombres qu'il faut multiplier ?

Ils sont sous forme de chaine de caractères ? Ce sont des int ? des float ?

Et sous quelle forme, sous quelle structure de donnée doit être renvoyé le résultat de la multiplication ?

[djbad]

Concernant la façon dont sont stockés les nombres qu'il faut multiplier
On ne m'a rien indiqué
Il seront sous forme de float vu que c'est le chapitre que nous étudions
et aucune info sur la structure de donnée doit être renvoyé le résultat de la multiplication
Mais je pense qu'il faut faire quelque chose d'assez simples sans trop se prendre la tete sur la structure de donnée
Merci en tout cas

[Invité]

C'est bizarre ton histoire. C'est en quel langage de programmation ?

Si c'est en C :

Code c :

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

1
2
3
int a = 123456789;
float b = 9876.5432;
float resultat = (float)a * b;

Ca se fait tout seul.

Cet exercice n'est intéressant que si tu définit toi même tes flottants :

Code c :

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

1
2
3
4
struct Flottant {
  int mantisse;
  int exposant;
}

Par exemple, pour le flottant 4,53*10^-6, la mantisse est égale à 453 et l'exposant est -6. Je me suis aidé de la page de wikipédia sur les flottants et sur la notation scientifique.


On va d'abord créer une fonction qui transforme un int en Flottant :

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
 
Flottant int_to_Flottant(int a) {
  struct Flottant flottant;
  flottant.mantisse = a;
  flottant.exposant = 0;
  while(abs(a) > 9) {
    a = a/10;
    ++flottant.exposant;
  }
  return flottant;
}

abs(a) est la valeur absolue de a.

Maintenant on définit la multiplication entre un Flottant et un Flottant :

Code c :

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

1
2
3
4
5
6
Flottant multiplicationFF(Flottant a, Flottant b) {
  Flottant resultat;
  resultat.mantisse = a.mantisse * b.mantisse;
  resultat.exposant = a.exposant + b.exposant;
  return resultat;
}

Pour le coup d'additioner les exposants, j'ai juste remarqué que
(5,12*10^32) * (1,00*10^8) == (5,12*10^40)
un autre exemple :
(3,50*10^-10) * (2,00*10^15) == (7,00*10^5)

Enfin on définit la multiplication entre un int et un Flottant :

Code c :

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

1
2
3
4
5
Flottant multiplicationIF(int a, Flottant b) {
  Flottant c = int_to_float(a);
  Flottant resultat = multiplicationFF(b, c);
  return resultat;
}

Si c'est à peu près ce que tu cherche, je peux améliorer le code.

[djbad]

je crois qu'on nous demande plus de faire sous forme de pseudo code
pas forcement dans un langage particulier
mais en tous cas ce que tu m'as fourni m'aide déjà beaucoup

Pour le coup d'additioner les exposants, j'ai juste remarqué que
(5,12*10^32) * (1,00*10^8) == (5,12*10^40)
un autre exemple :
(3,50*10^-10) * (2,00*10^15) == (7,00*10^5)

je l'avais remarqué aussi
mais quand on fait (3,50 * 10^-10) * (51,2 * 10^15) comment faire pour normaliser le resultat de facon à n'avoir qu'un chiffre avant la virgule
Merci en tout cas

[Invité]

Le principe est le suivant : On divise la mantisse par 10 et on augmente l'exposant de 1, jusqu'à ce que la mantisse soit comprise entre 1,000 et 9,999.

Si c'est l'inverse (exemple 0,0000456*10^34), on multiplie la mantisse par 10 et on diminue l'exposant de 1, jusqu'à ce que la mantisse soit comprise entre 1,000 et 9,999.

Normalement ça devrait pas arriver (car on se débrouille toujours pour qu'après une multiplication ou une autre opération que l'on a définie, nos Flottants reste dans un état convenable).

-------------------------------------------------------------------------

En ce qui concerne mon code, un Flottant de valeur 1,0*10^1 aura la structure :

mantisse == 100 000 000
exposant = 1

En fait dans la mantisse, si on veux signifier la valeur 1, on va écrire 100 000 000 (car sinon les mantisses de valeur 1, 10, 100, 1000, 10000 signifieraient toutes "1" et ça compliquerait un peu la multiplication). Si on décidait que les zéros de la gauche ne sont pas significatifs, on ne pourrait pas coder la valeur 0,0001 dans la mantisse par exemple. Mais ça ne changerait rien car 0,0001 est une valeur interdite dans la mantisse.

La limite supérieure de la mantisse est 999 999 999. (J'ai choisis cette limite car un int codé sur 32 bits peut aller jusqu'à 2 100 000 000.)

[djbad]

merci pour ton aide