Laboratorio_0_Introduccion

October 21, 2019

0.0.1 1. Crear una función con tres argumentos de salida y dos argumentos de entrada, donde
las entradas están dadas por:
A = [1, 1.1, 1.2, ..., 2] , B = [sin(1), sin(1.2), sin(1.4), ..., sin(3)]

0.0.2 Las salidas están dadas por:

K = A/B, L = A2 + B2 , M = ( AB)2

In [1]: import numpy as np #Libreria que contiene herramientas para trabajar con arreglos.

def function1(A,B):
K = A/B
L = A**2 + B**2
M = (A*B)**2
return(K,L,M)

A = np.arange(1.0,2.1,0.1) #Devuelve valores espaciados uniformemente

b = np.arange(1.0,3.2,0.2) #dentro de un intervalo dado.

B = np.sin(b) #Devuelve el seno trigonométrico, la entrada es el ángulo en radianes

K,L,M = function1(A,B) #Se llama la función

print("A =",A,"\n")
print("B =",B,"\n")
print("A/B = ",K,"\n")
print("A^2 + B^2 = ",L,"\n")
print("(A.B)^2 = ",M,"\n")

A = [1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2. ]

B = [0.84147098 0.93203909 0.98544973 0.9995736 0.97384763 0.90929743

0.8084964 0.67546318 0.51550137 0.33498815 0.14112001]

A/B = [ 1.18839511 1.18020802 1.21771813 1.30055455 1.43759656 1.64962526

1.97898221 2.51679151 3.49174629 5.67184242 14.17233479]

1
Aˆ2 + Bˆ2 = [1.70807342 2.07869686 2.41111117 2.68914739 2.90837921 3.07682181
3.21366643 3.34625051 3.50574166 3.72221706 4.01991486]

(A.B)ˆ2 = [0.70807342 1.0511232 1.39840009 1.68855909 1.85882325 1.86034907

1.67338607 1.31856397 0.86100299 0.40510359 0.07965943]

0.0.3 2. Cree una funcion que reciba como argumento una matriz 3x3 generada aleatoriamente.
La salida de dicha función deberá retornar lo siguiente:
a. La traspuesta de la matriz multiplicada por su inversa

b. La raíz cuadrada del determinante de la matriz.

c. La sumatoria de cada columna.

In [2]: def function2(Mat):

Trans = Mat.T #Calcula la traspuesta de la matriz
Inv = np.linalg.inv(Mat) #Calcula la inversa de la matriz
Producto = Trans*Inv # Traspuesta * Inversa

det = np.linalg.det(Mat) #Calcula el determinante de la matriz

Raiz_det = np.sqrt(np.abs(det)) #Calcula la raíz del determinante,
#si este es negativo toma el valor absoluto

fil,col=Mat.shape # Extrae el número de filas y el número

# de columnas de la matriz

Sum_columnas=[] #Variable donde se almanacerán los valores de la suma

#de cada una de las filas

for i in range(col):#Calcula la suma para cada una de las filas

s=0
for j in range(fil):
s = s + Mat[j][i]
Sum_columnas.append(s)

return(Producto,Raiz_det,Sum_columnas)

Mat = np.random.randn(3, 3) #Crear una matriz aleatoria de tamaño 3x3

prod,raizdet,sumcolum = function2(Mat) #Se llama la función

print("M = \n",Mat,"\n")
print("M(Traspuesta) * M(Inversa) = \n",prod,"\n")

2
 print("Raiz cuadrada del determinante de M = ",raizdet,"\n")
print("Sumatoria de cada columna de M = ",sumcolum,"\n")

M =
[[-0.06855431 -0.19211615 0.19045223]
[-0.22074909 0.48262691 -0.03188747]
[ 0.57225029 -0.47718619 0.20120564]]

M(Traspuesta) * M(Inversa) =
[[ 0.13001601 -0.26700187 1.13698585]
[ 0.11643032 1.37234906 -0.48877938]
[ 0.75355367 -0.10534719 0.35179353]]

Raiz cuadrada del determinante de M = 0.20779593004306993

Sumatoria de cada columna de M = [0.28294688840007, -0.18667543666227088, 0.3597704005661785]

0.0.4 3. Generar una figura de superficie y una figura de contorno en 3D, de la siguiente
ecuación:
z = e x cos(y) + ey sin( x )

Donde x, y son vectores que van desde -4 hasta 4 con un tamaño de paso de 0.1.

In [12]: import matplotlib.pyplot as plt # Librerias para graficar

import pylab as pl
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm

x = np.arange(-4.0,4.1,0.1)
y = x

[X,Y] = np.meshgrid(x,y) #Devuelve matrices de coordenadas de

#vectores de coordenadas.
Z = np.exp(X)*np.cos(Y) + np.exp(Y)*np.sin(X)

