Representación de flotantes

Puse los números binarios para verlo de otra forma:

En la tabla se puede observar que los números decimales en binario (los float) siguen el mismo patrón matemático de
reducir 1 al exponente de la base 2. Nosotros hacemos lo mismo en el sistema decimal pero con la base 10 ->:

• 10^-1
• 10^-2
• 10^-3
• etc

En binario, intenten sumar varios decimales para llegar a 0.1 verán no es posible. Necesitarían una infinita cantidad de números decimales para ello y la memoria de una computadora finita.

Si es que te parece muy extraño no poder representar un número decimal y difícil de entender, piensa que **este problema ya lo has tenido antes toda tu vida **en el sistema decimal con 1/3. Para ese número necesitamos infinitos dígitos decimales para representarlo.

Mi primer aporte para la comunidad 😃

Conclusión se puede decir que los flotantes son inexactos por lo tanto se los debe tratar como tal. Esto quiere decir que tenemos que manejarlos de manera aproximada. “cercano a…” por esto se recomienda no utilizar igualdad exacta == sino mayor que o menor que como el ejemplo de si queremos un numero igual a 1 tenemos que utilizar x < 1.000 y x > 0.999 para obtener una equidad aproximada.

pd. Me gusta que estos temas sutiles pero muy importantes se plasmen por escrito, no todo tiene que ser vídeo como piden algunos, el video lo pasas a 2X y luego no recuerdas de que va y terminas utilizando un == para flotante y no te funciona bien tu código. Paciencia que leer esta bueno también 😁🤓

Para los que quedaron perdidos en la ultima parte partamos por esto:

• Primero

• Como pasamos el mumero (5) en base 10 a base 2, osea a binario?, pues dividiendo el numero entre dos y almacenando el modulo asi:

5 / 2 = 2
5 % 2 = 1 <— Numero que agregamos al binario

• Entonces tenemos que el primer digito binario es (1), y la operacion de division ENTERA NO DECIMAL nos dio (2), ahora sigamos dividiendo el resultsado entre (2):

2 / 2 = 1
2 % 2 = 0 <— Segundo numero que agregamos al binario

• Ahora tenermos los dos primeros digitos del numero binario (01), y como el resultado de la DIVISION ENTERA nos dio (1), automaticamente agregamos ese numero como tercer digito del numero binario, quedando asi

5 en base 10 = 101 en base 2

• Segundo
• Ahora como seria el caso de pasar (0.1) decimal a binario?, Es ligeramente diferente solo que multiplicando por (2) en ves de dividir

0.1 * 2 = 0.2 # cogemos la parte entera para nuestro numero binario quedando (0.0)
0.2 * 2 = 0.4 # cogemos la parte entera para nuestro numero binario quedando (0.00)
0.4 * 2 = 0.8 # asi sucecivamente (0.000)
0.8 * 2 = 1.6 # agregamos el (1) de la parte entera (0.0001), y seguimos operando con la parte decimal
0.6 * 2 = 1.2 # otra ves agregamos el (1), quedando (0.00011) y operamos la parte decimal
0.2 * 2 = 0.4 # como se daran cuenta el ciclo se esta repitiendo nos volvio a dar parte decimal de (0.2)

• Asi que si seguimos operando 0.1 a binario daria algo como

0.0001100110011001100110011001100110011… infinito

• Y como python tiene acceso a memoria finita, trata de recortar el binario hasta el maximo de digitos que puede sostener, por ejemplo si solo pudiera sostener 8-bits decimalel (8 digitos decimales)

• Solo podriamos tener los primero 8 digitos decimales binarios (0.00011001) los cuales a decimal serian = 0.09765625

• Si acogieramos mas bits o digitos decimales, el numero se proximaria mas, pero consume mas memoria

Si tienen alguna duda, estare atento, gracias

Acabo de escribir un tutorial acerca de por que pasa esto y como lidiar con ello!
https://platzi.com/tutoriales/1764-python-cs/9448-por-que-obtengo-resultados-inesperados-con-los-float-como-lidiar-con-eso/
Explicado de manera sencilla y paso a paso.
Fueron varios dias de investigación. Espero y les ayude! 👍

