<jupyter_start><jupyter_text>Expresión correcta de una medición En la sección anterior vimos las causas que provocan errores en las mediciones, también vimos los tipos de errores y como calcularlos. En esta sección veremos como expresar la medición de forma correcta, con la cantidad de decimales adecuados.     Pero antes vamos a ver dos conceptos necesarios para escribír el resultado de una medición.     Truncamiento y Redondeo    En muchos casos al realizar operaciones matemáticas nos dan como resultado un número con muchos decimales. En la práctica no solemos anotar todos los decimales por lo que estamos cometiendo un error en el resultado final. La manera de **reducirlo, no de eliminarlo** es redondear el número.     Hay muchos tipos de redondeo, probablemente ustedes estén acostumbrados al **truncamiento** pero este método es indeseado para nosotros. Vamos a explicarlo por si no todos están familiarizados.      Truncamiento: Consiste en **"cortar"** el número con la cantidad de decimales que establecimos.Ejemplo n°1 Supongamos que tenemos el número 12,46779987, podemos quedarnos por ejemplo con dos decimales, por lo tanto el número que usamos es :12,46 Ejemplo n°2 Supongamos que tenemos el número 0,2396168, podemos quedarnos por ejemplo con cuatro decimales, por lo tanto el número que usamos es :0,2396          Esta es una posible implementación pero no es la mas adecuada, ya que si vemos el primer ejemplo, el número esta mas cerca de 12,47 que de 12,46. Sin embargo en el segundo caso funcionó correctamente.    En la siguiente animación puede variar con el slider un número de con 5 decimales, y con el otro slider puede decidir cuantos decimales quiere utilizar. Abajo vera el resultado del número truncado.    **Antes de comenzar no olvide presionar el botón Show Widgets para poder ver la animación**<jupyter_code># nbi:hide_in
import math
a = widgets.FloatSlider(min=0, max=2, step=1e-5,readout_format='.5f')
a.style.handle_color = 'lightblue'
b = widgets.IntSlider(min=0, max=4)
b.style.handle_color = 'lightblue'

def truncamiento(numero, cant_decimlaes):
    numero1 = numero
    stepper = 10.0 ** cant_decimlaes
    numero = math.trunc(stepper * numero) / stepper
    return 'El número {} truncado con {} decimales es {}'.format(numero1, cant_decimlaes, numero)

interact(truncamiento, numero=a, cant_decimlaes=b);<jupyter_output><empty_output><jupyter_text>Redondeo: Hay varios tipos de redondeo distintos, nosotros vamos a utilizar el **redondea de la mitad para arriba**     Consiste en **redondear** el número con la cantidad de decimales deseados mirando el número a la derecha de la cantidad deseada, siguiendo esta regla    * Si el decimal es **mayor o igual** a **5** se redondea hacia arriba, es decir se incrementa en 1 la última cifra deseada.       * Si el decimal es **menor** a **5** se redondea hacia abajo, es decir la última cifra deseada se deja sin modificar.       Veamos algunos ejemplos:     Ejemplo n°1 Supongamos que tenemos el número $4,\underbrace{25}7$, podemos quedarnos por ejemplo con dos decimales, por lo tanto nos tenemos que concentrar en el segundo decimal, el número $5$. Luego teneos que ver si el número que sigue es mayor-igual que cinco o menor, como en este caso es $7$ redondeamos hacia arriba sumando un $1$ al $5$.Por lo cual el número que usamos es :$\boxed{4,26}$ Ejemplo n°2 Supongamos ahora que tenemos el número $3,\underbrace{1124}2$, podemos quedarnos por ejemplo con cuatro decimales, por lo tanto nos tenemos que concentrar en el cuarto decimal, el número $4$. Luego teneos que ver si el número que sigue es mayor-igual que cinco o menor, como en este caso es $2$ redondeamos hacia abajo dejando el $4$ como esta.Por lo cual el número que usamos es :$\boxed{3,1124}$   Ejemplo n°3 Supongamos ahora que tenemos el número $1,\underbrace{386}5$, podemos quedarnos por ejemplo con tres decimales, por lo tanto nos tenemos que concentrar en el tercer decimal, el número $6$. Luego teneos que ver si el número que sigue es mayor-igual que cinco o menor, como en este caso es $5$ redondeamos hacia rriba sumando un $1$ al $6$. Por lo cual el número que usamos es :$\boxed{1,387}$      **Antes de comenzar no olvide presionar el boton Show Widgets para poder ver la animación**<jupyter_code># nbi:hide_in
import math
a = widgets.FloatSlider(min=0, max=5, step=1e-5,readout_format='.5f')
a.style.handle_color = 'lightblue'
b = widgets.IntSlider(min=0, max=4)
b.style.handle_color = 'lightblue'

