Operaciones con Escalares y Vectores en Python usando NumPy

Clase 9 de 29 • Curso de Introducción al Álgebra Lineal: Vectores

Resumen

¿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:

Vectores unitarios en R4: Escribe los vectores unitarios estándar en un espacio de cuatro dimensiones.
Combinaciones lineales en R3: Encuentra tres combinaciones lineales distintas para expresar el vector ((1, 1, 1)).
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!

John Alexander Ortiz Ramirez

student•

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

Ulises Rayon

teacher•

Qué elegancia la de Francia :ok_hand:

Camilo Velasquez

student•

Qué buena respuesta, me ayuda mucho a ir entendiendo el código. Gracias :)

John Alexander Ortiz Ramirez

student•

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()

Ulises Rayon

teacher•

La verdad es que sabía que alguien aportaría una forma de dibujar vectores ¡Muchas gracias por tu aporte!

Oscar Unzueta Salazar

student•

A mi me da error:

v1 = np.array([1,1]) v2 = np.array([1,2]) vectorgraph(v1,v2,'red') ValueError: Invalid RGBA argument: 'e' 328 "'%s' is neither a valid single color nor a color sequence " 329 "consisting of single character color specifiers such as " --> 330 "'rgb'. Note also that the latter is deprecated." % c) 331 else: 332 cbook.warn_deprecated("3.2", message="Using a string of single "

ValueError: 'e' is neither a valid single color nor a color sequence consisting of single character color specifiers such as 'rgb'. Note also that the latter is deprecated.

Angel Estrada

student•

Tomas Filippo

student•

Un poco desprolijo, disculpen.

Jainelker Jesus Yepez

student•

Gracias. jejeje con tu ejemplo he entendido perfectamente como hacer estos ejercicios. jajajaja soy de los que hace el trabajo como tú , a mano primero

Miguel Angel Reyes Moreno

student•

Con marcador y pizarrón: Reto 1:

Reto 2:

Reto 3:

Roberth Mafla

student•

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.

Jorge Cruz Perez

student•

Hermes A. J. Cabrera F.

student•

Hola platzitueros, acá los ejercicios planteados. Saludos

Sergio Alejandro Martínez

student•

Axel Díaz

student•

Asi lo intente resolver yo

Carlos Felipe Saldarriaga Bejarano

student•

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

Jorge Cruz Perez

student•

En el problema dos se esta trabajando en R3 no R4, saludos :), y cuando los sumas te dan [3,3,3,3 y no [1,1,1,1] si fuer en R4, saludos :)

Alejandro López

student•

# 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}')

Edwin Arteaga

student•

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

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

a * (1,1)

Daniel Camilo Velez Malagon

student•

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.

Cristian Gerardo Hernandez Barrios

student•

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

Clemente Cosetl Pérez

student•

Con este codigo se generan soluciones para el problema 2

import numpy as np
v_objetivo = np.array([1, 1, 1])#Vector Objetivo
matriz = np.array([np.array([np.random.randint(0,10) for i in range(3)])for i in range(3)])
print(matriz)


coeficientes = np.linalg.solve(matriz, v_objetivo) #Esta funcion de numpy resulve una matriz o sistema de ecuaciones
print("Coeficientes de la combinación lineal:")
print(coeficientes)

#Verificamos que la combinación lineal da el resultado correcto
resultado = matriz @ coeficientes
print("Resultado de la combinación lineal:")
print(resultado)

Rodrigo Ramirez Chaguala

student•

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]

Arley Santiago

student•

This is my solution for problem 3

Jeinfferson Bernal G

student•

Alejandro López

student•

# 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))

Operaciones con Escalares y Vectores en Python usando NumPy

Introducción al curso

Este curso tiene una versión actualizada

Vectores en Álgebra Lineal: Definición y Operaciones Básicas

Vectores

Vectores y Escalares: Conceptos y Operaciones Básicas

Convenciones y Notación en Vectores y Escalares

Modelo RGB y su implementación en Python

Adición de Vectores: Conceptos y Propiedades Básicas

Suma de Vectores en Python con NumPy

Producto Escalar-Vectores: Conceptos y Propiedades Básicas