Hola compañeros!
Acá mis notas de como entender pasar de decimal a binario,
Espero les sriva.

Honestamente no entendí 😢

Por favor mejoren esta lectura y si graban una clase con la explicación mucho mejor

Pago Platzi y aprendo en google y youtube. Por favor mejorar las explicaciones que van por texto. Gracias!

Aunque son temas que sé por la universidad, creo que seria mucho mas entendible el articulo si se utilizaran imágenes mínimamente para visualizar las expresiones. Lo ideal seria un video ya que es un tema que no todos podemos digerir tan facilmente…

Temas con este nivel de complejidad igual quedarian mejor en un video explicado con peras y manzanas en mi humilde opinion 😄

El artículo tiene muchos errores de caracteres y se pierde mucho la explicación.

Me sumo, a la petición de revisión de este articulo. Para poder tener un hilo conductivo al momento de la lectura.

La verdad, esta lectura es poco entendible. Se puede mejorar bastante para hacerla más sencilla

Creo entender el core del artículo, pero hubiese sido muchísimo mejor haberlo explicado en un vídeo. No es un tema que sea entendible para todos.

Hubiera sido mejor una explicación en video usando la pizarra interactiva que un articulo para entender este concepto

Quizás esto ayude un poco a entender: 1/3 = 0.3333333333; entonces si multiplicamos 1/3 * 3 = 1 y si lo hacemos con los decimales (float) 0.333333 * 3 = 0.9999999; con lo que llegamos a la conclusión de que (0.9999999 == 1)

Una explicación un poco compleja, es mejor que realizaran un vídeo realizando la explicación.

Comprendo, algo importante a mencionar es que, cualquier número con exponente negativo representa un número decimal, por ejemplo (recordemos que doble asterisco en Python significa exponente): 10**-1 == 0.1, el primero número (10) es la base numérica (sistema decimal), el segundo número (-1) es el número de decimales con los que queremos ser precisos, en este caso, para el sistema decimal, el exponente negativo (-1) generará un resultado con un solo decimal, si pusiéramos 10**-2 entonces el resultado es de dos decimales: 0.01 y así sucesivamente.
.
Ahora, tomando como referencia lo explicado en la clase, un número con punto flotante (un número decimal) se compone de:
.

1. Los dígitos significativos
2. El exponente (el que acabo de explicar)

.
Y estos dos se multiplican. Los dígitos significativos son el número entero que queremos convertir a decimal, mientras más números y mayor el exponente, el decimal será más preciso:

1234 * 10**-1 = 123.4
(El exponente genera un solo decimal a partir de los digitos significativos)

1234 * 10**-2 = 12.34
(El exponente genera dos decimales a partir de los digitos significativos)

1234 * 10**-3 = 1.234
(El exponente genera dos decimales a partir de los digitos significativos)

Mientras más dígitos significativos tengamos, mayor exponente podremos poner para que el resultado sea más preciso. Lo que aún no entiendo es como se relacionan estos números para la base 2 (binario): 5 * 2**-3, no entiendo cómo se relaciona ese 5 con el número 0.625 (donde en decimal 625 serían los dígitos significativos) 🤔

Si bien se entiende el artículo y la idea principal, hubiera sido mejor crear el video con mostrando el problema y la explicación de todo el asunto.

De manera muy general, como los numeros en la computadora son representados en binarios, toma mas espacio representar un numero racional en binario que un numero entero. Ademas sabiendo que python tiene un limite de 53 bits para la precision de los numeros con decimales, no se puede entonces llegar a calcular exactamente el 1.0, asi que con la capacidad de python se puede llegar es al numero dado en el articulo.

Excelente, muy buen aporte a considerar!!!
Conclusión:
- si se espera un entero usar ==
- si se espera flotante usar un intervalo.

Bastante complejos estos conceptos. Alguien tiene un video o algo donde expliquen este tema de otra forma ?

Qué genial, cómo todos comparten sus apuntes y sus dudas y todos responden o apoyan muy respetuosamente. La verdad los videos y cursos son muy buenos, pero la comunidad acá dentro es más que genial 😃.

