Producto escalar-vector en Python

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:

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]

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 cd: [1 1 1 1]
Tercera combinación de e*f: [1. 1. 1. 1.]```

# 1.- Escribe TODOS los vectores unitarios estándar de R4.
# a) Usando unicamente python

def unit_vectors(n):
    w = []
    i = 0
    for j in range(n):
        v = [1 if i == j else 0 for j in range(n)]
        w.append(v)
        i+=1
        
    return w    



# b) usando la potencia de numpy

import numpy as np


def unit_vectors_numpy(n):
    w = np.eye(n)
    
    return w



# 2.- Tres combinaciones lineales para expresar [1,1,1]

def scalar_coeff(v):
    e0 = v[0][0]
    e1 = v[1][1]
    e2 = v[2][2]

    return e0, e1, e2



def average_scalar_coeff(v):
    e0 = 1/v[0][0]
    e1 = 1/v[1][1]
    e2 = 1/v[2][2]
    
    return e0, e1, e2



def affine_scalar_coeff():
    v = [np.random.randint(1,100) for i in range(3)]
    v = [i/sum(v) for i in v]
    e0 = v[0]
    e1 = v[1]
    e2 = v[2]
        
    return e0, e1, e2



def linear_combination(v):
    
    w = e0*v[0] + e1*v[1] + e2*v[2]

    return w



if __name__=='__main__':

    # PROBLEMA 1
    # Escribe TODOS los vectores unitarios estándar de R4

    w = unit_vectors(4)
    print('vectores unitarios en R4 ', w)
    print()

    w = unit_vectors_numpy(4)
    print(w)
    print()
    
    # PROBLEMA 2
    # Tres combinaciones lineales para expresar [1,1,1]
    
    # 1.- Con los coeficientes de los vectores unitarios estándar:
    # β0=β1=⋯=βm−1=1

    v = np.diag([1,1,1])
    e0, e1, e2 = scalar_coeff(v)
    w = linear_combination(v)
    print(f'{e0}*{v[0]} + {e1}*{v[1]} + {e2}*{v[2]} = {w}')
    print()

    # 2.- Con la llamada combinación lineal promedio de vectores
    # β0=β1=⋯=βm−1=1/m

    v = np.diag([3,3,3])
    e0, e1, e2 = average_scalar_coeff(v)
    w = linear_combination(v)
    print(f'{e0}*{v[0]} + {e1}*{v[1]} + {e2}*{v[2]} = {w}')
    print()
    
    # 3.- Con la llamada combinación lineal promedio pesado
    # β0+β1+⋯+βm−1=1

    e0, e1, e2 = affine_scalar_coeff()
    v = np.diag([1/e0,1/e1,1/e2])
    w = linear_combination(v)
    print(f'{e0}*{v[0]} + {e1}*{v[1]} + {e2}*{v[2]} = {w}')

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 3
# Tres combinaciones afines en Rn

import numpy as np

def weight_vector(weight):
    #
    affine_coeff = [i/sum(weight) for i in weight]

    return affine_coeff


def linear_combination(affine_coeff, data):
    
    resultant_nvector = [sum(i*affine_coeff) for i in data]
        
    return (resultant_nvector)



if __name__=='__main__':
    data_0 = [6,7,5,7,8,6]
    data = np.diag(data_0)
    weight = [1,1,1,1,1,5]
    affine_coeff = weight_vector(weight)
    resultant_nvector = linear_combination(affine_coeff, data)

    print('Este es el vector resultante de la combinación lineal\nentre los coeficientes afines,(en funcion del vector de pesos)\ny la matriz de datos (data)')
    print(resultant_nvector)
    print('Cuendo de suman estos componentes se obtiene el promedio ponderado')
    print(sum(resultant_nvector))
    print('Que no es otra cosa que el producto punto np.dot(affine_coeff, data_0),\nel vector original de datos, sin ponerlo en la diagonal de una matriz')
    print(np.dot(affine_coeff, data_0))
    

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)

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