Conversor IEEE-754 ~ Programmming

Programa para pasar un número en decimal a IEEE en simple o doble precisión y viceversa

Decimal -------> IEEE

IEEE -------> Decimal

PROGRAM decbi(input,output);
TYPE
TAarray = ARRAY[1..20]OF integer;
TAarray2 = ARRAY[1..64]OF char;
TAarray3 = ARRAY[1..23] OF char;
TAarray4 = ARRAY[1..12] OF integer;
TAarray5 = ARRAY[1..32] OF char;
TAarray6 = ARRAY[1..10] OF char;
TAarray7 = ARRAY[1..40] OF integer;
TAarray8 = ARRAY[1..8] OF char;
TAarray9 = ARRAY[1..25] OF char;
TAarray10 = ARRAY[1..11] OF char;
arraydefinitivo = ARRAY[1..54] OF char;
VAR
numerocompleto:TAarray2;
mantisasp:TAarray3;
numero:string(11);
parteentera:string(11);
partedecimal:string(11);
posicioncomainicial,posicioncoma,inicio,total,contador1,entero,decimal,cifras,signo,exponentesp:integer;
parteenteraA:TAarray;
restobin:TAarray4;
restobin2:TAarray7;
ndecimal:real;
numeroensimpleprecision:TAarray5;
a:integer;
stringhexadecimal1:TAarray6;
stringhexadecimal2:TAarray3;
numeroendobleprecision:TAarray2;
(**********************************************************************************************************************************************************************************)
(**********************************************************************************************************************************************************************************)
(**********************************************************************************************************************************************************************************)
numeroieee:string(16);
icontador:integer;
iarraysimple,iarraydoble:TAarray2;
isignosp,signodp:char;
iexponentesp:TAarray8;
iexponentedp:TAarray10;
iposicioncomasp,iposicioncomadp:integer;
inumerobinariosp:TAarray3;
inumeroconcomasp:TAarray9;
iimantisa:arraydefinitivo;
numerototali:real;
(******************************************************************************)
PROCEDURE desplazarcoma;
VAR
I:integer;
intercambiador:char;
BEGIN
writeln;
FOR I:=1 TO 64 DO
IF numerocompleto[I] = ',' THEN posicioncoma:=I;
posicioncomainicial:=posicioncoma;
REPEAT
BEGIN
intercambiador:=numerocompleto[posicioncoma];
numerocompleto[posicioncoma]:=numerocompleto[posicioncoma-1];
numerocompleto[posicioncoma-1]:=intercambiador;
posicioncoma:=posicioncoma-1;
END;
UNTIL posicioncoma = 2;
(*FOR I:=1 TO 64 DO
write(numerocompleto[I]);*)
END;
(******************************************************************************)
PROCEDURE expsp;
VAR
acumulador,I,J,number:integer;
BEGIN
acumulador:=1;
exponentesp:=posicioncomainicial+127-2;(*Sumamos la posicion de la coma mas 127 y restamos los 2 que corresponden a la coma y al primer elemento*)
(*Ahora procedemos a pasar el numero a binario*);
FOR I:=11 DOWNTO 1 DO
BEGIN
IF exponentesp = 1 THEN restobin[I]:=exponentesp ELSE restobin[I]:=exponentesp MOD 2;
acumulador:=acumulador*10 + restobin[I];
exponentesp:= exponentesp DIV 2;
END;
CASE signo OF
1 : numeroensimpleprecision[1]:='1';
0 : numeroensimpleprecision[1]:='0';
END;
J:=4;
FOR I:=2 TO 9 DO
BEGIN
CASE restobin[J] OF
1 : numeroensimpleprecision[I]:='1';
0 : numeroensimpleprecision[I]:='0';
END;
J:=J+1;
END;
J:=1;
FOR I:=10 TO 32 DO
BEGIN
numeroensimpleprecision[I]:=mantisasp[J];
J:=J+1;
END;
FOR I:=1 TO 32 DO
IF (numeroensimpleprecision[I] <> '0') AND (numeroensimpleprecision[I] <>'1') THEN numeroensimpleprecision[I]:='0';
(*writeln('El array con los numeros es el siguiente:');
FOR I:=1 TO 32 DO
write(numeroensimpleprecision[I]);*)

writeln;
END;
(******************************************************************************)
PROCEDURE hexadecimal1;
VAR
I,inicial3,final3,J,grupo,k:integer;
BEGIN
inicial3:=1;
final3:=4;
grupo:=7;
J:=1;
FOR k:=1 TO 8 DO
BEGIN
BEGIN
FOR I:=inicial3 TO final3 DO
BEGIN
CASE numeroensimpleprecision[I] OF
'1' : grupo:=grupo*10+1;
'0' : grupo:=grupo*10;
END;
END;

END;