def redondeado(numero, cant_decimlaes):
    numero1 = numero
    numero = round(numero+1e-6, cant_decimlaes)
    return 'El número {} redondeado con {} decimales es {}'.format(numero1,cant_decimlaes, numero)

interact(redondeado, numero=a, cant_decimlaes=b);<jupyter_output><empty_output><jupyter_text>¿Por qué redondear en vez de truncar?Como se podrán imaginar la razón para redondear números en vez de truncarlos es el menor error que se comete en el primer caso.     Analicemos el peor caso de cada uno.    Truncar un número El peor caso ocurre cuando el decimal que estamos truncando es un $9$ antepuesto por un $0$. por ejemplo si truncamos con 1 decimal el número $1,099$, al truncarlo nos queda $1,0$. El error cometido es la resta del número real y el truncado, por lo tanto el error cometido es:    $$ \boxed{Error_{máx} = 1,099 - 1,0 = 0,099} $$      Con lo anterior estamos en condiciones de decir que el error máximo cometido al utilizar truncamiento es el menor decimal elegido. Si decidimos truncar con $2$ decimales el máximo error cometido sera menor a $0,01$, si utilizamos $5$ decimales sera $0,00001$.       Redondear un número El peor caso ocurre cuando el decimal que estamos redondeamos es un $5$, ya que a partir de ahí decidimos como redondear, si para arriba o para abajo. por ejemplo si redondeamos con 1 decimal el número $1,45$, al truncarlo nos queda $1,5$. El error cometido es la resta del número real y el redondeado, por lo tanto el error cometido es:    $$ \boxed{Error_{máx} = 1,5 - 1,45}=0,05 $$      Con lo anterior estamos en condiciones de decir que el error máximo cometido al utilizar redondeo es la mitad del de los decimales elegidos. Si decidimos redondear con $2$ decimales el máximo error cometido sera menor a $0,005$, si utilizamos $5$ decimales sera $0,000005$.           Tal vez no parezca mucha la diferencia entre un caso y el otro, pero este error se va propagando entre operaciones y mientras mas operaciones mas grande se va haciendo este erro, por lo cual es importante utilizar redondeo y no truncamiento.    Veamos esto en la siguiente simulación: Supongamos que sumamos números aleatorios que varían entre 0.01 y 0.05 y realizamos la suma con todos los decimales, truncando y redondeando. Veamos cuales son los resultados. Puede elegir la cantidad de números que se suman deslizando el slider.    **Antes de comenzar no olvide presionar el botón Show Widgets para poder ver la animación**<jupyter_code># nbi:hide_in
import math 

a = widgets.IntSlider(min=100, max=5000)
a.style.handle_color = 'lightblue'

def truncate(num):
    stepper = 10.0 ** 3
    return math.trunc(stepper * num) / stepper


def ejemplo(Nexp):
    
    sum_num      = 0
    sum_truncate = 0
    sum_redondeo = 0    

    numeros = + np.random.uniform(low=0.1, high=0.5, size=Nexp)

    for i in range(Nexp):
        sum_num      += numeros[i]
        sum_truncate += truncate( numeros[i])
        sum_redondeo += round(numeros[i], 3) 

    print('Comprobación mediante truncamiento y redondeo de 3 decimales')    
    print('La suma original es = ', sum_num)    
    print('La suma con valores truncados a 3 decimales es = ', truncate(sum_truncate))
    print('El error cometido al truncar es = ', (sum_num - sum_truncate))
    print('La suma con valores redondeados a 3 decimales es = ', round(sum_redondeo,3))
    print('El error cometido al redondear es = ', np.abs((sum_num - sum_redondeo)))
    print ('')