Concuerdo, no es una lectura sencilla, por favor revisar el tema.

Me costó entenderlo y eso que me considero bueno con las matemáticas. Creo que sería bueno hacer la explicación por vídeo para mejorar la comprensión.

Es un poco mas facil verlo con las bases y los exponentes. Senti como si me tiraran una piedra en la cara con esto!

KHA, cuando cambió tanto el nivel del curso ? jajaja
Empezó muy sencillo todo

La lectura esta bien , pero sugiero que para los ejemplos se haga algún video corto.
Si desean mas información les sugiero que lean el capítulo 1 del libro de Quarteroni y Saleri , llamado Calculo científico con Matlab y Octave.
Saludos

Creo que para principiantes en este mundo del código no es muy fácil entender los binarios con solo texto. Si no se tiene un mínimo de background matemático, que te permita entender esto de una forma más rápida, es muy complicado aprender con lecturas tan complejas.

Es mejor redondear los valores:

x = 0.0
for i in range(10):
	x += 0.1
x=round(x,1) "Re-asigno la variable x, redondeandola con la función round(numero,cantidad de decimales)"
if x == 1.0:
	print(f’x = {x}’)
else:
	print(f’x != {x}’)

Resultado, x = 1.0

no entendí nada

Con ciertos temas les da flojera explicarlos o que? El profe es excelente y el curso tambien, pero los modulos en texto le baja muchos puntos

Díganme por favor, que no fui el únio que no entendió.

la verdad no entendí nada :v

Al imprimir el resultado de cada iteracion, se puede notar lo que se explica en esta clase
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

Está parte la hubieran explicado mejor en video.

un año despues, estamos viendo esta informacion, hoy es 12-12-2020

para que nos de 1.0 podemos utilizar la función round() donde le pasas el número que quieres redondear y número de decimales.

x = 0.0
for i in range(10):    
    x += 0.1
    x = round(x, 2)

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')

Resultado
x = 1.0

Hay algunos errores en el artículo, ya que cuando ponen ** se pone en negrita algunos números y se confunde, tengan en cuenta eso.

Range, controla el número de veces que se ejecuta un bucle

En resumen. Si estas en cualquier lenguaje de programación tienes que tener cuidado con los números flotantes porque en binario muchos de ellos son inexactos. LISTO.

me parece que no es buena la explicación de este tema en particular

Sinceramente no entendí nada

Buen día,
En los tutoriales del curso pueden encontrar un excelente aporte del compañero @josuegranados1219 que trata también esta problemática y nos propone varias alternativas para tratarla.
¿Por qué obtengo resultados inesperados con los float? 🤔 ¿Comó lidiar con eso? 🔧

No entiendo

No entiendo porque Platzi implementa este tipo de “clases”, si ya estan armando el curso ¿qué les puede quitar una o dos clases mas?
Está es una clase que se pudo armar como un video, lo mismo pasa con otros cursos en donde tienes que instalar y te ponen un articulo, mejor pasame el link y listo… y por qué? Bueno hay personas a las que les puede surgir un detalle, en windows pasa con algunas cosillas, pero aunque se pueda investigar, entonces para que tomar esa clase? Mejor voy al articulo, instalo y resuelvo los problemas desde alli. En fin.

Ojalá el profesor responda esta pregunta, y es por qué pasa de 1/10 a 3/32 en esto= _Regresemos a nuestro problema inicial: ¿Cómo representaremos 1/10 (que escribimos en Python cómo 0.1)? Lo mejor que podemos hacer con cuatro dígitos significativos es (0011, -101) que es equivalente a 3/32 (0.09375). _

Me perdí en esa parte…

En conclusion en el caso de los numeros flotantes el operaror == es deficiente, es mejor dar un rango de precision a<x<b aceptable.

Me gustó la explicación. La conclusión final es de lo más importante “cuando estamos trabajando con flotantes es mejor asegurarnos que los números sean aproximados en vez de idénticos. Por ejemplo x < 1.0 and x > 0.99999.” … Teniendo esto en cuenta les aseguro que nos evitamos un montón de dolores de cabeza al testear que el código de resultados correctos o aceptables…

