1. Accueil
  2. Delphi / Pascal
  3. Sources Delphi / Pascal
  4. Sources Maths
  5. Conversions : binaire - octale - decimale - hexadecimale

Conversions : binaire - octale - decimale - hexadecimale

Soyez le premier à donner votre avis sur cette source.

Vue 11 780 fois - Téléchargée 489 fois


Télécharger le projet
Commenter

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 / Exemple : 


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...
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Signaler
Messages postés
1
Date d'inscription
samedi 2 août 2008
Statut
Membre
Dernière intervention
6 août 2008
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!
Signaler
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
 1
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.
Signaler
Messages postés
939
Date d'inscription
vendredi 25 octobre 2002
Statut
Membre
Dernière intervention
27 janvier 2009
 1
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. :)
Signaler
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
 1
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 >= 16 do par while n<>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.
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (hvb)