begin process at 2010 03 21 01:11:20
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths

 > CONVERSIONS : BINAIRE - OCTALE - DECIMALE - HEXADECIMALE

CONVERSIONS : BINAIRE - OCTALE - DECIMALE - HEXADECIMALE


 Information sur la source

Note :
8,5 / 10 - par 2 personnes
8,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths Niveau :Débutant Date de création :02/11/2002 Date de mise à jour :02/11/2002 04:02:55 Vu / téléchargé :7 691 / 231

Auteur : hvb

Ecrire un message privé
Site perso
Ce membre participe au partage de revenus publicitaires
Commentaire sur cette source (5)
Ajouter un commentaire et/ou une note


 Description

Bon c'est sur, il y a des fonctions integrées qui pourraient reduire la taille du code, mais le but etait de mettre en oeuvre les manieres de conversions apprises en cours.
C'est un de mes 1ers petits projet, mais je le poste, je n'ai pas vu d'equivalent...
il faudrait que je gere le depassement de capacité des variables integer lorsqu'on saisit un gros chiffre,je vais penser à ca.
Pour l'instant il ne gere pas encore les virgules, mais je suis en train de tenter de gerer ca (ce qui est deja une autre histoire lol)  

Source

  • function decibinr(decival : integer) : string;
  • var
  • i : integer;
  • j : integer;
  • h : string;
  • n : string;
  • begin
  • i := decival ;
  • while i <> 0 do
  • begin
  • j := i mod 2;
  • i := i div 2;
  • h := inttostr(j) + h ;
  • end;
  • decibinr := h;
  • end;
  • function decioct(decival : integer) : string;
  • var
  • j : integer;
  • h : string;
  • b : string ;
  • res : string;
  • n : integer;
  • begin
  • n := decival ;
  • while n >= 8 do
  • begin
  • j := n mod 8;
  • n := n div 8;
  • b := inttostr(j) + b;
  • end;
  • b := inttostr(n) + b ;
  • decioct := b;
  • end;
  • function decihexa(decival : integer) : string;
  • var
  • h : string;
  • res : string;
  • n : integer;
  • b : integer;
  • begin
  • n := decival;
  • while n >= 16 do
  • begin
  • b := n Mod 16 ;
  • n := n div 16 ;
  • CASE b of
  • 0 : h := '0';
  • 1 : h := '1';
  • 2 : h := '2';
  • 3 : h := '3';
  • 4 : h := '4';
  • 5 : h := '5';
  • 6 : h := '6';
  • 7 : h := '7';
  • 8 : h := '8';
  • 9 : h := '9';
  • 10 : h := 'A';
  • 11 : h := 'B';
  • 12 : h := 'C';
  • 13 : h := 'D';
  • 14 : h := 'E';
  • 15 : h := 'F';
  • END;
  • res := h + res;
  • end;
  • CASE n of
  • 0 : h := '0';
  • 1 : h := '1';
  • 2 : h := '2';
  • 3 : h := '3';
  • 4 : h := '4';
  • 5 : h := '5';
  • 6 : h := '6';
  • 7 : h := '7';
  • 8 : h := '8';
  • 9 : h := '9';
  • 10 : h := 'A';
  • 11 : h := 'B';
  • 12 : h := 'C';
  • 13 : h := 'D';
  • 14 : h := 'E';
  • 15 : h := 'F';
  • END;
  • res := h + res ;
  • decihexa := res;
  • end;
  • function bindeci(binval : string) : integer;
  • var
  • i : integer;
  • res : variant;
  • h : string;
  • bin : string;
  • begin
  • bin := binval ;
  • res := 0 ;
  • for i := 0 to Length(bin)-1 do
  • begin
  • h := copy(bin,length(bin)-i,1) ;
  • if i = 0 then
  • begin
  • if h = '1' then res := res + 1 ;
  • h := '0';
  • end ;
  • if h = '1' then res := res + Exp(i*Ln(2)) ;
  • end ;
  • bindeci := res;
  • end;
  • function octdeci(octval : integer) : integer;
  • var
  • i : integer;
  • j : string;
  • h : string;
  • test : integer;
  • b : integer;
  • n : integer;
  • res : integer;
  • result2 : variant;
  • result3 : integer;
  • oct : integer;
  • begin
  • oct := octval;
  • n := length(inttostr(oct)) - 1 ;
  • for i := 0 to n do
  • begin
  • j := inttostr(oct) ;
  • b := strtoint(copy(j,n-i+1,1));
  • if i = 0 then
  • begin
  • res := b ;
  • end
  • else
  • begin
  • result2 := exp(i*ln(8)) * b ;
  • result3 := result3 + result2
  • end;
  • end;
  • result2 := res + result3 ;
  • octdeci := result2;
  • end ;
  • function hexadeci(hexaval : string) : integer;
  • var
  • z : integer;
  • x : integer;
  • v : integer;
  • p : integer;
  • b : variant;
  • h : integer;
  • n : integer;
  • begin
  • x := Length(hexaval);
  • v := x;
  • p := 0;
  • n := 0;
  • b := 0;
  • while v >= 1 do
  • begin
  • z := Ord(hexaval[v]) ; {Je recupere la valeur du charactere pour pouvoir utiliser le Case * of ... j'aurais donc pu directement les convertir en hexa, mais c'est pas le but}
  • Case z of
  • 48 : h := 0 ;
  • 49 : h := 1 ;
  • 50 : h := 2 ;
  • 51 : h := 3 ;
  • 52 : h := 4 ;
  • 53 : h := 5 ;
  • 54 : h := 6 ;
  • 55 : h := 7 ;
  • 56 : h := 8 ;
  • 57 : h := 9 ;
  • 65 : h := 10;
  • 66 : h := 11;
  • 67 : h := 12;
  • 68 : h := 13;
  • 69 : h := 14;
  • 70 : h := 15;
  • End;
  • b := exp(p * ln(16)) * h;
  • p := p + 1;
  • v := v - 1;
  • n := n + b;
  • end;
  • hexadeci := n;
  • end;