Encontré también esto, espero les ayude:

Llamemos a X = 0,9999999…
Entonces 10X = 9,9999999…
Podemos restar estos dos valores 10X-X = 9X = 9,99999… - 0,99999…
Como se ve, la parte decimal se cancela (ya que hay infinitos 9) y se llega a la expresión
9X = 9
Es decir
X = 1
Y como X también es X = 0,99999…
Podemos decir que
0,99999… = 1

Ejecuté el programa y agregue una instrucción para que cada iteración, imprimiera el valor que iba tomando “x”

Este fue el resultado:

  DevEd git:(master) ✗ /usr/bin/python3.7 "/mnt/c/Desarrollo/DevEd/Python/Introduccion Pensamiento Computacional/iteraciones.py"
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
x != 0.9999999999999999

Muy interesante saber la precisión de los flotantes en Python, realmente fue algo nuevo, cuando me enseñaron el sistema binario siempre me pregunte como exactamente se aplicaba y con esta lectura acabo de ver una de sus implementaciones, de hecho me costo y eso que si tenia algo de bases.

Por donde comienzo… Bueno creo que será por lo del sistema binario, en el sistema binario a diferencia del decimal, solo maneja dos números el 0 y 1, donde podrías decir que la posición importa. el 0 indica que vale eso 0 y el 1 indica el valor total de esa posición, la posición tiene vale el doble de la anterior por ejemplo un numero binario normal seria el siguiente

0 0 0 0 pero este numero lo puedes ver también como
0*(8) 0*(4) 0*(2) 0*(1)

dice

Si fueran cinco ceros entonces el primero de izquierda a derecha se podría multiplicar por 16 por que es el doble del 8 y así sucesivamente.
Es por eso que si queremos un 10 por ejemplo solo tenemos que asignar los colocar 1s en las posiciones que podrían dar un 10 que seria:
1010 = 1*(8) 0*(4) 1*(2) 0*(1) = 8 + 0 + 2 + 0

Con esto creo que puede ser mas claro
si quieren practicar demuestren que
17 = 10001
6 = 110
27 = 11011

Ahora la lectura nos dice que el flotante se representa con dos números en sistema binario se parados por una “,”, donde el primero es el que se quiere dividir y el segundo es el numero que será un exponencial aplicado al numero 2(siempre es este numero porque indica el que es sistema binario).

Por lo tanto cuando pone el 5 que es 101 y el segundo numero binario -11 que es -3 que realmente el menos solo es para indicar que se aplicara como divisor, lo que realmente se esta haciendo es la siguiente operación

5/(2^3) donde 2^3 = 8
o sea 5/(2^3) = 5/8 = (101, -11)

En la lectura pone que el máximo es 53 o sea que el divisor mas grande que podemos tener es de 2^53, eso al menos en python

Espero esto sea de ayuda y si no pues… se intento.

No me queda muy claro.
Si deberían hacer un video.

Después de leer este artículo me entro la curiosidad de como calcular la representación flotante de un numero decimal según los dígitos significativos requeridos, así que después de hacer varios cálculos a mano llegué a este algoritmo que está pensado para realizarse con papel y lápiz, pero como estamos en un curso de Python lo traduje a código y se los comparto.
Son solo 18 líneas de código el resto son comentarios explicativos.
#xxxxxxx = comentarios

# Este es un algoritmo para realizar calculos en punto flotante de una división cuyo resultado es menor a uno.
# PROCEDIMIENTO:
# 1. Ingresar 1er Numero y 2do Numero
# 2. Elegir cantidad de cifras significativas en flotante.
# 3. Se muestra el resultado del algoritmo (con la cantidad de digitos significativos elegido) comparando la aproximación
# a la computadora(53 bits de precisión para Python).
# AUTOR: Miguel Salinas, algoritmo desarrollado apartir del artículo leido.
# Fuente: https://platzi.com/clases/1764-python-cs/25239-representacion-de-flotantes/ 