CASE grupo OF
70000 : stringhexadecimal1[J]:='0';
70001 : stringhexadecimal1[J]:='1';
70010 : stringhexadecimal1[J]:='2';
70011 : stringhexadecimal1[J]:='3';
70100 : stringhexadecimal1[J]:='4';
70101 : stringhexadecimal1[J]:='5';
70110 : stringhexadecimal1[J]:='6';
70111 : stringhexadecimal1[J]:='7';
71000 : stringhexadecimal1[J]:='8';
71001 : stringhexadecimal1[J]:='9';
71010 : stringhexadecimal1[J]:='A';
71011 : stringhexadecimal1[J]:='B';
71100 : stringhexadecimal1[J]:='C';
71101 : stringhexadecimal1[J]:='D';
71110 : stringhexadecimal1[J]:='E';
71111 : stringhexadecimal1[J]:='F';
END;
write(stringhexadecimal1[J]);
inicial3:=inicial3+4;
final3:=final3+4;
grupo:=7;
J:=J+1;
END;
END;
(******************************************************************************)
PROCEDURE simpleprecision;
VAR
I,J:integer;
BEGIN
FOR I:=1 TO 23 DO
mantisasp[I]:='0';
J:=1;
FOR I:=3 TO 26 DO
BEGIN
mantisasp[J]:=numerocompleto[I];
J:=J+1;
END;
expsp;
writeln(' SIMPLE PRECISION 32 bits');
writeln('--------------------------------------------------|');
writeln('Signo | Exponente | Mantisa |');
writeln('-------|----------------|-------------------------|');
mantisasp[23]:='0';
write(' ',signo,' | ');
FOR I:=4 TO 11 DO
write(restobin[I]);
write(' | ');
FOR I:=1 TO 23 DO
IF (mantisasp[I] = '1') OR (mantisasp[I] = '0') THEN write(mantisasp[I]) ELSE write('0');
write(' |');
writeln;
writeln('-------|----------------|-------------------------|');
writeln('Numero en hexadecimal |');
writeln('------------------------|');
hexadecimal1;
write(' |');
writeln;
writeln('------------------------');

END;
(******************************************************************************)
PROCEDURE hexadecimal2;
VAR
I,inicial3,final3,J,grupo,k:integer;
BEGIN
inicial3:=1;
final3:=4;
grupo:=7;
J:=1;
FOR k:=1 TO 16 DO
BEGIN
BEGIN
FOR I:=inicial3 TO final3 DO
BEGIN
CASE numeroendobleprecision[I] OF
'1' : grupo:=grupo*10+1;
'0' : grupo:=grupo*10;
END;
END;

END;

CASE grupo OF
70000 : stringhexadecimal2[J]:='0';
70001 : stringhexadecimal2[J]:='1';
70010 : stringhexadecimal2[J]:='2';
70011 : stringhexadecimal2[J]:='3';
70100 : stringhexadecimal2[J]:='4';
70101 : stringhexadecimal2[J]:='5';
70110 : stringhexadecimal2[J]:='6';
70111 : stringhexadecimal2[J]:='7';
71000 : stringhexadecimal2[J]:='8';
71001 : stringhexadecimal2[J]:='9';
71010 : stringhexadecimal2[J]:='A';
71011 : stringhexadecimal2[J]:='B';
71100 : stringhexadecimal2[J]:='C';
71101 : stringhexadecimal2[J]:='D';
71110 : stringhexadecimal2[J]:='E';
71111 : stringhexadecimal2[J]:='F';
END;
write(stringhexadecimal2[J]);
inicial3:=inicial3+4;
final3:=final3+4;
grupo:=7;
J:=J+1;
END;
END;
(******************************************************************************)
PROCEDURE expdp;
VAR
exponentedp,I,restobin,acumulador2,inicial,J:integer;
BEGIN
(*writeln('Procedemos a calcular el exponente');*)
exponentedp:=posicioncomainicial+1023-2;
(*Ahora vamos a pasar el exponente a binario
writeln('El numero para pasar a binario es:',exponentedp);*)
I:=40;
REPEAT
BEGIN
restobin2[I]:=exponentedp MOD 2;
(*writeln('Cojemos un:',restobin2[I]);*)
exponentedp:= exponentedp DIV 2;
I:=I-1;
END;
UNTIL I = 1;

inicial:=1;
FOR I:=1 TO 40 DO
IF (restobin2[I] > 0) AND (restobin2[I] > restobin2[inicial]) THEN inicial:=I;
(*writeln('El numero en decimal es:');*)
J:=2;
FOR I:=inicial TO 40 DO
BEGIN
CASE restobin2[I] OF
1 : numeroendobleprecision[J]:='1';
0 : numeroendobleprecision[J]:='0';
END;
(*write(restobin2[I]);*)
J:=J+1;
END;

END;
(******************************************************************************)
PROCEDURE dobleprecision;
VAR
I,J:integer;
BEGIN
CASE signo OF
1 : numeroendobleprecision[1]:='1';
0 : numeroendobleprecision[1]:='0';
END;
writeln(' DOBLE PRECISION 64 bits');
writeln('------------------------------------------------------------------------------|');
writeln(' Signo | Exponente | Mantisa |');
writeln('--------|--------------|------------------------------------------------------|');
write(' ',signo,' | ');
expdp;
FOR I:=2 TO 13 DO
write(numeroendobleprecision[I]);
write('| ');
J:=13;
FOR I:=3 TO 64 DO
BEGIN
numeroendobleprecision[J]:=numerocompleto[I];
J:=J+1;
END;
FOR I:=13 TO 64 DO
IF (numeroendobleprecision[I] = '0') OR (numeroendobleprecision[I] = '1') THEN write(numeroendobleprecision[I]) ELSE
BEGIN
numeroendobleprecision[I]:='0';
write(numeroendobleprecision[I]);

END;
write(' |');
writeln;
writeln('--------|--------------|------------------------------------------------------|');
write('Numero en hexadecimal |');
writeln;
writeln('--------|--------------|');
hexadecimal2;
write(' |');
writeln;
writeln('--------|--------------|');
END;
(******************************************************************************)
PROCEDURE menu3;
VAR
b:char;
BEGIN
desplazarcoma;
REPEAT
BEGIN
writeln;
writeln('-------------------------------------------------');
writeln('[S] Pasar el numero a simple precision 32 bits');
writeln('[D] Pasar el numero a doble precision 64 bits');
writeln('[V] Volver');
readln(b);
CASE b OF
's','S' : simpleprecision;
'd','D' : dobleprecision;
'v','V' :writeln('Volviendo...');
OTHERWISE writeln('Error, seleccione una opcion valida');
END;
END;
UNTIL b = 'v';
END;
(******************************************************************************)
PROCEDURE dectobin;
VAR
I,contador,guia:integer;
BEGIN
contador:=0;
IF entero > 1 THEN
BEGIN
FOR I:=20 DOWNTO 1 DO
BEGIN
parteenteraA[I]:=entero MOD 2;
entero:=entero DIV 2;
contador:=contador+1;
END;
END;
FOR I:=20 DOWNTO 1 DO
BEGIN
IF parteenteraA[I] >0 THEN inicio:=I;
END;
guia:=1;
FOR I:=inicio TO 20 DO
BEGIN
CASE parteenteraA[I] OF
1 : numerocompleto[guia]:='1';
0 : numerocompleto[guia]:='0';
END;
guia:=guia+1;
END;
numerocompleto[guia]:=',';
END;
(******************************************************************************)
PROCEDURE alarray;
VAR
I,coma,largonumero,pasar:integer;
BEGIN
coma:=INDEX(numerocompleto,',');
coma:=coma+1;
largonumero:=contador1;
I:=coma+largonumero;
REPEAT
BEGIN
I:=I-1;
pasar:=total MOD 10;
CASE pasar OF
1 :numerocompleto[I]:='1';
0 :numerocompleto[I]:='0';
END;
total:=total DIV 10;
END;
UNTIL I = coma;
(*writeln('--------------------------');
writeln('El numero en binario es:');
writeln;
(*FOR I:=1 TO 64 DO
write(numerocompleto[I]);*)
END;
(******************************************************************************)
PROCEDURE decimal2;
VAR
entera,I:integer;
numero,decimal,a:real;
cadenademierda:string(30);
BEGIN
entera:=0;
total:=1;
contador1:=0;
I:=1;
REPEAT
BEGIN
numero:=ndecimal*2;
IF numero = 1 THEN
BEGIN
entera:=trunc(numero);
total:=total*10 + entera;
IF entera = 1 THEN cadenademierda[I]:='1' ELSE cadenademierda[I]:='0';
END
ELSE IF numero >1 THEN
BEGIN
entera:=trunc(numero);
ndecimal:=numero-1;
total:=total*10+entera;
IF entera = 1 THEN cadenademierda[I]:='1' ELSE cadenademierda[I]:='0';
I:=I+1;
END
ELSE IF ((numero <1) AND (numero >0)) THEN
BEGIN
entera:=trunc(numero);
IF entera = 1 THEN ndecimal:=numero-1 ELSE ndecimal:=numero-0;
total:=total*10 + entera;
IF entera = 1 THEN cadenademierda[I]:='1' ELSE cadenademierda[I]:='0';
I:=I+1;
END;
contador1:=contador1+1;
END;
UNTIL (contador1 = 20) OR (numero = 1);
alarray;
END;

(******************************************************************************)
PROCEDURE dectobin2;
VAR
resto,dividendo,divisor,I,numero:integer;
BEGIN
(* writeln('El numero en el procedimiento dectobin2 es:',numero); *)
numero:=decimal;
cifras:=0;
divisor:=1;
ndecimal:=0;
REPEAT
BEGIN
resto:=decimal MOD 10;
dividendo:=decimal DIV 10;
decimal:=dividendo;
cifras:=cifras +1;
END;
UNTIL dividendo = 0;
FOR I:=1 TO cifras DO
divisor:=divisor*10;
ndecimal:= numero/divisor;
decimal2;

END;
(******************************************************************************)
PROCEDURE separar;
(*En este procedimiento buscaremos el lugar en el que se encuentra la coma que separa la parte decimal de la binaria
y separaremos ambas partes en dos nuevas variables, parteentera y partedecimal*)
VAR
I:integer;
BEGIN
IF (numero[1] = 'I') AND (numero[2] = 'N') AND (numero[3]= 'F') THEN writeln('El resultado es infinito') ELSE IF (numero[1] = 'I') AND (numero[2] = 'n') AND (numero[3]= 'f') THEN writeln('El resultado es infinito')
ELSE IF (numero[1] = 'i') AND (numero[2] = 'n') AND (numero[3]= 'f') THEN writeln('El resultado es infinito') ELSE IF (numero[1] = 'N') AND (numero[2] = 'A') AND (numero[3]= 'N') THEN writeln('El resultado no es un numero') ELSE
IF (numero[1] = 'n') AND (numero[2] = 'a') AND (numero[3]= 'n') THEN writeln('El resultado no es un numero')ELSE
BEGIN
IF numero[1] = '-' THEN
BEGIN
signo:=1;
FOR I:=2 TO length(numero) DO
IF ((numero[I]=',')OR(numero[I]='.'))THEN posicioncoma:=I;
(*Mediante este bucle hayamos la posicion de la coma*)
FOR I:=2 TO posicioncoma-1 DO
parteentera[I]:=numero[I];
(*Pasamos la parte entera a un string aparte, ponemos posicioncoma-1 para que no se coja la coma*)
FOR I:=posicioncoma+1 TO length(numero) DO
partedecimal[I]:=numero[I];
(*Pasamos la parte decimal a un string aparte y en este caso ponemos posicioncoma+1*)
END
ELSE
BEGIN
signo:=0;
FOR I:=1 TO length(numero) DO
IF ((numero[I]=',')OR(numero[I]='.'))THEN posicioncoma:=I;
(*Mediante este bucle hayamos la posicion de la coma*)
FOR I:=1 TO posicioncoma-1 DO
parteentera[I]:=numero[I];
(*Pasamos la parte entera a un string aparte, ponemos posicioncoma-1 para que no se coja la coma*)
FOR I:=posicioncoma+1 TO length(numero) DO
partedecimal[I]:=numero[I];
(*Pasamos la parte decimal a un string aparte y en este caso ponemos posicioncoma+1*)
END;
END;

END;
(******************************************************************************)
PROCEDURE insertarentero;
(*Debido a que con el tipo string no se puede trabajar matematicamente hay que pasar los valores a un array*)
VAR
I,acumulador:integer;
BEGIN
(*Primero pasaremos la parte entera*)
entero:=0;
FOR I:=1 TO posicioncoma-1 DO
BEGIN
CASE parteentera[I] OF
'0' : acumulador:=0;
'1' : acumulador:=1;
'2' : acumulador:=2;
'3' : acumulador:=3;
'4' : acumulador:=4;
'5' : acumulador:=5;
'6' : acumulador:=6;
'7' : acumulador:=7;
'8' : acumulador:=8;
'9' : acumulador:=9;
END;
entero:=entero+acumulador;
entero:=entero*10;
END;
entero:=entero DIV 10;
dectobin;
END;
(******************************************************************************)
PROCEDURE insertardecimal;
(*Debido a que con el tipo string no se puede trabajar matematicamente hay que pasar los valores a un array*)
VAR
I,acumulador:integer;
BEGIN
(*Ahora pasamos la parte decimal*)
decimal:=0;
FOR I:=posicioncoma+1 TO length(numero) DO
BEGIN
CASE partedecimal[I] OF
'0' : acumulador:=0;
'1' : acumulador:=1;
'2' : acumulador:=2;
'3' : acumulador:=3;
'4' : acumulador:=4;
'5' : acumulador:=5;
'6' : acumulador:=6;
'7' : acumulador:=7;
'8' : acumulador:=8;
'9' : acumulador:=9;
END;
decimal:=decimal+acumulador;
decimal:=decimal*10;
END;
decimal:=decimal DIV 10;
dectobin2;
END;
(******************************************************************************)
PROCEDURE dectoieee;
BEGIN
writeln('Escriba un numero en decimal:');
readln(numero);
(*writeln('Escriba un 1 si es negativo y un 0 si es positivo');
readln(signo);*)
separar;
insertarentero;
insertardecimal;
menu3;
END;
(**********************************************************************************************************************************************************************************)
(*******************************************************************FUNCIÓN INVERSA************************************************************************************************)
(**********************************************************************************************************************************************************************************)
PROCEDURE escribirresultado;
BEGIN
writeln;
writeln(' ---------------------------------------------------------------------');
writeln(' | IEEE-HEXADECIMAL Doble Precision | DECIMAL |');
writeln(' |-------------------------------------|-------------------------------|');
write(' | ',numeroieee,' | ');
IF signodp = '-' THEN write('-');
write(numerototali:0:6);
writeln;
writeln(' ---------------------------------------------------------------------');
END;
(******************************************************************************)
PROCEDURE iiimantisadpadecimal2;
TYPE
arraysuma = ARRAY[1..54] OF real;
VAR
sumasii:arraysuma;
I,J:integer;
totalidos:real;
BEGIN
FOR I:=1 TO 54 DO
sumasii[I]:=0;
write(' ');
J:=1;
FOR I:=iposicioncomadp+3 TO 54 DO
BEGIN
CASE iimantisa[I] OF
'0' : BEGIN
sumasii[I]:=0;
J:=J+1;
END;
'1' : BEGIN
sumasii[I]:=1/2POW(J);
J:=J+1;
END;
END;
END;
FOR I:=1 TO 54 DO
totalidos:=totalidos+sumasii[I];
(*writeln('La suma total es :',totalidos:0:7);*)
numerototali:=numerototali+totalidos;
(*writeln('El numero completo es: ',numerototali:0:6);*)
escribirresultado;
END;
(******************************************************************************)
PROCEDURE iiimantisadpadecimal;
TYPE
arraysuma = ARRAY[1..54] OF integer;
VAR
I,k,J,totali:integer;
sumasii:arraysuma;
BEGIN
FOR I:=1 TO 54 DO
sumasii[I]:=0;
(*writeln('esto es la coma: ',iimantisa[iposicioncomadp+2]);*)
(*Ahora vamos a pasar la parte entera a decimal*)
J:=iposicioncomadp;
FOR I:=1 TO iposicioncomadp+1 DO
BEGIN
(*writeln('La J vale: ',J);*)
sumasii[I]:=1;
CASE iimantisa[I] OF
'0' : sumasii[I]:= 0;
'1' : BEGIN
FOR k:=1 TO J DO
sumasii[I]:=sumasii[I]*2;
END;
END;
J:=J-1;
(*writeln('LA suma de ahora es: ',sumasii[I]);*)
END;
(*Ahora calculamos el total de las sumas*)
totali:=0;
FOR I:=1 TO 54 DO
totali:=totali+sumasii[I];
(**Aqui se escribe la parte entera**)
write(' ');
numerototali:=0;
numerototali:=totali;
iiimantisadpadecimal2;
END;
(******************************************************************************)
PROCEDURE iiimantisadp;
VAR
I,J:integer;
iiacumulador:char;
BEGIN
(*writeln('La mantisa es:');
writeln;*)
iimantisa[1]:='1';
iimantisa[2]:=',';
J:=3;
FOR I:=13 TO 64 DO
BEGIN
iimantisa[J]:=iarraydoble[I];
J:=J+1;
END;
(*FOR I:=1 TO 54 DO
write(iimantisa[I]);
Ahora vamos a mover la coma
writeln(' ');*)
FOR I:=2 TO iposicioncomadp+1 DO
BEGIN
iiacumulador:=iimantisa[I];
iimantisa[I]:=iimantisa[I+1];
iimantisa[I+1]:=iiacumulador;
END;
FOR I:=1 TO 54 DO
write('');
iiimantisadpadecimal;
END;
(******************************************************************************)
PROCEDURE expdp2;
TYPE
iiTAarray = ARRAY[1..11] OF integer;
VAR
I,J,k,iiitotal:integer;
sumasi:iiTAarray;
BEGIN
J:=1;
write(' ');
FOR I:=1 TO 64 DO
write(' ');
FOR I:=2 TO 12 DO
BEGIN
iexponentedp[J]:=iarraydoble[I];
J:=J+1;
END;
write(' ');
FOR I:=1 TO 11 DO
write(' ');
(*************************)
J:=10;
FOR I:=1 TO 11 DO
BEGIN
write(' ');
sumasi[I]:=1;
CASE iexponentedp[I] OF
'0' : sumasi[I]:= 0;
'1' : BEGIN
FOR k:=1 TO J DO
sumasi[I]:=sumasi[I]*2;
END;
END;
J:=J-1;
END;
FOR I:=1 TO 11 DO
iiitotal:=iiitotal+sumasi[I];
write(' ');
iposicioncomadp:=iiitotal-1023;
write(' ');
iiimantisadp;
END;
(******************************************************************************)
PROCEDURE iiiidoble;
VAR
I,icontador:integer;
BEGIN
icontador:=1;
(*writeln('El numero de cifras es:',icontador,',por lo tanto es un numero en simple precision');*)
FOR I:=1 TO 16 DO
BEGIN
CASE numeroieee[I] OF
'0' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'1' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'2' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'3': BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'4' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'5' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'6' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'7' : BEGIN
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'8' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'9' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'A','a' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'B','b' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'C','c' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'D','d' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
'E','e' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='0';
icontador:=icontador+1;
END;
'F','f' : BEGIN
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
iarraydoble[icontador]:='1';
icontador:=icontador+1;
END;
END;
END;
(*writeln('El numero en doble precision sera:');
FOR I:=1 TO 64 DO
write(iarraydoble[I]); *)
IF iarraydoble[1] = '1' THEN signodp:='-' ELSE signodp:='+';
write(' ');
expdp2;
END;
(******************************************************************************)
PROCEDURE ieeetodecdobleprecision;
BEGIN
writeln('Este es el modo doble precision');
iiiidoble;
END;
(******************************************************************************)
PROCEDURE ifinalizarsp;
TYPE
isTAarray1 = ARRAY[1..20] OF integer;
VAR
I,L,J,iloccomasp,iacumuladorsp,ispinicio,irepeticionsp,isumatoriofinalsp,iJ:integer;
isumatoriofinalsp2:integer;
huecossuma:isTAarray1;
BEGIN
FOR I:=1 TO 20 DO
huecossuma[I]:=0;
isumatoriofinalsp:=0;
FOR I:=1 TO 25 DO
IF inumeroconcomasp[I] = ',' THEN iloccomasp:=I;
(*writeln('La coma esta en:',iloccomasp); *)
ispinicio:=iloccomasp-1;
irepeticionsp:=1;
FOR I:=iloccomasp-1 DOWNTO 1 DO
BEGIN
IF inumeroconcomasp[I] = '0' THEN
BEGIN
isumatoriofinalsp:=isumatoriofinalsp + 0;
irepeticionsp:=irepeticionsp +1;
(*writeln('Cojo un 0');
writeln('Estamos en la posicion:',I); *)
END
ELSE
BEGIN
CASE irepeticionsp OF
1 : isumatoriofinalsp:=isumatoriofinalsp +1;
2 : isumatoriofinalsp:=isumatoriofinalsp +2;
3 : isumatoriofinalsp:=isumatoriofinalsp +4;
4 : isumatoriofinalsp:=isumatoriofinalsp +8;
5 : isumatoriofinalsp:=isumatoriofinalsp +16;
6 : isumatoriofinalsp:=isumatoriofinalsp +32;
7 : isumatoriofinalsp:=isumatoriofinalsp +64;
8 : isumatoriofinalsp:=isumatoriofinalsp +128;
9 : isumatoriofinalsp:=isumatoriofinalsp +256;
10 : isumatoriofinalsp:=isumatoriofinalsp +512;
11 : isumatoriofinalsp:=isumatoriofinalsp +1024;
12 : isumatoriofinalsp:=isumatoriofinalsp +2048;
13 : isumatoriofinalsp:=isumatoriofinalsp +4096;
14 : isumatoriofinalsp:=isumatoriofinalsp +8192;
15 : isumatoriofinalsp:=isumatoriofinalsp +16384;
END;
irepeticionsp:=irepeticionsp +1;
(*writeln('Cojo un 1');*)
END;
END;
(*writeln('(****************************************');*)
iJ:=1;
irepeticionsp:=1;
isumatoriofinalsp2:=0;
FOR I:=iloccomasp+1 TO 32-iloccomasp DO
BEGIN
IF inumeroconcomasp[I] = '0' THEN
BEGIN
irepeticionsp:=irepeticionsp +1;
(*writeln('Cojo un 0');
writeln('Estamos en la posicion:',I);*)
END
ELSE
BEGIN
CASE irepeticionsp OF
1 : huecossuma[iJ]:= 50000000;
2 : huecossuma[iJ]:= 25000000;
3 : huecossuma[iJ]:= 12500000;
4 : huecossuma[iJ]:= 6250000;
5 : huecossuma[iJ]:= 3125000;
6 : huecossuma[iJ]:= 1562500;
7 : huecossuma[iJ]:= 781250;
8 : huecossuma[iJ]:= 390625;
9 : huecossuma[iJ]:= 195312;
10: huecossuma[iJ]:= 97656;
11: huecossuma[iJ]:= 48828;
END;
iJ:=iJ+1;
irepeticionsp:=irepeticionsp +1;
(* writeln('Cojo un 1');
writeln('Estamos en la posicion:',I);*)
END;
END;
(*writeln('La suma de todos los nuemros enteros es:',isumatoriofinalsp);
writeln('La suma de todos los numeros decimales es:');*)
FOR I:=1 TO 20 DO
BEGIN
(*writeln(huecossuma[I]);*)
isumatoriofinalsp2:=isumatoriofinalsp2+huecossuma[I];
END;
(*writeln('El total de los decimales es:',isumatoriofinalsp2);*)
writeln;
writeln(' ---------------------------------------------------------------------');
writeln(' | IEEE-HEXADECIMAL Simple Precision | DECIMAL |');
writeln(' |-------------------------------------|-------------------------------|');
write(' | ',numeroieee,' | ');
IF isignosp = '+' THEN
write(isumatoriofinalsp,',',isumatoriofinalsp2) ELSE write('-',isumatoriofinalsp,',',isumatoriofinalsp2);
writeln;
write(' ---------------------------------------------------------------------');
END;
(******************************************************************************)
PROCEDURE unirsp;
VAR
I,J:integer;
ispcoma:char;
BEGIN
inumeroconcomasp[1]:='1';
inumeroconcomasp[2]:=',';
J:=3;
FOR I:=1 TO 23 DO
BEGIN
inumeroconcomasp[J]:=inumerobinariosp[I];
J:=J+1;
END;
write(' ');
FOR I:=1 TO 25 DO
write(' ');
write(' ');
write(' ');
FOR I:=2 TO iposicioncomasp+1 DO
BEGIN
ispcoma:=inumeroconcomasp[I];
inumeroconcomasp[I]:=inumeroconcomasp[I+1];
inumeroconcomasp[I+1]:=ispcoma;
END;
(*writeln('Hola');
writeln('Este es el numero:');
FOR I:=1 TO 25 DO
write(inumeroconcomasp[I]);*)
END;
(******************************************************************************)
PROCEDURE imantisasp;
VAR
I,J:integer;
BEGIN
J:=1;
FOR I:=10 TO 32 DO
BEGIN
inumerobinariosp[J]:=iarraysimple[I];
J:=J+1;
END;
write(' ');
write;
FOR I:=1 TO 23 DO
write(' ');
END;
(******************************************************************************)
PROCEDURE iexpsp;
(*Pasamos el exponente a decimal para calcular el numero de desplazamientos de la coma*)
TYPE
iTAarray = ARRAY[1..8] OF integer;
VAR
I,J,k:integer;
sumas:iTAarray;
isumatorio:integer;
BEGIN
J:=7;
FOR I:=1 TO 8 DO
BEGIN
sumas[I]:=1;
CASE iexponentesp[I] OF
'0' : sumas[I]:= 0;
'1' : BEGIN
FOR k:=1 TO J DO
sumas[I]:=sumas[I]*2;
END;
END;
J:=J-1;
END;
isumatorio:=0;
FOR I:=1 TO 8 DO
isumatorio:=isumatorio+sumas[I];
(*writeln('La suma de todos los numeros es:');
writeln(isumatorio); *)
iposicioncomasp:=isumatorio-127;
(* writeln('El numero de desplazamientos de la coma es:');
writeln(iposicioncomasp); *)
END;
(*****************************************************************************************)
PROCEDURE icortarsp;
(*Ahora procederemos a cortar la cadena para separar el exponente, la mantisa y el numero*)
VAR
I,J:integer;
BEGIN
(*writeln('Ahora cortamos el array');
writeln('El numero entero es:');
FOR I:=1 TO 32 DO
write(iarraysimple[I]);*)
(*Cojemos el signo*)
IF iarraysimple[1] = '0' THEN isignosp:='+' ELSE isignosp:='-';
(*writeln('El signo es:',isignosp);
(*Cojemos el exponente*)
J:=1;
FOR I:=2 TO 9 DO
BEGIN
iexponentesp[J]:=iarraysimple[I];
J:=J+1;
END;
(*writeln('El exponente es:');
FOR I:=1 TO 8 DO
write(iexponentesp[I]);*)
iexpsp;
imantisasp;
unirsp;
ifinalizarsp;
END;

(******************************************************************************)
PROCEDURE ieeetodecsimpleprecision;
VAR
I,icontador:integer;
BEGIN
icontador:=1;
(*writeln('El numero de cifras es:',icontador,',por lo tanto es un numero en simple precision');*)
FOR I:=1 TO 8 DO
BEGIN
CASE numeroieee[I] OF
'0' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'1' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'2' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'3': BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'4' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'5' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'6' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'7' : BEGIN
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'8' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'9' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'A','a' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'B','b' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'C','c' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'D','d' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
'E','e' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='0';
icontador:=icontador+1;
END;
'F','f' : BEGIN
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
iarraysimple[icontador]:='1';
icontador:=icontador+1;
END;
END;
END;
(*writeln('El numero en simple precision sera:');
FOR I:=1 TO 32 DO
write(iarraysimple[I]);*)
icortarsp;
END;
(******************************************************************************)
PROCEDURE pasaraieee;
VAR
I:integer;
BEGIN
icontador:=0;
FOR I:=1 TO 16 DO
BEGIN
IF (numeroieee[I] ='0') OR (numeroieee[I] ='1') OR (numeroieee[I] ='2') OR (numeroieee[I] ='3') OR (numeroieee[I] ='4') OR (numeroieee[I] ='5') OR (numeroieee[I] ='6') OR
(numeroieee[I] ='7') OR (numeroieee[I] ='8') OR (numeroieee[I] ='9') OR (numeroieee[I] ='A') OR (numeroieee[I] ='a') OR (numeroieee[I] ='B') OR (numeroieee[I] ='b') OR (numeroieee[I] ='C')
OR (numeroieee[I] ='c') OR (numeroieee[I] ='D') OR (numeroieee[I] ='d') OR (numeroieee[I] ='E') OR (numeroieee[I] ='e') OR (numeroieee[I] ='F') OR (numeroieee[I] ='f') THEN
icontador:=icontador+1;
END;
IF icontador = 8 THEN ieeetodecsimpleprecision ELSE
IF icontador = 16 THEN ieeetodecdobleprecision ELSE IF (numeroieee[1] ='i')AND(numeroieee[2] ='n')AND(numeroieee[3] ='f') THEN writeln('El resultado es inf') ELSE
IF (numeroieee[1] ='I')AND(numeroieee[2] ='n')AND(numeroieee[3] ='f') THEN writeln('El resultado es inf')ELSE IF(numeroieee[1] ='I')AND(numeroieee[2] ='N')AND(numeroieee[3] ='F') THEN writeln('El resultado es inf')ELSE IF
(numeroieee[1] ='N')AND(numeroieee[2] ='A')AND(numeroieee[3] ='N') THEN writeln('El resultado no es un numero') ELSE writeln('Error, numero no valido');

END;
(******************************************************************************)
PROCEDURE ieeetodec;
BEGIN
writeln('Por favor introduzca un numero en formato ieee-754(hexadecimal):');
readln(numeroieee);
pasaraieee;
END;
(******************************************************************************)
PROCEDURE menu;
VAR
a:char;
BEGIN
REPEAT
BEGIN
writeln;
writeln('Conversor de decimal a IEEE y viceversa');
writeln('---------------------------------------');
writeln('Seleccione la operacion a realizar:');
writeln(' ');
writeln('[D] Pasar un numero de decimal a IEEE');
writeln('[I] Pasar un numero de IEEE a decimal');
writeln('[S] Salir');
readln(a);
CASE a OF
'D','d' : dectoieee;
'I','i' : ieeetodec;
'S','s' : writeln('Saliendo...');
OTHERWISE writeln('Error, opcion no valida');
END;
END;
UNTIL (a = 'S') OR (a = 's');
END;
(******************************************************************************)
BEGIN
menu;
END.

7 comentarios:

Anónimo2 de noviembre de 2012, 12:36
Hola! Magnifico el programa pero me gustaria saber si lo puedes subir de nuevo pero con algunas modificaciones para simplificarlo es decir, sin las lineas y el formato al estilo tabla. GRACIAS
ResponderEliminar
Respuestas
Unknown10 de enero de 2014, 17:20
Este comentario ha sido eliminado por el autor.
ResponderEliminar
Respuestas
Anónimo20 de octubre de 2017, 22:15
disculpa amigo q lenguaje de programacion???
ResponderEliminar
Respuestas
Unknown29 de octubre de 2017, 0:20
si me ayudarias a realizarlo en c. pero nada mas de decimal a al estandar ieee 754.
ResponderEliminar
Respuestas
Unknown29 de octubre de 2017, 0:21
este es mi correo corona.mc95@gmail.com
ResponderEliminar
Respuestas
Unknown29 de octubre de 2017, 0:23
Algo asi
Realizar un convertidor en C que dado un número en base 10 (punto flotante), imprima con resultado su representación en hexadecimal a partir de haber obtenido su representación en IEEE 754 (1985). Así como se explicó y ejemplificó en clase.
Es decir,
Recibir el número en base 10 (punto flotante) -> -120.5
Convertir a binario (punto flotante) -> -1111000.10
Normalizar -> -1.11100010 x 2^-6
Pasar a su representación IEEE 754 (1985) -> 11000010111100010000000000000000
Obtener su representación hexadecimal -> 0xc2f10000
ResponderEliminar
Respuestas
Unknown29 de octubre de 2017, 0:33
Este comentario ha sido eliminado por el autor.
ResponderEliminar
Respuestas

Añadir comentario

Programmming

jueves, 26 de enero de 2012

Conversor IEEE-754

7 comentarios:

Visitas

Buscar en el blog

Seguidores

Popular Posts