function decibinr(decival : integer) : string;
var
i : integer;
j : integer;
h : string;
n : string;

begin
i := decival     ;
while i <> 0 do
begin
j := i mod 2;
i := i div 2;
h := inttostr(j) + h   ;

end;
decibinr := h;
end;

function decioct(decival : integer) : string;
var
j : integer;
h : string;
b : string ;
res : string;
n : integer;
begin
n := decival  ;
while n >= 8 do
begin
j := n mod 8;
n := n div 8;
b := inttostr(j) + b;
end;
b := inttostr(n) + b  ;
decioct := b;
end;

function decihexa(decival : integer) : string;
var
h : string;
res : string;
n : integer;
b : integer;

begin
n := decival;
while n >= 16 do
begin
b := n Mod 16 ;
n := n div 16   ;
CASE b of
        0 : h := '0';
        1 : h := '1';
        2 : h := '2';
        3 : h := '3';
        4 : h := '4';
        5 : h := '5';
        6 : h := '6';
        7 : h := '7';
        8 : h := '8';
        9 : h := '9';
        10 : h := 'A';
        11 : h := 'B';
        12 : h := 'C';
        13 : h := 'D';
        14 : h := 'E';
        15 : h := 'F';
END;
res := h + res;
end;
CASE n of
        0 : h := '0';
        1 : h := '1';
        2 : h := '2';
        3 : h := '3';
        4 : h := '4';
        5 : h := '5';
        6 : h := '6';
        7 : h := '7';
        8 : h := '8';
        9 : h := '9';
        10 : h := 'A';
        11 : h := 'B';
        12 : h := 'C';
        13 : h := 'D';
        14 : h := 'E';
        15 : h := 'F';
END;
 res := h + res ;
 decihexa := res;
 end;

 function bindeci(binval : string) : integer;
 var
i : integer;
res :  variant;
h : string;
bin : string;
begin
bin := binval  ;
 res := 0   ;
for i := 0 to Length(bin)-1 do
begin
h := copy(bin,length(bin)-i,1) ;
if i = 0 then
begin
if h = '1' then res := res + 1  ;
h := '0';
end ;

if h = '1' then res := res + Exp(i*Ln(2))  ;
end ;
 bindeci := res;
end;

function octdeci(octval : integer) : integer;
var
i : integer;
j : string;
h : string;
test : integer;
b : integer;
n : integer;
res : integer;
result2 : variant;
result3 : integer;
oct : integer;

begin
oct := octval;
n := length(inttostr(oct)) - 1 ;
for i := 0 to n do
begin
j := inttostr(oct)  ;
b := strtoint(copy(j,n-i+1,1));
if i = 0 then
begin
res := b  ;
end
else
begin
result2 := exp(i*ln(8)) * b  ;
result3 := result3 + result2
 end;
 end;
 result2 := res + result3 ;
 octdeci := result2;
end ;

function hexadeci(hexaval : string) : integer;
var
z : integer;
x : integer;
v : integer;
p : integer;
b : variant;
h : integer;
n : integer;
begin
x := Length(hexaval);
v := x;
p := 0;
n := 0;
b := 0;
while v >= 1 do
begin
z := Ord(hexaval[v])  ;  {Je recupere la valeur du charactere pour pouvoir utiliser le Case * of ... j'aurais donc pu directement les convertir en hexa, mais c'est pas le but}

 Case z of
 48 : h := 0 ;
 49 : h := 1 ;
 50 : h := 2 ;
 51 : h := 3 ;
 52 : h := 4 ;
 53 : h := 5 ;
 54 : h := 6 ;
 55 : h := 7 ;
 56 : h := 8 ;
 57 : h := 9 ;
 65 : h := 10;
 66 : h := 11;
 67 : h := 12;
 68 : h := 13;
 69 : h := 14;
 70 : h := 15;
End;
b := exp(p * ln(16)) * h;
p := p + 1;
v := v - 1;
n := n + b;
end;
hexadeci := n;
end;  

 Conclusion