#Grafica de superficie en 3D
fig1 = plt.figure(figsize=(8,6))
ax1 = Axes3D(fig1)
ax1.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=pl.cm.hot)
#ax1.contourf(X, Y, Z, zdir='z', offset=-2, cmap=pl.cm.hot)
ax1.set_title('Grafica de superficie 3D',fontsize=20)
ax1.set_xlabel('x',fontsize=20)
ax1.set_ylabel('y',fontsize=20)
ax1.set_zlabel('z',fontsize=20)

3
 ax1.tick_params(labelsize=20)#Cambiar el tamaño de los numeros
#en cada uno de los ejes
plt.show()

In [4]: #Grafica de contorno en 3D

fig = plt.figure(figsize=(8,6))
ax = Axes3D(fig)
cset = ax.contour(X, Y, Z, cmap=pl.cm.hot)
ax.clabel(cset, fontsize=20, inline=1)
ax.set_title('Grafica de contorno 3D',fontsize=20)
ax.set_xlabel('x',fontsize=20)
ax.set_ylabel('y',fontsize=20)
ax.set_zlabel('z',fontsize=20)
ax.tick_params(labelsize=20)#Cambiar el tamaño de los numeros
#en cada uno de los ejes

4
0.0.5 4. Cree una función que reciba el periodo de una señal y retorne un tren de pulsos con
un ciclo de dureza del 50%. Grafique la función obtenida entre 0 y 10s. ¿El resultado es
como esperaba?
In [5]: def gra_sencuadra(periodo):
fs = 1000
time = 10 #Tiempo de simulacion
aux = time
duty = 0.5 # Ciclo de dureza
y3 = [] #crear una lista vacia

"""
Se genera una señal con periodos completos y solo se muestra
la porcion indicada por la variable tiempo, si el tiempo
divido el periodo no es exacto, se incrementa el tiempo hasta que sea así.
"""
while 1:
if ((aux%periodo)==0):
break
else:

5
 aux = aux+1

for i in range(0,aux,periodo):
y = np.linspace(1,1,(fs*duty*periodo)) #vector de 1's durante
# el ciclo de encendido

y2 = np.linspace(0,0,fs*(1-duty)*periodo) #vector de 0's durante

# el ciclo de encendido
y3 = np.concatenate((y3,y,y2))

y3 = (2*y3)-1 # Para obtener amplitudes entre -1 y 1

t = np.linspace(0,aux,len(y3)) # Se crea un nuevo vector temporal

# con el tamaño de 'y3'

plt.figure(figsize=(8,6))
plt.plot(t,y3)
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.ylabel('Amplitud',FontSize=20)
plt.title('Onda Periódica Cuadrada',FontSize=20)
plt.tick_params(labelsize=20) #Cambiar el tamaño de los numeros
#en cada uno de los ejes
plt.grid()
plt.show()

In [13]: import warnings #Libreria para que no aparezcan los warnings

periodo = 2 #definir el periodo de la señal arbitriaramente en 2
gra_sencuadra(periodo)
warnings.filterwarnings("ignore")

6
0.0.6 5. Repita lo anterior para una señal diente de sierra de pendiente m = 1.
In [7]: def gra_sendiensierra(periodo):
fs = 1000
time = 10 #Tiempo de simulacion
aux = time
duty = 0.5 # Ciclo de dureza
y3 = [] #crear una lista vacia

"""
Se genera una señal con periodos completos y solo se muestra
la porcion indicada por la variable tiempo, si el tiempo
divido el periodo no es exacto, se incrementa el tiempo hasta que sea así.
"""

while 1:
if ((aux%periodo)==0):
break
else:
aux = aux+1

7
 for i in range(0,aux,periodo):
y = np.linspace(0,1,(fs*periodo))
y3 = np.concatenate((y3,y))

y3 = (2*y3)-1 # Para obtener amplitudes entre -1 y 1

t = np.linspace(0,aux,len(y3)) # Se crea un nuevo vector temporal

# con el tamaño de 'y3'

plt.figure(figsize=(8,6))
plt.plot(t,y3)
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.ylabel('Amplitud',FontSize=20)
plt.title('Onda Periódica Diente de Sierra, m=1',FontSize=20)
plt.tick_params(labelsize=20)#Cambiar el tamaño de los numeros
#en cada uno de los ejes
plt.grid()
plt.show()

In [8]: periodo = 1 #definir el periodo de la señal arbitriaramente en 2

gra_sendiensierra(periodo)

8
0.0.7 6. Consulte como usar las funciones “square” y “sawtooth” de matlab. Compare los
resultados de los numerales 4 y 5 con el resultado de usar dichas funciones.
In [9]: from scipy import signal
time = 10 #Tiempo de simulacion
fs = 10000 #Cantidad de puntos entre el valor maximo y minimo

t=np.linspace(0,time,fs*time) # Crear un vector de 0 a 10s con

# 10000 puntos por seg
duty=0.5
periodo=1 # Periodo de la señal
m=1

plt.figure(figsize=(14,7))
plt.subplot(1,2,1)
plt.plot(t, signal.square((2*np.pi/periodo)*t,duty))
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.ylabel('Amplitud',FontSize=20)
plt.title("Funcion 'square' de Python",FontSize=20)
plt.tick_params(labelsize=20)
plt.grid()