import math #impoorta las operacione matemáticas avanzadas
numero1 = int(input('Ingrese primer numero: '))
numero2 = int(input('Ingrese segundo numero: '))
num_cifras_signif = int(input('Ingrese el numero de cifras significativas: '))
if numero1 > numero2:
    print(f'El resultado de dividir: {numero2} / {numero1} = ')
    Numerador = numero2
    Denominador = numero1
elif numero2 > numero1:
    print(f'El resultado de dividir: {numero1} / {numero2} = ')
    Numerador = numero1
    Denominador = numero2
else:
    print(f'El resultado de dividir: {numero1} / {numero2} = 1')

# definiciones:
# A/B = (X,-n); donde A < B, X = representación en binario del numerador
# -n; es el exponente de la base 2(de binario), 
# La aproximación de la división es: A/B = X/2^n
# #####    ALGORITMO EN 3 PASOS:   ########
# 1. Estimación de X y calculo de n
# 2. Calculo de X
# 3. Mostrar resultados con la aproximación especificada.

# ================ PROCEDIMIENTO ==================
# Estimación de "X"
# x <= int(2^num_cifras_signif - 1)
x = int(math.pow(2,num_cifras_signif))

# Calculo de "n"
# n = int(log2(X*B/A))
n = int(math.log2(x*Denominador/Numerador))

# Calculo de "X"
# x = int(A / B * 2 exp(n))
x = int(Numerador/Denominador*math.pow(2,n))

# finalmente A/B = X/2^n
print('===========================================================')
print(f'Resultado del Algoritmo: {Numerador}/{Denominador} = {x}/{math.pow(2,n)} ={ x / math.pow(2,n) }, para una aprox. de {num_cifras_signif} cifras significativas')
print(f'comparado a : {Numerador}/{Denominador} ={Numerador/Denominador}, considerando hasta 53 bits de precisión para numero flotante')
print('===========================================================')

Ha sido una muy buena explicación, pero para que me quede claro averigüé como pasar un número racional en base decimal (como 0.7 o 0.125) a binario. De esta manera te das cuenta que no puedes hallar el resultado final de 0.7 ó 0.1 en binario, se vuelve un ciclo infinito.

La manera es la siguiente: para 0.125:
Se trata de multiplicar por 2 el número, si es que este es mayor a 1 entero, se agrega un 1, si es menor, se agrega un 0, en el caso de ser igual a 1, se agrega un 1 y se termina la conversión.

.125 x 2 = .250 , agregamos un cero…
.250 x 2 = .500 , agregamos otro cero…
.500 x 2 = 1.000 , agregamos un 1 y terminamos.

resultado de 0.125 en decimal a binario es: 0.001

Si hacemos esto para 0.7:
0.7×2 = 1.4 ≥ 1 ⇒ 1
0.4×2 = 0.8 < 1 ⇒ 0
0.8×2 = 1.6 ≥ 1 ⇒ 1
0.6×2 = 1.2 ≥ 1 ⇒ 1
0.2×2 = 0.4 < 1 ⇒ 0
0.4×2 = 0.8 < 1 ⇒ 0
0.8×2 = 1.6 ≥ 1 ⇒ 1
0.6×2 = 1.2 ≥ 1 ⇒ 1
0.2×2 = 0.4 < 1 ⇒ 0
0.4×2 = 0.8 < 1 ⇒ 0
el ciclo nunca acaba… igual para 0.1

Al comienzo creí entender perfectamente, luego todo se fue al carajo cuando empecé a leer lo del 101. sigo leyendo para ver si comprendo.

Creo que se entendería mejor por medio de un vídeo que en formato texto

La parte de “No existe ningún número que cumpla con la siguiente ecuación: sim * 2**-exp” es algo confusa, tal vez sería mejor algo como:
No existen números naturales a y b que cumplan la ecuación:
a * 2 ** -b = c
cuando c = 0.1
Por lo cual se recurre a números a y b que den un aproximado a 0.1, y pasa lo mismo con otros números decimales c.

Creo que este tema debió haberse explicado en vídeo 😦

Entendí algo, pero no todo.

Solución:

x = 0.0
for i in range(10):
x += 0.1

x = round(x, 1)

if x == 1.0:
print(f’x = {x}’)
else:
print(f’x != {x}’)

Mucho texto :'v

