No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Producto escalar-vector en Python

8/28
Recursos

Aportes 27

Preguntas 1

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Solucion al reto
Problema 1

def vectores_unitarios(n):
    vector_u = []
    for i in range(n):
        array = np.zeros(n)
        array[i] = 1
        vector_u.append(array)
    return vector_u

vectores_unitarios(4)

[array([1., 0., 0., 0.]),
array([0., 1., 0., 0.]),
array([0., 0., 1., 0.]),
array([0., 0., 0., 1.])]

Problema 2

def combinacion_lineal(escalares, vectores):
    combinaciones =  [np.array(i * j) for i, j in zip(escalares, vectores)]
    return sum(combinaciones)

print('Combinacion lineal 1 = ',combinacion_lineal([1, 1, 1], vectores_unitarios(3)))

print('Combinacion lineal 2 = ',combinacion_lineal([-1, 1, 1], np.array([[2, 2, 2], [2, 2, 2], [1, 1, 1]])))

print('Combinacion lineal 3 = ',combinacion_lineal([-1, 1, 1/3], np.array([[3, 3, 3], [3, 3, 3], [3, 3, 3]])))

Combinacion lineal 1 = [1. 1. 1.]
Combinacion lineal 2 = [1 1 1]
Combinacion lineal 3 = [1. 1. 1.]

Problema 3

def sum1_coef(n_coef, size):
    data = []
    for i in range(size):
        coef = np.random.rand(2)
        coef = np.linspace(min(coef), max(coef), n_coef-1)
        coef = np.append(coef, 1 - sum(coef))
        data.append(coef)
    return data

sum1_coef(3, 3)

[array([0.14405631, 0.38670477, 0.46923892]),
array([ 0.04266722, 0.96290285, -0.00557008]),
array([ 0.73777766, 0.99145253, -0.72923019])]

Esta es una manera de garficarlo en python y asi comprenderlos cambios que produce un escalar en un vector.

import matplotlib.pyplot as plt

def vectorgraph(vector, vector2, color=['red', 'blue']):
    plt.figure(dpi=200, facecolor='white')
    plt.quiver(vector[0], vector[1], angles='xy', scale_units='xy', scale=1, color=color[0])
    plt.quiver(vector2[0], vector2[1], angles='xy', scale_units='xy', scale=1, color=color[1], alpha=0.5)
        
    xpos = max(0.5, vector[0]+1,  vector2[0]+1)
    xneg = min(-0.5, vector[0]-1, vector2[0]-1)
    ypos = max(0.5, vector[1]+1, vector2[1]+1)
    yneg = min(-0.5, vector[1]-1,  vector2[1]-1)
    plt.axvline(0, color='gray')
    plt.axhline(0, color='gray')
    plt.xlim([xneg, xpos])
    plt.ylim([yneg, ypos])
    plt.show()

Un poco desprolijo, disculpen.

Con marcador y pizarrón:
Reto 1:

Reto 2:

Reto 3:

Soy yo no más o a alguien más le gusta esa manera de explicar detalle por detalle, que buen profesor es Ulises Rayón.

Hola platzitueros, acá los ejercicios planteados.
Saludos

Asi lo intente resolver yo

Esta es la forma que entendí se debían resolver los problemas 1 y 2, me gustaría recibir sus comentarios para saber si de manera similar realizar el tercero.

#Problema 1
primero = np.array([1,0,0,0])
segundo = np.array([0,1,0,0])
tercero = np.array([0,0,1,0])
cuarto = np.array([0,0,0,1])

r_4 = primero + segundo + tercero + cuarto
print("resultado ℝ4: ",r_4)```

Output Problema 1:

resultado ℝ4: [1 1 1 1]```

#Problema 2

#primer combinación
a= np.array([2,2,2,2])
b= 0.5

#segunda combinación
c= np.array([-1,-1,-1,-1])
d= -1

#segunda combinación
e= np.array([-10,-10,-10,-10])
f= -0.1