interact(ejemplo, Nexp=a);<jupyter_output><empty_output><jupyter_text>De la simulación podemos notar que mientras mas operaciones, en este caso sumas, se realizan, mayor es el error cometido, veremos en la siguiente sección que para el caso de multiplicaciones y potencia el error se acrecienta. Por lo cual siempre tenemos que **_redondear_ nunca _truncar_**  Cifras significativasCuando realizamos operaciones en una calculadora parece como si fuese **“correcto”** o **“más exacto”** escribir los resultados con tantas cifras decimales como aparecen en pantalla, pero esto la mayoría de las veces carece de sentido. Debemos ser sensatos al escribír el resultado final.    Una cifra es **significativa** cuando se la conoce con una **exactitud aceptable**. Así, cuando se mide con un termómetro que aprecia hasta 0,1 °C no tiene ningún sentido que se escriban resultados, por ejemplo, del tipo 36,25 °C o 22,175 °C. Esto es, la cantidad de decimales después de la coma, esta relacionada con la exactitud del instrumento (y no con la cantidad de dígitos que maneja una calculadora)          Ejemplo n°1: Piense en lo siguiente, suponga que realiza una medición de la corriente que circula por un resistor y la misma es de $1,7 \pm 0,1$ A y la diferencia de potencial es $15,4 \pm 0,1$ V. Utilizando la ley de Ohm nos queda $R = \frac{V}{I}=\frac{15,4V}{1,7A}=9,058823529.$$$$$    Este resultado no tiene sentido, pues nuestras mediciones tienen una precisión de un decimal, por lo cual no podemos asegurar el valor de mas de un decimal. En la próxima sección veremos como calcular su incerteza que es de $\Delta R = 0,5916 \Omega$, que si lo redondeamos con un decimal nos queda $\Delta R = 0,6 \Omega$.$$$$La medición se escribe de forma correcta como:$$\boxed{R = 9,1 \pm 0,6 \Omega}$$                Las cifras significativas de una medida son los dígitos que no están afectados por el error, más una última cifra sometida al error de la medida, por lo cual este último número no es exacto. Normalmente solo se utiliza una cifra significativa en la incertidumbre, definiendo con esto la cantidad de dígitos necesarios para escribir el número. La primer cifra significativa de la incertidumbre es el primer número distinto de cero.       Las cifras significativas no tienen ninguna relación “fija”  con la posición de la coma decimal, esto es, no tiene siempre que ser 1 o 2 lugares. La cantidad de decimales depende del instrumento utilizado para medir.         Ejemplo n°2: Si digo que el resultado de una medida es $3,72m$, quiero decir que serán significativas las cifras $3, 7$ y $2$,  los dígitos $3$ y $7$ son cifras exactas y que el dígito $2$ puede ser erróneo.          Ejemplo n°3: No es lo mismo $3,70 m$ que $3,7 m$. En el primer caso queremos decir que se ha precisado hasta los centímetros mientras que en el segundo caso sólo hasta los decímetros.       Para expresar correctamente los resultados de operaciones aritméticas, mediante cifras significativas, es necesario tener en cuenta que dicho resultado no puede tener más decimales que el número de menor cantidad de decimales involucrado en la operación.     Abajo les dejo otra animación con la cual pueden seleccionar un número entre 0 y 20 y pueden seleccionar la cantidad de cifras significativas. Para presentar el número se redondea no se trunca.    **Antes de comenzar no olvide presionar el boton Show Widgets para poder ver la animación**<jupyter_code># nbi:hide_in

a = widgets.FloatSlider(min=0, max=20, step=1e-5,readout_format='.5f')
a.style.handle_color = 'lightblue'
b = widgets.IntSlider(min=1, max=5)
b.style.handle_color = 'lightblue'
'''
a=widgets.FloatText(
    value=7.5000,
    description='Número:',
    disabled=False
)
'''

def cifra(numero, cifras_significativas):
                        
    numero2 = numero
    if numero < 10 :
        numero = round(numero+1e-6, cifras_significativas-1)
    elif  cifras_significativas > 2:
        numero = round(numero+1e-4, cifras_significativas-2)
    elif cifras_significativas == 2 :
        numero = (numero+1e-6)/ 10
        numero = round(numero, 1)
        numero = numero * 10
    else:
        numero = round(numero/ 10)   
    return 'El número {} con {} cifras significativas es {}'.format(numero2,cifras_significativas,numero)

interact(cifra, numero=a, cifras_significativas=b);<jupyter_output><empty_output><jupyter_text>Realice los siguientes ejercicios.**Antes de comenzar no olvide presionar el boton Show Widgets para poder ver la actividad**<jupyter_code># nbi:hide_in
nbi.short_answer('Expresar g = 9,80666 con 4 cifras significativas', answers='9,807'
                 , explanation='hay que redondear el tercer decimal')

nbi.short_answer('sqrt(2) con 4 cifras significativas', answers='1,414'
                 , explanation='hay que redondear el tercer decimal')