el covid se llevo el video 😦 RIP

Gracias por aclarar este tipo de punto con los flotantes.
Hace años había programado una calculadora científica muy simple en lenguaje C. Sin embargo, me topé con este diminuto tipo de error en cierto tipo de cálculos, a pesar de que era un error de cálculo tan pequeño que podría considerarse despreciable, era una astilla que se me había quedado y que si me causaba mucha inquietud haha, sobre todo porque los profesores a los que les pregunté no me supieron dar respuesta. Y bueno, ahora por fin la tengo haha.
Gracias por compartir esos aspectos de conocimiento que ningún profesor (al menos ninguno de los que me han dado clases en la escuela) toca al respecto cuando se habla de programar con números flotantes

Se entiende, aunque quedan dudas :S

Un video porfaaaaaa

seria mejor que sea grabado las clases

Profe un video por favor, hay cosas que no he logrado comprender.

Es decir que si uso decimales, para tener mayor control, es preferible en vez de usar una igualdad ==, definir un rango:

if x < 1.0 and x > 0.99999:
print(f’x = {x}’)
else:
print(f’x != {x}’)

En el casos de FLOAT a veces tenemos el inconveniente que imprime mucho decimales para solucionarlo utilizamos ROUND(numero float, cant. decimales)

total = 6 / 9
total = round (total, 2)
print(total)```

¿Saben cómo se puede sugerir al profesor de Platzi de hacer un video sobre este argumento? 🤨🧐

No quería pasar de página hasta entender bien lo que quería decir el profesor. Gracias a los compañeros por sus comentarios. Por eso al usar flotantes nunca vas a llegar a x == 1.0.

Así quedaría el código aproximado.
x = 0.0
for i in range(10):
    x += 0.1

if x < 1.0 and x > 0.99999:
    print(f'x = {x}')
else:
    print(f'x != {x}')
Output:
x = 0.9999999999999999

Ahora, ¿por qué el range con flotante se va a 0.99999 en vez de detenerse en 0.9?

Comparto la opinión me costo entender, me toco volver al lápiz y papel para entenderlo.
Pero no se les hace fabuloso esto?

Cuando tenia 18 años pense en esta hipotesis de la no existencia del 0, nunca llegamos de un punto a otro punto, solo pensamos en un desplazamiento aproximado, y luego pensé que las matematicas como las conocemos no representan toda la realidad, solo es una herramienta que en nuestra realidad es bastante útil.

Lo que entendi:

1. En base x tenemos x^n números entonces en base 2 tenemos 2^n números.
2. En Negativos se usa un bit adicional al inicio donde 0=positivo y 1=negativo
3. En decimales
   2,345(10)=2345*(10)^^(digitos signi)
   0,625 = 5/8 = 5*2^-3 =(binario) 101^-11

DECIMAL A BINARIO FACIL

0,625
0,625x2=1,250—1
0,250x2=0,500—0
0,500x2=1,000—1
0,625(10) = 0,101(2)

1/10 = 0,1
0,1x2=0,2–0
0,2x2=0,4–0
0,4x2=0,8–0
0,8x2=1,6–1
0,6x2=1,2–1
0,2 …
0,0001100110011001100110011…

Hay numeros decimales que en base dos son periodicos puros pero aun asi debemos encontrar una forma de expresarlos y esta forma es haciendo aproximaciones

El resto no lo entendi.

Investigué mas sobre este tema y encontré más detalle en la documentación oficial de Python en https://docs.python.org/es/3/tutorial/floatingpoint.html. También apliqué un cambié las líneas de código adicionando la función de redondeo posterior a la suma, de esta manera el valor final da 1.0 exacto. Esto lo aplique basado en la explicación de la documentación:

x = 0.0
for i in range(10):
    x = x + 0.1
    x = round(x,15)
    print(x)

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')```

Espero resuelva las inquietudes.
Saludos

Un poco densa la info, pero entendí el concepto aunque no quedó muy clara la explicación

Entendí el consejo de la última parte, pero no entendí muy bien el concepto matemático, alguien podría por favor proporcionar algún material complementario o no sé si exista una forma más sencilla de entender estos conceptos. gracias

