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 31

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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.]```

Programa para obtener un vector v que cumpla la combinaci贸n af铆n

import numpy as np


def unit_vector(n):
  '''
      Funci贸n para crear vectores unitarios en R^n
  '''
  vectors = np.empty((0,n), int)

  for i in range(n):
    array = np.zeros(n)
    array[i] = 1
    vectors = np.append(vectors, np.array([array], int), axis = 0)
  
  return vectors


def coef_affine_combination(n):
  '''
    Funci贸n para tener coeficientes que cumplen que
      b_1 + b_2 + ... + b_n = 1
  '''
  values = np.zeros(n)
  for i in range(n):
    values[i] = np.random.randint(100)
  
  total_sum = sum(values)
  for i in range(n):
    values[i] = values[i]/total_sum
  
  return values


def linear_combination(coef, vectors):
  '''
      Funcion para daos
      coef= (b_1, b_2 , ..., b_n) y vectors=(u_1, u_2 , ..., u_n)
      Se obtiene v como combinaci贸n lineal 
             v = b_1 * u_1 + b_2 * u_2 + ... + b_n * u_n
  '''
  combination = [np.array(i * j) for i, j in zip(coef, vectors)]
  return sum(combination)

# Para n=5
n=5
unit_vectors = unit_vector(n)
coef = coef_affine_combination(n)
v = linear_combination(coef, unit_vectors)

print(v) 

[0.32989691 0.00687285 0.06872852 0.32989691 0.26460481]

https://www.geogebra.org/calculator/m4hv9yyq

DE click en icono de play para ver como varia el vector

a * (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```

Problema 1.

import numpy as np

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

print(e1)
print(e2)
print(e3)
print(e4)
salida 
[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]

Ploblema 2


# Vectores en R鲁
v1 = np.array([1, 0, 0])
v2 = np.array([0, 1, 0])
v3 = np.array([0, 0, 1])

# Combinaci贸n lineal 1
cl1 = 1 * v1 + 1 * v2 + 1 * v3
print(cl1)  # [1 1 1]

# Combinaci贸n lineal 2
cl2 = 2 * np.array([0, 1, 1]) + (-1) * np.array([1, 0, 0])
print(cl2)  # [1 1 1]

# Combinaci贸n lineal 3
cl3 = 3 * np.array([0, 1, 0]) + (-2) * np.array([0, 0, 1]) + 1 * np.array([1, 1, 1])
print(cl3)  # [1 1 1]

Ploblema 3

# Funci贸n para encontrar combinaciones afines
def encontrar_combinaciones_afines():
    combinaciones = []
    for beta0 in np.linspace(0, 1, 10):
        for beta1 in np.linspace(0, 1, 10):
            for beta2 in np.linspace(0, 1, 10):
                if beta0 != beta1 and beta0 != beta2 and beta1 != beta2 and beta0 + beta1 + beta2 == 1:
                    combinaciones.append([beta0, beta1, beta2])
    
    return combinaciones

# Encontrar combinaciones afines
comb_afines = encontrar_combinaciones_afines()

# Imprimir las primeras tres combinaciones encontradas
for i in range(3):
    print(comb_afines[i])

Reto cumplido
Problema 1, Este ejercicio lo realize manual

R1 = np.array([1,0,0,0])
R2 = np.array([0,1,0,0])
R3 = np.array([0,0,1,0])
R4 = np.array([0,0,0,1])

print("R1 es: ", R1)
print("R2 es: ", R2)
print("R3 es: ", R3)
print("R4 es: ", R4)

Problema 2, Este ejercicio a帽adi los vectores de forma manual

R1 = np.array([1,0,0]) + np.array([0,1,0]) + np.array([0,0,1])
R2 = 5 * (np.array([0.2,0,0])) + 5 * (np.array([0,0.2,0])) + 5 * (np.array([0,0,0.2]))
R3 = np.array([0.2,0.1,0.2]) + np.array([0.2,0.5,0.3]) + np.array([0.6,0.4,0.5])

print("Este es R1: ", R1)
print("Este es R2: ", R2)
print("Este es R3: ", R3)

Problema 3, Este ejercicio intente ingresar los vectores desde el usuario pero no me salio y tuve que a帽adirlos manual pero ando trabajando en eso, pero cumple con las especificaciones que los vectores sean diferentes

B_0 = 0.2,0.1,0.2
B_1 = 0.2,0.5,0.3
B_2 = 0.2,0.1,0.2

# 0.6,0.4,0.5

if (B_0 != B_1) and (B_0 != B_2) and (B_1 != B_2):
    R3 = np.array([B_0]) + np.array([B_1]) + np.array([B_2])
    print("B_0 + B_1 + B_2 = ", R3)
else:
    print("Vuelve a ingresar los valores, recuerda que tienes que tener vectores diferentes")

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.])]