nbi.short_answer('pi² con 3 cifras significativas', answers='9,87'
                 , explanation='hay que redondear el segundo decimal')<jupyter_output><empty_output><jupyter_text>Expresión correcta de una medición       Vimos en la sección anterio que la forma correcta de expresar una medida es a siguiente.$$$$      $$ \boxed{X = X_o \pm \Delta X}$$ donde: $$$$    *  X es el resultado de la medición. $$$$    *  $X_o$ es el valor representativo de la medición (el valor que consideramos como verdadero).$$$$    *  $\Delta X$ es el error absoluto, incerteza o indeterminación de la medición.$$$$            Ahora que ya vimos los conceptos de redondeo y de cifras significativas estamos en condiciones de poder escribir una medición.       Lo mas usual es representar las incertezas con una sola cifra significativa y solo en casos excepcionales y cuando existe fundamento para ello se usan mas. Esto determinará las cifras significativas del valor representativo.              Ejemplo n°1: Para medición $ X = 4,52 \pm 0,38 $ al tomar una sola cifra significativa después de la coma (en el error absoluto $0,\underbrace{3}$ ) y redondeando el número nos queda $\Delta X=0,4$. De forma similar como nuestra medición no puede ser mas precisa que el error que estamos cometiendo debemos también redondear el valor representativo $X_o$ a un sola cifra significativa quedándonos $X_o = 4,5$. Por lo tanto la medición final se debe escribir como:    $$ X = 4,5 \pm 0,4 cm $$       Lo que quiere decir que el valor verdadero de la medición se encuentra entre $4,1$ y $4,9 cm$        La siguiente animación les ayudará a entender la forma correcta de representar una medida con una sola cifra significativa (solo el primer número distinto de cero en el error absoluto es válido) y redondeando el valor. Esto se verá con mas detalle en la siguiente sección.<jupyter_code># nbi:hide_in

b = widgets.FloatSlider(min=0, max=2, step=0.01)
b.style.handle_color = 'lightblue'
a = widgets.FloatSlider(min=0, max=10, step=0.01)
a.style.handle_color = 'lightblue'

def medicion(valor_representativo, error_absoluto):
    
    valor = valor_representativo
    error = error_absoluto
    if error_absoluto > 1: 
        error_absoluto = round(error_absoluto+0.01, 0)
        valor_representativo = round(valor_representativo+0.01, 0)
    else:
        error_absoluto = round(error_absoluto+0.01, 1)
        valor_representativo = round(valor_representativo+0.01,1)
    return 'La medicion X = {} +/- {} se escribe de forma correcta como: X = {} +/- {}'.format(valor, error,valor_representativo, error_absoluto)

interact(medicion, valor_representativo=a, error_absoluto=b);<jupyter_output><empty_output><jupyter_text>Ejemplo n°2: Dada la medición $24567 \pm 2908 m$, exprésela de forma correcta con una sola cifra significativa.$$ $$    Lo primero que hacemos es tomar una sola cifra significativa del error absoluto y la redondeamos$$ \underbrace{2}908$$    como lo que le sigue al $2$ es un $9$, lo redondeamos hacia arriba convirtiéndolo en un $3$$$$$Por lo cual ya definimos el error absoluto como $$\Delta X = 3000 m$$     Ahora tenemos que redondear el valor representativo para finalizar. Lo importante acá es redondear la cifra que coincida con el error absoluto, en este caso es la unidad de mil. Con esto podemos definir que el 2 es una cifra exactas pero el 4 correspondientes a la unidad de mil hay que redondearlo. $$X_o = 2\overbrace{4}^{Udm}567 m$$$$\Delta X =  0\underbrace{3}_{Udm}000 m$$    Por lo cual la medición debe expresarse como:        $$ \boxed {X = 25000 \pm 3000 m}$$               Ejemplo n°3: Dada la medición $43 \pm 0,06 m$, exprésela de forma correcta con una sola cifra significativa.$$ $$    Nuevamente lo primero que hacemos es tomar una sola cifra significativa del error absoluto y la redondeamos$$ 0,0\underbrace{6}$$    Ahora tenemos que buscar la cifra correspondiente en el valor representativo, como en este caso no esta escrita, lo que tenemos que hacer es escribirla. Por lo cual la medición se expresa como:$$ \boxed {X = 43,00 \pm 0,06 m}$$      **Antes de comenzar no olvide presionar el boton Show Widgets para poder ver la actividad**   Escriba las siguientes mediciones con una sola cifra significativa. Separe con "+/-" el valor representativo del error absoluto sin dejar espacios. Ejemplo 45+/-1<jupyter_code># nbi:hide_in
nbi.short_answer('Xo = 2238,2816 +/- DX = 349,89432', answers='2200+/-300')

nbi.short_answer('Xo = 5719,9123 +/- DX = 91,538915', answers='5720+/-90')

nbi.short_answer('Xo = 8,3794350 +/- DX = 0,8716577', answers='8,4+/-0,9')

nbi.short_answer('Xo = 0,0055671 +/- DX = 0,0000255', answers='0,00557+/-0,00003')

nbi.short_answer('Xo = 0,0893651 +/- DX = 0,0134952', answers='0,09+/-0,01')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07688797627195984, 'fraction_numerical': 0.030800821355236138, 'mean_word_length': 4.1872781065088756, 'pattern_counts': {'":': 0, '<': 30, '<?xml version=': 0, '>': 31, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '474702', 'license': 'MIT', 'n_tokens_mistral': 6072, 'n_tokens_neox': 5741, 'n_words': 2333, 'path': 'Mediciones/expresion-medicion.ipynb', 'repo_name': 'NicolasFerragamo/AEA', 'size': '17532'}