Tema-1-evaluacion

March 17, 2020

1 Tema 1: “Ambiente de desarrollo Python3 + Jupyter-

Notebook”
Curso “HERRAMIENTAS DE PROGRAMACIÓN PARA INGENIERÍA” (ING-38)
GIDAT - UNRC - Año 2020 Ing. S. J. Tosco - Ing. F. Corteggiano - Ing. E. Corti

1.1 EVALUACIÓN
Llegado a este punto, es importante evaluar los conocimientos y habilidades adquiridos…

Esta evaluación consta de 5 actividades: * 3 son para resolver y 2 para explicar

ÉXITOS!!!
NOTA: Estos son las únicas actividades del Tema 1 que deben entregarse para evaluar
la unidad correspondiente.

1
 1.2 Consignas
1.2.1 Ejercicio 1
Genere un traductor simple Ingles-Español. Idea: Use diccionario como “base de datos”. ¿Qué
cambios habría que hacer para transformarlo en un traductor Español-Inglés?

1.2.2 Ejercicio 2

A continnuación se transcribe un programa que per-

mite modelar la caída libre de un cuerpo desde una altura inicial dada y partiendo del reposo. Ex-
plicar su funcionamiento y las opciones de graficación utilizadas. https://www.profesorenlinea.
cl/fisica/Movimiento_caida_libre.html
[1]: import numpy as np
import matplotlib.pyplot as plt

class Experimento:
def __init__(self, g = 9.8):
self.g = g
self.y0 = None
self.v0 = 0 # Se deja caer.
self.type = None
self.v = None
self.y = None
self.t = None

def type_1(self, tf):

"""
Calcula altura y velocidad final en base al tiempo que tarda en caer

2
 :param tf: tiempo que demora en caer
:return : None
"""
self.type = 1
dt = 1e-6
self.t = np.arange(0,tf,dt)
self.v = self.v0 + self.g * self.t
#y = y0 - 0.5 * g * np.power(t,2); h=y0
y0 = 0.5 * self.g * np.power(tf,2)
self.y = y0 - 0.5 * self.g * np.power(self.t,2)

def type_2(self, h):

"""
Calcula tiempo y velocidad final en base a la altura inicial

:param h: altura desde la que se deja caer el objeto

:return : None
"""
self.type = 2
dt = 1e-6
tf = np.sqrt(2 * h / self.g)
self.t = np.arange(0,tf,dt)
self.v = self.v0 + self.g * self.t
self.y = h - 0.5 * self.g * np.power(self.t,2)

def show_results(self, with_plot=True):

if self.type == 1:
h = round(self.y[0],2)
vf = round(self.v[-1],2)
print('El objeto se lanza desde una altura de {}m y su velocidad␣
,→final al tocar el suelo es de {}m/s.'.format(h, vf))

else:
tf = round(self.t[-1],2)
vf = round(self.v[-1],2)
print('El objeto demora en llegar al suelo {}s y su velocidad final␣
,→es de {}m/s.'.format(tf, vf))

if with_plot:
self.plot_experiment()

def plot_experiment(self):
"""
Plot experiment

:return : None
"""

3
 plt.figure()
plt.subplot('211')
plt.plot(self.t, self.y)
plt.ylabel('Altura')
plt.xlabel('Tiempo')
plt.title('Caida libre h(t)')
plt.subplot('212')
plt.plot(self.t, self.v)
plt.ylabel('Velocidad')
plt.xlabel('Tiempo')
plt.title('Caida libre v(t)')
plt.show()

e1 = Experimento()
e1.type_1(3)
e1.show_results(with_plot=False)
e2 = Experimento()
e2.type_2(44.1)
e2.show_results()

El objeto se lanza desde una altura de 44.1m y su velocidad final al tocar el

suelo es de 29.4m/s.
El objeto demora en llegar al suelo 3.0s y su velocidad final es de 29.4m/s.

4
 1.2.3 Ejercicio 3
Implemente un programa que permita cifrar y descifrar una frase (escrita sólo en
mayúsculas) mediante el Cifrado César, permitiendo elegir el desplazamiento deseado
(https://es.wikipedia.org/wiki/Cifrado_C%C3%A9sar).

1.2.4 Ejercicio 4
A continuación se transcribe un código que busca la raiz de una función mediante el método
de la bisección. Copie en un notebook el código (ojo con espacios). Ejecútelo y explique su
funcionamiento.
[2]: import matplotlib.pyplot as plt
import numpy as np

def f(x):
"""
Define la funcion para la cual queremos encontrar alguna raiz
"""
return (np.power(x,2) + 4.0*x - 4.0) # usar (-6,-4)

def biseccion(f, a, b, tol=1.e-6):

"""
Funcion que implenta el metodo de biseccion usando
la instruccion while para encontrar raices reales de
una funcion.

:param f: es la funcion a la cual se le determina alguna raiz

:param a: valor menor del interval
:param b: valor mayor del intervalo
:param tol: es la tolerancia
:return (i,c,fmed): iteraciones, coord, valor_funcion
"""

fa = f(a)
if fa*f(b) > 0:
return None, None, None

c = (a + b)*0.5
fmed = f(c)
i = 0
while abs(b-a) > tol:

5
 if fa*fmed <= 0:
b = c # La raiz esta en el intervalo [a,c]
else:
a = c # La raiz esta en el intervalo [c,b]
fa = fmed

c = (a + b)*0.5
fmed = f(c)
i = i + 1

return i, c, fmed

tol = 1e-10
a, b = -6, -4 # para raiz en la grafica
i, x, fx = biseccion(f, a, b, tol)

# {:g} Notación científica o Decimal; https://realpython.com/

,→python-formatted-output/#the-ltformat_specgt-component

if x is None:
print('f(x) NO cambia signo en el intervalo [{0:g},{1:g}]'.format(a, b))
else:
print('En {0:d} iteraciones y con tolerancia de {1:g} la raiz es:'.
,→format(i,tol))

print('x = {0:g}, generando f({0:g}) = {1:g}'.format(x,fx))

n = int((b - a) / 0.001)
x = np.linspace(a, b, n)
y = f(x)
plt.figure()
plt.plot(x, y)
plt.ylabel('y')
plt.xlabel('x')
plt.title('Bisección')
plt.grid()
plt.show()

En 35 iteraciones y con tolerancia de 1e-10 la raiz es:

x = -4.82843, generando f(-4.82843) = -3.84581e-11

6
1.2.5 Ejercicio 5
Realiza un programa que calcule el desglose en billetes y monedas de una cantidad exacta de pesos
argentinos. ¿Cómo adaptaría dicho código si ahora se le pidiera que sirviera para dar vuelto?