Creo que hay un error:

Cuando dicen:

_"5 * 2-3. Por lo que podríamos decir (101, -11) "
_

Deberia ser (101,-1000) porque seria igual a 5(101) sobre 8 (1000)

Mi duda es porque este tipo de cosas no las explican en la escuela… Punto para platzi!

En aplicaciones cientificas esas pequeñisimas diferencias son tolerables y se les conoce como margen de error.

En aplicaciones comerciales estos pequeños errores no son admisibles. La contabilidad debe ser cuadrada al centavo.

Yo trabajo en un banco, en los lenguajes antiguos como COBOL se implementaba un tipo que era el computational 3

por ejemplo PIC S9(5)V99 COMP-3 era un numero con 5 enteros y 2 decimales.

en el fondo este formato implementaba la codificacion BCD Binary Code Decimal.

Logicamente COBOL implementaba toda la aritmetica BCD.

No entendí

Entendí casi todo, pero, ¿de dónde sale la siguiente info? (que la creo porque es de Platzi, pero quiero saber de dónde sale o cómo se confirma esa aproximación):
“Regresemos a nuestro problema inicial: ¿Cómo representaremos 1/10 (que escribimos en Python cómo 0.1)? Lo mejor que podemos hacer con cuatro dígitos significativos es (0011, -101) que es equivalente a 3/32 (0.09375). ¿Qué tal si tuviéramos cinco dígitos significativos? La mejor representación sería (11001, -1000) que es equivalente a 25/256 (0.09765625).”

mmm no entiendo

Profe usted explica muy bien, pero con video hubiera sido mejor

0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0

El post se entiende con unas dos lecturas, intenten entenderlo.
Puede ocurrir algunos typos ( que espero que se arreglen), pero ,para mi, esta bien explicado.

La vdd es que no entendí mucho este tema :v

Creo que somo varios los que nos trabamos cuando llegamos a la parte de los binarios con el 0.1.
…
En mi caso la forma en que esta redactada esa parte se me ha hecho bastante confusa agregándole que nunca había usado el sistema binario como tal en mi rutina diaria, desde mi punto de vista como estudiante esa parte debería estar mejor desglosada para su entendimiento.
…
Por ejemplo encontré en un libro como leer de manera fácil los binarios, sin meternos en los decimales, con una cuadricula donde se empieza de derecha a izquierda; luego conforme avanzamos, el valor de cada celda se multiplica por 2 y el resultado de ese valor se agrega a la celda de la izquierda
…
8 | 4 | 2 | 1 ------- Todos los números se multiplicaran por 2 al tratarse del sistema binario.
…
el 8 es el resultado de multiplicar el valor de la 3° celda (4) de derecha a izquierda por 2, los mismo aplicaría para una 5° celda donde multiplicaríamos 8 (4° celda de derecha a izquierda) por 2
…
Ahora para leer algún binario con las celdas anteriores debemos entender que igual que los números aumentan progresivamente de derecha a izquierda también leeremos el binario de derecha a izquierda, otorgando un valor a cada numero en el binario siguiendo dicha secuencia (la secuencia de las celdas)
…
si tenemos 11001 entonces leemos, de derecha a izquierda, que;
…
recordemos, tendremos 5 celdas teniendo en consideración que el binario es de 5 dígitos
… | 16 | 8 | 4 | 2 | 1 |
también recordar que 0 en binario siempre sera 0 aunque en la celda tengamos algún valor.
1 == 1
00
00
18
116
…
si sumamos los valores conseguiremos el numero en el sistema decimal, dicho numero seria = 25
…
Ahora eso no ha sido un problema como tal pero a la hora de pasar eso o tratar de interpretar eso con lo que esta escrito a partir del párrafo donde nos quieren explicar los decimales se vuelve confuso y hasta, en mi caso, pareciera carecer de coherencia porque.
…
Claro esto hablando desde mi punto de vista.
…
Si alguien pudiera ser tan amable de explicarme como se llegaron a esos valores o porque habla de 4 datos significativos y luego le sigue un numero con 6 se los agradecería infinitamente.
…
““Lo mejor que podemos hacer con cuatro dígitos significativos es (0011, -101) que es equivalente a 3/32 (0.09375).””