Je met un zip qui montre comment utiliser les fonctions, et comment empecher la saisie de characteres qui entraineraient une erreur dans les Edit .
Ne ralez pas parcqu'il y a des fichiers inutiles dans le zip, je ne sais pas lesquels ne sont pas necessaires...  

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

AJOUTER UN OBJET (ICI LABEL POUR L'EXEMPLE) DYNAMIQUEMENT SU...
FAIRE UNE PAUSE DE ** SECONDES OU MILLISECONDES SANS "PERDRE...
RENVOYER CE QU'IL Y A AVANT UNE STRING, APRES UNE STRING OU ...

 Sources de la même categorie

Source avec Zip Source avec une capture CONVERTISSEUR D'UN NOMBRE DÉCIMAL EN BINAIRE ET HEXADECIMAL par ludokk
Source avec Zip Source avec une capture PREMIER OU PAS? par ludokk
Source avec Zip Source avec une capture CONJECTURE DU CARRÉ DES FACTEURS par Bacterius
Source avec Zip Source avec une capture GÉNÉRATEUR DE NOMBRES PSEUDO-ALÉATOIRES par Bacterius
Source avec Zip Source avec une capture ALGORITHME DE HASH LEA par Bacterius

Commentaires et avis

Commentaire de Nono40 le 02/11/2002 13:32:13

Si tes conversions de base 10 à autres sont simples, tes conversions de autres à base 10 sont bien compliquées : utiliser des variants et des exp() juste pour des conversions...
En fait comme tu commence par le poids faible des nombre alors qu'il faut commencer par le poids fort. Ainsi à chaque chiffre l'opération est la même :
Result:=Result*Base+Valeur(ChiffreSuivant);

Voici ce que ça donne pour la base 2 :
function bindeci(binval : string) : integer;
var i : integer;
begin
  result:=0;
  for i := 1 to Length(binval) do Result:=Result*2+Ord(BinVal[i])-Ord('0');
end;

Et vu que pour toutes les bases le calcul est le même, il est préférable de ne faire qu'une seule procédure : ( elle fonctionne pour les bases 2 à 36 )
function basedeci(binval : string;Base:Integer) : integer;
var i : integer;
begin
  result:=0;
  for i := 1 to Length(binval) do
  Case BinVal[i] Of
    '0'..'9':Result:=Result*base+Ord(BinVal[i])-Ord('0');
    'A'..'Z':Result:=Result*base+Ord(BinVal[i])-Ord('A')+10;
  End;
end;

Dans DeciHexa tu met deux fois le case ... Of, une seule fois suffit si turemplace
while n &gt;= 16 do par while n&lt;&gt;0 do ( comme tu as fait pour la base 2 )

Pense aussi à utiliser Result plutôt qu'une variable intermédiaire, ne recopie pas non plus les paramètres dans des variables locales : c'est moins lisible et parfaitement inutile pour la vitesse.

Nono.

Commentaire de hvb le 02/11/2002 14:22:40

merci tout d'abord à toi d'avoir pris le temps de checker ma source (c'est pratique pour un debutant).
Je pense voir a peu près mes erreurs grace à ton commentaire, (apres un petit temps de reflexion tout de meme ^^ ) .
Tout d'abord je comprends pkoi commencer par le bit de poid fort et non de poid faible, cela m'evitera de checker si c'est le bit le plus faible a chaque fois... ce qui entrainera donc aussi la suppression du case inutile.
Malgré tout ca, il va falloir que je relise plusieurs fois ta ligne "for i := 1 to Length(binval) do Result:=Result*2+Ord(BinVal[i])-Ord('0');" , je ne comprends pas la soustraction du Ord('0') ...
bref je vais de toute facon essayer de tout refaire pour gerer les virgules.
Merci à toi. :)

Commentaire de Nono40 le 02/11/2002 19:27:37

Le Ord(BinVal[i])-Ord('0') est pour obtenir la valeur de 0 à 9 à partir des caractères ascii '0' à '9'. Comme tu as mis dans ton source la code ascii de '0' est 48 et celui de '9' est 57, on aurai pu écrire Ord(BinVal[i])-48. Mais ceci implique de connaitre la valeur 48. En plaçant Ord('0') le résultat est le même mais il n'y a pas besoin de connaitre la valeur Ascii de '0'.

Pour les virgules, tout dépend du format utilisé pour le stockage. L'un des format connu est le IEEE754 : ( format Single de Delphi )
http://www.blois.univ-tours.fr/~marcel/archi/node53.html
http://lojiax.free.fr/systeme/cours.htm

Nono.

Commentaire de Jeankiki le 08/11/2002 13:38:59

Tu peux aller voir le composant ci-dessous à l'adresse ci-dessous.
http://www.delphifr.com/article.aspx?Val=1930

Commentaire de sasah le 06/08/2008 11:55:41

salut! il y a presque tout là mais porrais-tu me donner le code source de la conversion binaire-hexa, j'ai essayé de combiner les fonctions bindeci et decihexa plusieurs fois mais ça n'a pas marché.
Merci!

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,374 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales