Publicado el 12 de Julio del 2017
675 visualizaciones desde el 12 de Julio del 2017
67,3 KB
5 paginas
Creado hace 14a (21/09/2009)
Convirtiendo números del sistema decimal al sistema binario.
Pablo Santamaría
v0.1b (Septiembre 2009)
Veamos como puede convertirse la representación decimal de un número al sistema binario.
El procedimiento trata a las partes entera y fraccionaria por separado, así que supongamos, en
primer lugar, que el número p dado es un entero positivo. Entonces, en la base β = 2, el número
puede ser escrito en la forma
p = an × 2n + an−1 × 2n−1 + · · · + a1 × 21 + a0 =
n
X
j=0
aj2j,
donde aj son los dígitos que queremos determinar. La igualdad anterior puede ser escrita en la
forma
n
p = a0 + 2
X
j=1
aj2j−1
,
de donde se sigue que el dígito a0 se identifica con el resto de la división entera de p por la base 2:
Considerando ahora el cociente entero de tal división
a0 = mod(p, 2).
c1 =
n
X
j=1
aj2j−1 = a1 + 2
X
j=2
n
aj2j−2
,
resulta que el dígito a1 es el resto de la división entera de c1 por 2:
a1 = mod(c1, 2).
Procediendo sucesivamente, si ci denota el cociente de la división entera por 2 del paso anterior
(poniendo c0 = p), tenemos que
ci = ai + 2
n
X
j=i+1
aj2j−i
,
i = 0, 1, . . . , n,
con lo cual
ai = mod(ci, 2).
El proceso se detiene en n, puesto que el dividendo en el paso (n + 1) es cero. En efecto, siendo
cn = an = an + 0 · 2, es cn+1 = 0. El procedimiento puede ser resumido esquemáticamente como
sigue.
1
Para convertir un número entero positivo de base 10 a base β = 2.
Paso 1. Realice la división entera por 2 del cociente obtenido en el paso anterior, comenzando
con el número dado.
Paso 2. Guarde el resto de tal división.
Paso 3. Continúe con el paso 1 hasta que el dividendo sea cero.
Paso 4. Lea los restos obtenidos, desde el último al primero, para formar la representación bus-
cada.
Ejemplo: Convertir 29 a binario.
29
29/2 = 14
14/2 = 7
7/2 = 3
3/2 = 1
1/2 = 0
resto 1
resto 0
resto 1
resto 1
resto 1
↑
Entonces (29)10 = (11101)2.
Consideremos ahora la parte fraccional del número en su representación decimal. Podemos
entonces asumir que el número p dado es un número real positivo entre 0 y 1. Entonces, en la base
β = 2, puede ser escrito en la forma
p = a−1 × 2−1 + a−2 × 2−2 + · · · =
n
X
j=1
a−j2−j ,
donde a−j son los dígitos que queremos determinar. Multiplicando la igualdad anterior por 2
tenemos que
n
q1 = 2 p = a−1 +
a−j2−j+1,
X
j=2
de donde se sigue que el dígito a−1 se identifica con la parte entera de la multiplicación de p por
2:
a−1 = [q1] .
Consideremos ahora la parte fraccionaria de tal producto, si ésta no es nula podemos volver a
multiplicar por 2 para obtener
q2 = 2 (q1 − [q1]) = a−2 +
n
X
j=3
a−j2−j+2,
de donde,
a−2 = [q2] .
Procediendo sucesivamente, si qi denota el producto de 2 por la parte fraccionaria del paso anterior
(poniendo q1 = 2 p), tenemos que
qi = a−i +
n
X
j=i+1
a−j2−j+i,
i = 1, 2, dots,
de donde,
a−i = [qi] .
2
Notemos que el procedimiento continúa indefinidamente, a menos que para algún qk su parte
fraccionaria sea nula. En tal caso qk+1 = 2 (qk − [qk]) = 0 y, en consecuencia, a−(k+1) = a−(k+2) =
· · · = 0, obteniéndose así una cantidad finita de dígitos fraccionarios en la base 2. Resumimos el
procedimiento como sigue.
Para convertir un número decimal entre 0 y 1 a la base β = 2.
Paso 1. Realice la multiplicación por 2 de la parte fraccionaria obtenida en el paso anterior,
comenzando con el número dado.
Paso 2. Guarde la parte entera de tal producto.
Paso 3. Continúe con el paso 1 hasta que la parte fraccionaria sea cero, o hasta obtener el
suficiente número de dígitos requeridos para su representación.
Paso 4. Lea las partes enteras obtenidas, del principio hacia el final, para formar la representación
buscada.
Ejemplo: Convertir 0.625 a binario.
0.625
2*0.625 = 1.25
2*0.25 = 0.5
2*0.5 = 1
[1.25] = 1
[0.5] = 0
[1] = 1
↓
Nos detenemos puesto que 1 − [1] = 0. Así, (0.625)10 = (0.101)2.
Ejemplo: Convertir 0.1 a binario.
0.1
2*0.1 = 0.2
2*0.2 = 0.4
2*0.4 = 0.8
2*0.8 = 1.6
2*0.6 = 1.2
2*0.2 = 0.4
2*0.4 = 0.8
2*0.8 = 1.6
2*0.6 = 1.2
2*0.2 = 0.4
[0.2] = 0
[0.4] = 0
[0.8] = 0
[1.6] = 1
[1.2] = 1
[0.4] = 0
[0.8] = 0
[1.6] = 1
[1.2] = 1
[0.4] = 0
↓
. . .
En este caso la representación es infinita, (0.1)2 = (0.0001100110 . . . )2.
El siguiente código en Fortran77 implementa el procedimiento descrito para obtener la repre-
sentación binaria de cada número que se ingrese por teclado.
program dec2bin
------------------------------------------------------------------
Convierte números del sistema decimal al sistema binario
------------------------------------------------------------------
Declaración de variables
------------------------------------------------------------------
implicit none
integer max_digits
parameter (max_digits = 32) ! de la parte entera y "decimal"
integer bp(max_digits)
integer bf(max_digits)
---------------------------------
! digitos binarios de la parte entera
! digitos binarios de la parte decimal
! número maximo de digitos binarios
*
*
*
*
*
*
3
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
! unidades de entrada/salida estandar
! variables para construir un
! formato dinámico de impresión
character(*) ifield
parameter (ifield=’(i2)’)
character(2) sp,sf
character(14) formato
---------------------------------
integer in,out
parameter (in=5,out=6)
---------------------------------
integer p,d
integer np,nf
integer i
real num,f
---------------------------------
integer io
logical go
------------------------------------------------------------------
Proceder sobre la lista de numeros ingresados por la
entrada estandar
------------------------------------------------------------------
io = 0
do while(io.eq.0)
--------------------------------------------------------------
Leer el numero desde la entrada estandar
---------------------------------------------------------------
read(unit=in,fmt=*,iostat=io) num
if (io.eq.0) then
------------------------------------------------------------
Separar la parte entera de la parte decimal
------------------------------------------------------------
p = int(num)
f = num-p
------------------------------------------------------------
Convertir la parte entera
------------------------------------------------------------
go = .true.
np = 0
do while(go)
= np + 1
= mod(p,2)
np
d
bp(np) = d
p
if(p.eq.0.or.np.ge.max_digits) go = .false.
= int(p/2)
end do
------------------------------------------------------------
Convertir la parte decimal
------------------------------------------------------------
go = .true.
f
nf = 0
do while(go)
= 2.0*f
= nf + 1
= int(f)
nf
d
bf(nf) = d
f
if(f.eq.0.0.or.nf.ge.max_digits) go = .false.
= 2.0*(f-d)
end do
------------------------------------------------------------
Construir el formato dinamicamente: (npi1,A1,nfi1)
4
*
*
*
*
*
------------------------------------------------------------
write(sp,fmt=ifield) np
write(sf,fmt=ifield) nf
formato = ’(’ // sp // ’i1,A1,’ // sf // ’i1)’
------------------------------------------------------------
Imprimir el numero binario en la salida estandar
------------------------------------------------------------
write(unit=out,fmt=formato) (bp(i),i=np,1,-1), ’.’,
*
(bf(i),i=1,nf)
------------------------------------------------------------
endif
enddo
stop
end
5
Comentarios de: Convirtiendo números del sistema decimal al sistema binario (0)
No hay comentarios