Introducción al curso

1

Vectores y Operaciones Básicas en Álgebra Lineal

Vectores

2

Vectores y escalares: fundamentos y aplicaciones prácticas

3

Vectores y escalares: Notación y ejemplos en Python

4

Modelo de Color RGB en Python: Crea y Manipula Vectores

5

Suma de Vectores: Propiedades y Ejemplos Prácticos

6

Suma de Vectores con NumPy en Python

7

Producto Escalar y Vector: Operaciones y Propiedades Básicas

8

Operaciones de Vectores con Python y NumPy

9

Producto Interno: Operaciones y Propiedades Matemáticas

10

Producto Interno y Polinomios en Python con NumPy

11

Análisis de Sentimientos en Tweets: Evaluación Práctica y Resultados

Funciones lineales

12

Funciones Lineales: Transformar Vectores en Escalares

13

Funciones Lineales: Producto Interno y Superposición

14

Teorema de Ángulos en Intersección de Rectas

15

Funciones Afines y Propiedades de Superposición

16

Aproximaciones de Taylor para funciones no lineales

17

Aproximación de Taylor Multivariable con Python

18

Regresión Lineal: Construye Modelos de Predicción con Datos Numéricos

Norma y distancia

19

Normas y Magnitudes de Vectores: Propiedades y Cálculos en Python

20

Cálculo de distancias entre vectores en Python

21

Priorizar visitas para arrendar usando distancias entre vectores

22

Desviación Estándar de Series de Tiempo con NumPy

23

Modelo de Riesgo-Retorno en Inversiones Accionarias

24

Ángulos y productos punto: cálculo y aplicación en vectores

Clustering

25

Clustering y sus Aplicaciones Prácticas

26

Clustering con Algoritmo K-means: Agrupación de Datos Geométrica

27

Algoritmo K-Means en Python: Implementación Paso a Paso

Cierre

28

Automatización de Tareas con Python

No tienes acceso a esta clase

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

Operaciones de Vectores con Python y NumPy

8/28
Recursos

¿Cómo usar NumPy para operaciones entre escalares y vectores en Python?

Las matemáticas y la programación pueden parecer mundos distintos, pero gracias a herramientas como NumPy, se unen para simplificar nuestras vidas. Trabajar con operaciones entre escalares y vectores en Python es una tarea sencilla y eficiente, especialmente cuando se compara con listas nativas del lenguaje. NumPy no solo facilita estas operaciones, sino que también abre un camino hacia la visualización y comprensión geométrica de los vectores.

¿Qué ventajas tienen los NumPyArrays sobre las listas en Python?

Los NumPyArrays ofrecen una serie de beneficios sobre las listas nativas de Python, una de las cuales es la eficiencia en el manejo de operaciones matemáticas:

  • Producto escalar-vector: Con NumPy, multiplicar un escalar por un vector se realiza directamente utilizando el operador *. Esto es algo que, con listas, podría causar confusión dado que se replicaría la lista concatenando su contenido.

    import numpy as np
    
    # Definimos un vector usando NumPy
    x = np.array([1, -1, 1])
    a = 3.1
    
    # Realizamos la multiplicación entre escalar y vector
    resultado = a * x
    print(resultado)  # Output: [ 3.1 -3.1  3.1 ]
    

¿Cómo se verifica la conmutatividad y otras propiedades en Python?

La conmutatividad y la distribución sobre suma de escalares y vectores son fundamentales en álgebra:

  • Conmutatividad del producto escalar: Multiplicar un escalar por un vector en cualquier orden debe dar el mismo resultado.

    # Comprobación de la conmutatividad
    resultado1 = a * x
    resultado2 = x * a
    print(resultado1 == resultado2)  # Output: True
    
  • Distribución sobre la suma de escalares: Se puede sumar dos escalares y luego multiplicar el resultado por un vector, o multiplicar cada uno de los escalares por el vector por separado y luego sumarlos.

    b = -a
    vector_cero = (b + a) * x
    print(vector_cero)  # Output: [0. 0. 0.]
    
    resultado_dist1 = a * x + b * x
    print(resultado_dist1 == vector_cero)  # Output: True
    

¿Qué significado geométrico tiene multiplicar escalares por vectores?

Los vectores tienen una interpretación geométrica que cobra vida en el plano cartesiano. Al multiplicar un escalar a un vector, observamos cambios en magnitud y sentido:

  • Multiplicación por un escalar positivo:
    • Si el escalar es mayor que uno, el vector se magnifica, es decir, aumenta su tamaño.
    • Si el escalar está entre cero y uno, el vector se encoge.
  • Multiplicación por un escalar negativo:
    • Cambia la dirección del vector.
    • Si es menor que menos uno, también magnifica el vector en la dirección opuesta.

El uso de herramientas como Geogebra facilita la visualización de estos conceptos, permitiendo representar vectores como flechas en un plano, donde su magnitud y dirección son obvias al ojo.

¿Qué ejercicios prácticos puedes realizar para dominar estos conceptos?

El mejor camino hacia el aprendizaje es la práctica:

  1. Vectores unitarios en R4: Escribe los vectores unitarios estándar en un espacio de cuatro dimensiones.
  2. Combinaciones lineales en R3: Encuentra tres combinaciones lineales distintas para expresar el vector ((1, 1, 1)).
  3. Combinaciones afines en R3: Crea combinaciones afines donde los coeficientes sumen a uno.
# Ejemplo básico de uso de np.linspace para encontrar soluciones a ecuaciones lineales
a = np.linspace(0, 5, 1000)
print(a)

Con estos ejercicios, ganarás comprensión y destreza en el manejo de operaciones algebraicas con NumPy, y la aplicación geométrica y práctica de vectores. ¡Continúa explorando y aprendiendo para dominar cada vez más estos poderosos conceptos!

Aportes 35

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

# 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```
vectores unitarios en R4 = v=\[1,1,1,1] sus vectores unitarios 1\[1,0,0,0] +1\[0,1,0,0] + 1\[0,0,1,0] + 1\[0,0,0,1] combinaciones lineales para el vector v=\[1,1,1] sus combinaciones 1\[1,0,0]+ 1\[0,1,0]+ 1\[0,0,1] otra combinacion es la que β0, β1 y β2 = 1, v=\[1,1,1] combinaciones = 1\[1,1,1] +1 \[0,0,0] + 1\[0,0,0] otra combinacion β = 1/2 \[ 2,0,0] + 3/4 \[0,4/3,0] + 1/3\[0,0,3] combinacion donde β0, β1 y β2 = 1/m, promedio de vectores v= \[1,1,1] α = \[0.3333, 0.3333, 0.3333] combinacion afin, donde β0+β+β2 = 1 para este caso β=\[0.3,0.5,0.2]
![](https://static.platzi.com/media/user_upload/image-8580eef9-8d10-41b8-9ea1-8b7a93a68be7.jpg)This is my solution for problem 3
![](https://static.platzi.com/media/user_upload/exercise1.3-ad1a2714-c600-4c8c-8945-fc1216af0363.jpg) ![](https://static.platzi.com/media/user_upload/exercise2.3-97b3c8ca-8405-4a2d-9f71-11e0f99899b5.jpg) ![](https://static.platzi.com/media/user_upload/exercise%203.3-e7d246b4-2afe-4b7b-a7d0-c6e6abb739e0.jpg)
# 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)
<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.])]