print("Primera combinación de a*b:",a*b,
     "\nSegunda combinación de c*d:",c*d,
     "\nTercera combinación de e*f:",e*f)```

Output Problema 2:



Primera combinación de ab: [1. 1. 1. 1.]
Segunda combinación de c
d: [1 1 1 1]
Tercera combinación de e*f: [1. 1. 1. 1.]```

Importante: El vector cambiara no por operarlo por 1 o menos a 1, si no por un real mayor o menor en comparación al valor real del vector. Esto lo pueden comprobar jugando con Geogebra y Numpy.

Otra excelente clase, me gusta mucho como se puede representar en python el producto de un escalar y vector, la forma en la que el profesor enseñó el plano cartesiano y la graficación de los vectores… fue asombroso.

import numpy as np # Importamos numpy

vector = np.array([1,-1,1]) # Declaramos el vector como numpy array
escalar = 3.1 # Declaramos el escalar

print('El resultado del producto vector y escalar es ', vector*escalar)

### EJERCICIO ###
v = np.array([1,1])
a = -1
b = 2
c = 0.1```

A mano:

Asentado a código:

Aca surge la utilidad de numpy.
Los vectores unitarios de un espacio vectorial suelen agruparse en una matriz llamada matriz identidad. Primero importamos la libreria y luego llamamos la función

import numpy as np
np.identity(4)

[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]

Para el segundo reto, cree una función que recibe como parametros :

  • un vector de r3 cualquiera
  • un numero que servira tanto de minimo como maximo para hallar diferentes combinaciones lineales aleatorias.
def comb_lineales(vector,limit):
    vectorsito=np.array([[0,0,0],[0,0,0],[0,0,0]])
    for i in range(len(vector)):
        combinaciones=[]
        
        while vectorsito[0,i]+vectorsito[1,i]+vectorsito[2,i]!=vector[i]:
            a=random.randint(-limit, limit)
            b=random.randint(-limit, limit)
            c=random.randint(-limit, limit)            
            c=a+b+c
            if c==vector[i]:               
                vectorsito[0,i]=a
                vectorsito[1,i]=b
                vectorsito[2,i]=c       
        
    print(f"el resultado final es : {vectorsito}")

Hay que pulirla un poco todavia pero para fines practicos sirve. por ejemplo no se deja explicitos los coeficientes, aunque seria muy facil inventarlos y dividir por ellos.

comb_lineales([1,1,1],10)

el resultado final es :
[[-6 -8 7]
[ 6 8 -7]
[ 1 1 1]]

Problema 1:

a = np.identity(4)

¿Están bien resueltos profe? Gracias

Mi respuesta al ejercicio♾️♾️



Esto es lo que realice para el problema 1

e0 = np.array([1,0,0,0])
e1 = np.array([0,1,0,0])
e2 = np.array([0,0,1,0])
e3 = np.array([0,0,0,1])

Esto es lo que realice para el problema 2

# Combinacion1
uno_1 = (1/2)*np.array([2,0,0]) + 4*np.array([0,1/4,2]) - 7*np.array([0,0,1])
uno_1
# Combinacion2
uno_2 = (1/3)*np.array([0,3,0]) + 2*np.array([1/4,0,2]) - 1*np.array([-1/2,0,3])
uno_2
# Combinacion3
uno_3 = (2/5)*np.array([0,0,5]) - 1*np.array([-1,2,1]) + 6*np.array([0,1/2,0])
uno_3

Y esta es la función que realice para encontrar las combinaciones afines

def diferentes(coeficientes):
    values = []
    repeat = []
    for i in coeficientes:
        if i not in values:
            values.append(i)
        else:
            if i not in repeat:
                repeat.append(i)
    return bool(repeat)
def coeficientes_afin(n):
    coeficientes = []
    for i in range(n - 1):
        coeficientes.append(random.randint(-10,10))
    coeficientes.append(1 - sum(coeficientes))
    while diferentes(coeficientes):
        coeficientes = []
        for i in range(n - 1):
            coeficientes.append(random.randint(-10,10))
        coeficientes.append(1 - sum(coeficientes))
    return coeficientes

Ejercicio 2

vector_unos = 4*np.array([13, 7/4, 1]) + (-15)*np.array([3, 4, 5]) + (-9)*np.array([6/9, -6, -8])

Solucion al problema 3

coef = np.random.rand(2)#calculamos 2 numeros en el intervalo 0,1
coef = np.append(coef, 1 - sum(coef))# calculamos la diferencia a 1 y lo agregamos al array
print('suma: ',sum(coef))#verificamos que la suma de 1
coef#mostramos los coeficientes

Reto 1:

eu = np.array([1,0,0,0])
ev = np.array([0,1,0,0])
ew = np.array([0,0,1,0])
ex = np.array([0,0,0,1])

Reto2:

def combinacion_lineal(coeficientes,vectores):
  vector_dict = {}
  for k,(i,j) in enumerate(zip(coeficientes,vectores)):
    vector_dict[k] = i*j
  suma = sum(vector_dict.values())  
  return suma, vector_dict
coefs = np.array([1,1,1])
vects = np.array([[1,0,0],[0,1,0],[0,0,1]])
suma, vect_dict = combinacion_lineal(coefs,vects)

[1, 1, 1], {0: array([1, 0, 0]), 1: array([0, 1, 0]), 2: array([0, 0, 1])}

coefs = np.array([0.1,0.1,0.1])
vects = np.array([[10,0,0],[0,10,0],[0,0,10]])
suma, vect_dict = combinacion_lineal(coefs,vects)

[1., 1., 1.], {0: array([1., 0., 0.]), 1: array([0., 1., 0.]), 2: array([0., 0., 1.])}

coefs = np.array([2,4,6])
vects = np.array([[1,1,1],[-1,-1,-1],[1/2,1/2,1/2]])
suma, vect_dict = combinacion_lineal(coefs,vects)
suma, vect_dict

[1., 1., 1.], {0: array([2., 2., 2.]), 1: array([-4., -4., -4.]), 2: array([3., 3., 3.])}
Reto 3:

coefs = np.array([0.3,0.2,0.5])
vects = np.array([[1,0,0],[0,1,0],[0,0,1]])
suma, vect_dict = combinacion_lineal(coefs,vects)

[0.3, 0.2, 0.5], {0: array([0.3, 0. , 0. ]), 1: array([0. , 0.2, 0. ]), 2: array([0. , 0. , 0.5])}

coefs = np.array([0.3,0.2,0.5])
vects = np.array([[2,3,4],[5,6,7],[8,9,10]])
suma, vect_dict = combinacion_lineal(coefs,vects)

[5.6, 6.6, 7.6], {0: array([0.6, 0.9, 1.2]), 1: array([1. , 1.2, 1.4]), 2: array([4. , 4.5, 5. ])}

coefs = np.array([0.4,0.7,-0.1])
vects = np.array([[2,0,8],[3,-1,5],[4,1,2]])
suma, vect_dict = combinacion_lineal(coefs,vects)

[ 2.5, -0.8, 6.5], {0: array([0.8, 0. , 3.2]), 1: array([ 2.1, -0.7, 3.5]), 2: array([-0.4, -0.1, -0.2])}

Problema 1

def vect_unitarios(n):
  e = []
  for k in range(n):
    u = np.zeros(n,dtype=int)
    u[k] = 1
    e.append(u)
  return e

vect_unitarios(4)
<h3>[array([1, 0, 0, 0]),
array([0, 1, 0, 0]),
array([0, 0, 1, 0]),
array([0, 0, 0, 1])]</h3>

Problema 2

e3 = vect_unitarios(3)
def comb_lin(b,e):
  vect = np.zeros(len(b))
  for i in range(len(b)):
    x = b[i] * e[i]
    vect = vect + x
  
  print(vect)

b1 = [1,1,1]
b2 = [np.pi,-np.pi,1]
b3 = [3,6,2]

comb_lin(b1,e3)
comb_lin(b2, np.array([[1, 0,1/np.pi],[1, -1/np.pi,0],[1,0,0]]))
comb_lin(b3, np.array([[3,2,1],[-1,-1,-1],[-1,1/2,2]]))

[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]


Problema 3

def f(beta_0,beta_1):
  return 1-beta_0-beta_1

print('b0 = 2, b1 = 5, b2=', f(2,5))
print('b0 = pi, b1 = -pi, b2=', f(np.pi,-np.pi))
print('b0 = 402002, b1 = 78454, b2=', f(402002,78454))

b0 = 2, b1 = 5, b2= -6
b0 = pi, b1 = -pi, b2= 1.0
b0 = 402002, b1 = 78454, b2= -480455

Aquí mis soluciones. Lo bonito de las matemáticas es que hay muchas formas de expresar las respuestas correctas 😄

Problema 1

a = np.array([1,0,0,0])
b = np.array([0,1,0,0])
c = np.array([0,0,1,0])
d = np.array([0,0,0,1])

Problema 2

# Combinacion 1
v1 = np.array([1,0,0])
v2 = np.array([0,1,0])
v3 = np.array([0,0,1])
print(v1 +  v2 + v3)

# Combinacion 2
u1 = np.array([3,0,0])
u2 = np.array([-2,2,0])
u3 = np.array([0,-1,1])
print(u1 + u2 + u3)

# Combinacion 3
n1 = np.array([3,4,0])
n2 = np.array([-1,-2,0])
n3 = np.array([-1,-1,1])
print(n1 + n2 + n3)

Problema 3

import random
def generar_combinacion_afin(n):
    b0 = random.randint(1,n)
    b1 = random.randint(1, n)
    if b0 != b1:
        pivot = (b1 + b0)
    else:
        b1 = b1 + 1
        pivot = (b1 + b0)
    b2 = -pivot + 1
    # print(b0, b1, b2)
    # print(b0 + b1 + b2)
    return b0, b1, b2
combinaciones = []
while len(combinaciones) < 3:
    a, b, c = generar_combinacion_afin(100)
    combinaciones.append((a,b,c))
i = np.array([1,0,0])
j = np.array([0,1,0])
k = np.array([0,0,1])
print("Coeficientes de combinaciones:", combinaciones)
for comb in combinaciones:
    print(i*comb[0] + j*comb[1] + k*comb[2])

Así se ve mas claro lo que sucede.

import numpy as np

def vectores_unitarios(n):
    vector_u = []
    for i in range(n):
        array = np.zeros(n)
        print(array)
        array[i] = 1
        print(array[i])
        vector_u.append(array)
        print(vector_u)
    return vector_u


if __name__=='__main__':
    print('- PROBLEMA N°1 -')
    n = int(input('ingrese un valor: '))
    print(vectores_unitarios(n))
  
RESULTADO:
λ py vectores.py
- PROBLEMA N°1 -
ingrese un valor: 4
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.]), array([0., 0., 0., 1.])]
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.]), array([0., 0., 0., 1.])]

Así se ve mas claro lo que sucede.

import numpy as np

def vectores_unitarios(n):
    vector_u = []
    for i in range(n):
        array = np.zeros(n)
        print(array)
        array[i] = 1
        print(array[i])
        vector_u.append(array)
        print(vector_u)
    return vector_u


if __name__=='__main__':
    print('- PROBLEMA N°1 -')
    n = int(input('ingrese un valor: '))
    print(vectores_unitarios(n))
  
RESULTADO:
λ py vectores.py
- PROBLEMA N°1 -
ingrese un valor: 4
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.])]
[0. 0. 0. 0.]
1.0
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.]), array([0., 0., 0., 1.])]
[array([1., 0., 0., 0.]), array([0., 1., 0., 0.]), array([0., 0., 1., 0.]), array([0., 0., 0., 1.])]