Es decir que si trabajamos con número muy pequeños tendremos errores de cálculo puesto que la computadora hará una aproximación del valor en cuestión.

Hola en las clases anteriores si podia correr mi programa de python en la terminal de vs code pero ahora me dice que permiso negado, alguien sabe porque sera?

rayos que nivel ajjaj

No entendí :v gracias por la confusión 😭

Estoy haciendo mi resumen, pero resulto que con 2 aportes del chat lo hicieron bastante mas entendible que la lectura:

11-Representación de flotantes

La mayoría del tiempo los Nros flotantes (tipo float) son una buena aproximación de los números que queremos calcular con nuestras computadoras. Sin embargo, a veces no se comportan de esta manera y esto puede tener consecuencias inesperadas.

Por ejemplo, trata de correr el siguiente código:

x = 0.0
for i in range(10):
    x += 0.1

if x == 1.0:
    print(f'x = {x}')
else:
    print(f'x != {x}')
# esperamos como resultado 1.0 y nos da -> 0.999999999999
# Porque pasa esto? 

En la tabla se puede observar que los números decimales en binario (los float) siguen el mismo patrón matemático de reducir 1 al exponente de la base 2. Nosotros hacemos lo mismo en el sistema decimal pero con la base 10 ->:

binarios1.webp

• 10^-1
• 10^-2
• 10^-3
• etc

En binario, intenten sumar varios decimales para llegar a 0.1 verán no es posible. Necesitarían una infinita cantidad de números decimales para ello y la memoria de una computadora finita.

Si es que te parece muy extraño no poder representar un número decimal y difícil de entender, piensa que **este problema ya lo has tenido antes toda tu vida **en el sistema decimal con 1/3. Para ese número necesitamos infinitos dígitos decimales para representarlo.

CONCLUSION:

Se puede decir que los flotantes son inexactos por lo tanto se los debe tratar como tal. Esto quiere decir que tenemos que manejarlos de manera aproximada. “cercano a…” por esto se recomienda no utilizar igualdad exacta == sino mayor que o menor que como el ejemplo de si queremos un numero igual a 1 tenemos que utilizar x < 1.000 y x > 0.999 para obtener una equidad aproximada.

Aquí un tutorial que explica el tema, fue hecho por un compañero nuestro en Platzi 😃
https://platzi.com/tutoriales/1764-python-cs/9448-por-que-obtengo-resultados-inesperados-con-los-float-como-lidiar-con-eso/

Transcribí el 4to párrafo que no entendía por causa de las negritas; agregué “saltos de línea” ficticios para no verlos tan robusto.
\n
Cuando aprendiste a contar, lo que en realidad aprendiste es una técnica combinatoria para manipular los siguientes símbolos que le llamamos números: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
\n
La forma en la que funciona esta técnica es asignando el número 10 ** 0 al número de la extrema derecha, 10 ** 1 al siguiente, 10 ** 2 al siguiente y así sucesivamente. De tal manera que el número 525 es simplemente la representación de (5 * 100) + (2 * 10) + (5 * 1).
\n
Esto nos dice que el número de números que podemos representar depende de cuanto espacio tengamos. Si tenemos un espacio de 3, podemos representar 1,000 números (10 ** 3) o la secuencia del 0 al 999.
\n
Si tenemos 4, podemos representar 10,000 (10 ** 4) o la secuencia del 0 al 9,999. De manera general podemos decir que podemos decir que con una secuencia de tamaño n, podemos repesentar 10 ** n números.

No se entiende nada este tema. Por favor, podrían revisarlo? Gracias

No entendí. Alguien que por favor me explique en cotidiano?

Buena información! Sin embargo, debería estar en video

La lectura deja todo claro, pero se podria complementar con un video.

Acá hay otros resultados interesantes al operar con números flotantes en Python que ilustran el punto de la clase:

“Cuando estamos trabajando con flotantes es mejor asegurarnos que los números sean aproximados en vez de idénticos. Por ejemplo x < 1.0 and x > 0.99999.”