plt.subplot(1,2,2)
plt.plot(t, signal.sawtooth((2*np.pi/periodo)*t,m))
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.title("Funcion 'sawtooth' de Python",FontSize=20)
plt.tick_params(labelsize=20)#Cambiar el tamaño de los numeros
#en cada uno de los ejes
plt.grid()

plt.show()

9
In [10]: time = 10 #Tiempo de simulacion
fs = 10000 #Cantidad de puntos entre el valor maximo y minimo

t=np.linspace(0,time,fs*time) # Crear un vector de 0 a 10s

# con 10000 puntos por seg

periodo=1 # Periodo de las señales

duty=0.5
m=1

aux=time
# crear de nuevo la señal cuadrada
y_cuadrada = [] #crear una lista vacia
while 1:
if ((aux%periodo)==0):
break
else:
aux = aux+1

for i in range(0,aux,periodo):
y = np.linspace(1,1,(fs*duty*periodo)) #vector de 1's
# durante el ciclo de encendido

y2 = np.linspace(0,0,fs*(1-duty)*periodo) #vector de 0's

# durante el ciclo de encendido

y_cuadrada = np.concatenate((y_cuadrada,y,y2))

10
y_cuadrada = (2*y_cuadrada)-1 # Para obtener amplitudes entre -1 y 1
t_cuad = np.linspace(0,aux,len(y_cuadrada)) # Se crea un nuevo vector
# temporal con el tamaño de 'y3'

# crear de nuevo la señal diente de cierra

y_diensier = [] #crear una lista vacia
while 1:
if ((aux%periodo)==0):
break
else:
aux = aux+1

for i in range(0,aux,periodo):
y = np.linspace(0,1,(fs*periodo))
y_diensier = np.concatenate((y_diensier,y))

y_diensier = (2*y_diensier)-1 # Para obtener amplitudes entre -1 y 1

t_die = np.linspace(0,aux,len(y_diensier)) # Se crea un nuevo vector

# temporal con el tamaño de 'y3'
#

plt.figure(figsize=(15,14))
plt.subplot(2,2,1)
plt.plot(t, signal.square((2*np.pi/periodo)*t,duty))
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.ylabel('Amplitud',FontSize=20)
plt.title("Funcion 'square' de Python",FontSize=20)
plt.tick_params(labelsize=20)
plt.grid()

plt.subplot(2,2,2)
plt.plot(t, signal.sawtooth((2*np.pi/periodo)*t,m))
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.title("Funcion 'sawtooth' de Python",FontSize=20)
plt.tick_params(labelsize=20)
plt.grid()

plt.subplot(2,2,3)
plt.plot(t_cuad, y_cuadrada)
plt.xlim([0, time])
plt.ylim([-1.2,1.2])

11
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.ylabel('Amplitud',FontSize=20)
plt.title("Funcion 'square' creada",FontSize=20)
plt.tick_params(labelsize=20)
plt.grid()

plt.subplot(2,2,4)
plt.plot(t_die, y_diensier)
plt.xlim([0, time])
plt.ylim([-1.2,1.2])
plt.xlabel('Tiempo (seg)',FontSize=20)
plt.title("Funcion 'sawtooth' creada",FontSize=20)
plt.tick_params(labelsize=20)
plt.grid()

plt.show()
warnings.filterwarnings("ignore")

12
0.0.8 7. Cree un vector aleatorio de “1s” y “0s” con 1000 elementos. Agregue un ruido con una
desviación estándar de 0.1. Grafique el histograma del resultado.
a. ¿Qué distribución de probabilidad siguen los datos?

b. Si el resultado obtenido representa la recepción información binaria ¿Cuál sería el umbral

de decisión que garantice una menor tasa de error de bit?

In [11]: Fsize=10000
simbolos = np.array([0, 1]) # simbolos son '1' o '0'
vector = np.random.choice(simbolos, size=Fsize) # crear vector aleatorio
# de '1's y '0's

ruido = 0.1*np.random.randn(Fsize) # crear un vector aleatorio uniformemente

# distribuido con desviacion estandar=0.1.

senal = vector + ruido

print("Desviacion estandar de los datos= ",np.std(ruido))
print("Media de los datos= ",np.mean(ruido))
# graficar el histograma
plt.figure(figsize=(10,6))
plt.hist(senal,label="Histogram",normed=True)
plt.title("Histograma",fontsize=20)
plt.xlabel('Datos',fontsize=20)
plt.ylabel('Probabilidad',fontsize=20)
plt.tick_params(labelsize=20)#Cambiar el tamaño de los numeros
#en cada uno de los ejes
plt.grid()

Desviacion estandar de los datos= 0.1007587788832517

Media de los datos= 0.0007321165575788156

13
a. Los datos siguen una distribución de probabilidad Gaussiana, con media ≈ 0 y desviacion
estandar ≈ 0.1.

b. Según el resultado, un umbral de 0.5 hará que se garantice la menor tasa de error de bit.

14