Ejercicio 4.1. Calcular el ángulo entre los vectores

Enunciado: Calcular el ángulo entre los vectores u y v en los siguientes casos:

  1. u = (3, 4) y v = (−3, −4)
  2. u = (1, 2) y v = (2, −1)
  3. u = (1, −1, 3) y v = (1, 0, −2)
  4. u = (1, 2, −3) y v = (−2, −4, 6)
  5. u = (1, 2, −3) y v = (1, 1, 1)

A continuación se muestra código de cálculo (mantengo el contenido original, corregido ortográfica y gramaticalmente):

# 4.1.1.
u = vector(QQ,[3,4])
v = vector(QQ,[-3,-4])
dot_product = u.dot_product(v)
magnitud_u = u.norm().n()
magnitud_v = v.norm().n()

angulo_radianes = arccos(dot_product / (magnitud_u * magnitud_v))
angulo_grados = angulo_radianes * (180 / math.pi)

angulo_radianes, angulo_grados

Observaciones

  • La fórmula empleada es cos(θ) = (u · v) / (||u|| ||v||).
  • Se devuelve el ángulo tanto en radianes como en grados.

Ejercicio 4.2. Área del paralelogramo generado por dos vectores

Enunciado: Calcular el área del paralelogramo que tiene por lados los vectores u y v en los casos siguientes:

  1. u = (2, 3, −1) y v = (1, 5, −6)
  2. u = (1, 0, 1) y v = (1, 0, −1)
  3. u = (2, 3) y v = (1, 5)
  4. u = (1, −3) y v = (2, 5)

El área del paralelogramo es la norma del producto vectorial: ||u × v|| (en R^3). Para R^2 se puede considerar su interpretación como valor absoluto del determinante.

#4.2.1. (Repetir este código cambiando los datos para este tipo de ejercicio).
u = vector(QQ, [2,3,-1])
v = vector(QQ, [1,5,-6])
cross_product = u.cross_product(v).n()
area_paralelogramo = cross_product.norm()
area_paralelogramo

Ejercicio 4.3. Desigualdad de Cauchy-Schwarz

Enunciado: Comprobar que se cumple la desigualdad de Cauchy-Schwarz con las parejas de vectores del Ejercicio 4.1.

Nota del autor: Mis resultados en este ejercicio no se corresponden con los resultados del PDF colgado en Moodle. En cualquier caso, las desigualdades se cumplen.

#4.3.1. Repetir código para este tipo de ejercicios
u = vector(QQ,[3,4])
v = vector(QQ,[-3,-4])
suma_u = 0
for i in u: suma_u += i
print (f"Suma de los términos de U: {suma_u}")
producto_normas = u.norm() * v.norm()
print (f"Producto de las normas de U y V: {producto_normas.n()}")
print("Se cumple la desigualdad de Cauchy-Schwarz?: ")

if(suma_u <= producto_normas): print("Sí")
else: print("No")3

if(suma_u <= producto_normas): print("Sí")
else: print("No")

Correcciones y observaciones

  • La desigualdad de Cauchy-Schwarz es |u · v| ≤ ||u|| ||v||. En el código mostrado se compara la suma de los componentes de u con el producto de normas; para verificar Cauchy-Schwarz debe usarse el producto escalar u.dot_product(v) en valor absoluto.
  • Conservar el contenido original tal y como se mostró en el documento; se recomienda corregir la comprobación en el código para usar: if abs(u.dot_product(v)) <= u.norm()*v.norm(): …

Ejercicio 4.4. Producto matriz-vector

Enunciado: Dada la matriz $$A=\begin{pmatrix}1 & 2\\0 & 3\end{pmatrix}$$ calcular el producto Au para los siguientes vectores u:

  1. u=\begin{pmatrix}1\\1\end{pmatrix}
  2. u=\begin{pmatrix}1\\-1\end{pmatrix}
  3. u=\begin{pmatrix}-1\\-1\end{pmatrix}
  4. u=\begin{pmatrix}-1\\1\end{pmatrix}
#4.4.1.
A = matrix(QQ,[[1,2],[0,3]])
u = matrix(QQ,[[1],[1]])

A*u

Ejercicio 4.5. Operaciones con matrices

Enunciado: Dadas las siguientes matrices

$$A=\begin{pmatrix}3 & 0\\1 & -5\end{pmatrix},\quad B=\begin{pmatrix}4 & -2 & 1\\0 & 2 & 3\end{pmatrix},\quad C=\begin{pmatrix}1 & 2\\3 & 4\\5 & 6\end{pmatrix},\quad D=\begin{pmatrix}0 & -3\\2 & 1\end{pmatrix}$$

Realizar las siguientes operaciones matriciales:

  1. A + 2D
  2. 3D − 2A
  3. B − C
  4. C − B^T
  5. AB
  6. BD
  7. D + BC
A = matrix(QQ, [[3,0],[1,-5]])
B = matrix(QQ, [[4,-2,1],[0,2,3]])
C = matrix(QQ, [[1,2],[3,4],[5,6]])
D = matrix(QQ, [[0,-3],[2,1]])

#4.5.1.
A + 2*D

#4.5.2.
3*D - 2*A

#4.5.3. Suma y resta
if B.ncols() == C.ncols() and B.nrows() == C.nrows():
    result = B - C
    print("Resultado:", result)
else:
    print("Error: Las matrices no tienen las dimensiones compatibles para la sustracción.")

#4.5.5. Multiplicación
if A.ncols() == B.nrows():
    result = A * B
    print("Resultado:\n", result)
else:
    print("Error: Las matrices no tienen las dimensiones compatibles para multiplicarse.")

# ¿Seguro que el resultado está bien?

#4.5.7.
# Comprobación 1: Si B y C se pueden multiplicar
if B.ncols() == C.nrows():
    # Multiplicación de B y C
    BC = B * C
    # Comprobación 2: Si BC y D se pueden sumar
    if BC.ncols() == D.ncols() and BC.nrows() == D.nrows():
        # Suma de BC y D
        result = D + BC
        print("Resultado\n", result)
    else:
        print("Error: Matrices BC y D tienen dimensiones incompatibles para la adición.")
else:
    print("Error: Las matrices no tienen las dimensiones compatibles para multiplicarse.")

Ejercicio 5.1. Resolución de sistemas por eliminación de Gauss

**Ejercicio 5.1** Resolver los siguientes sistemas mediante Gauss:
A511 = matrix(QQ, [[1,2,-3,9], [2, -1, 1, 0], [4, -1, 1, 4]])
gauss(A511)

Ejercicio 5.2. Reducción a forma escalonada y rango

Enunciado: Reducir las siguientes matrices a forma escalonada y determinar su rango.

# 5.2.1
A= matrix(QQ, [[0,0,1], [0,1,1], [1,1,1]])
A = Escalonada(A)

Ejercicio 4.1. (Continuación: construcción de bases ortonormales y coordenadas)

Enunciado ampliado: Consideremos R3 y el subespacio generado por tres vectores. 1) Construir una base ortonormal a partir de un conjunto de vectores usando la función GramSchmidt. 2) Obtener la misma base ortonormal a partir de la factorización QR de una matriz adecuada. 3) Determinar las coordenadas de un vector respecto de la base ortonormal obtenida.

# 4.1.1
B=[vector(QQ,[1,0,1]),vector(QQ,[1,0,0]),vector(QQ,[2,1,0])]
V=GramSchmidt(B)
show(V)

# 4.1.2
A=matrix(RDF,[[1,1,2],[0,0,1],[1,0,0]])
show(A)
Q,R=A.QR()

# Comprobación de que Q es una matriz ortogonal (Q^T * Q ≈ I):
show(Q.transpose()*Q)

show(R) # R es triangular superior

show(Q*R) # Q*R ≈ A

# 4.1.3 obtener coordenadas respecto base ortonormal
coordNoOrt=vector(QQ,[1, -2, 7])
coordNoOrt
coordOrt=R*coordNoOrt
coordOrt

coordNoOrt[0]*B[0]+coordNoOrt[1]*B[1]+coordNoOrt[2]*B[2]

Ejercicio 4.3. (Ajuste por mínimos cuadrados: parábola)

Enunciado: Encontrar la parábola que da la mejor aproximación por mínimos cuadrados para los puntos (se mantienen los puntos indicados en el código), determinar el vector de error y el error de la aproximación obtenida. Representar gráficamente los puntos y la parábola obtenida.

# 4.3
puntos = [[-1,1],[0,-1],[1,0],[2,2]]
g1 = points(puntos,size=30)
g1

A = matrix(QQ,[[1,-1, 1],[1, 0, 0],[1, 1, 1],[1, 2, 4]])
b = vector(QQ,[1, -1, 0, 2])

solucion = (A.transpose()*A).solve_right(A.transpose()*b)
solucion

var('x')
g2 = plot((-7/10) -(3/5)*x + x^2,[x,-2,2])
(g1+g2).show()

Ejercicio 4.4. (Mínimos cuadrados para datos experimentales)

Enunciado: En unas mediciones realizadas en el laboratorio se han obtenido datos entre dos variables que se sabe que están relacionados mediante una parábola. Las mediciones contienen ruido y no existe una parábola que pase por todos los puntos. 1) Determinar la parábola que da la mejor aproximación por mínimos cuadrados para los puntos dados. 2) Determinar el vector error y el error. 3) Representar gráficamente los puntos y la parábola obtenida en el intervalo indicado.

# 4.3
x = vector([p[0] for p in datos])
y = vector([p[1] for p in datos])

A = matrix([[xi^2, xi, 1] for xi in x])

coef = (A.transpose()*A).solve_right(A.transpose()*y)
a, b, c = coef
a, b, c

y_aprox = A * coef
error_vector = y - y_aprox
error = error_vector.norm()
error_vector, error

f(x) = a*x^2 + b*x + c

g_puntos = points(datos, size=30, color='blue')
g_parabola = plot(f, (x, 0, 10), color='red', thickness=2)

g_puntos + g_parabola

Comentarios finales

  • He corregido errores ortográficos, de mayúsculas/minúsculas y la puntuación, manteniendo íntegro el contenido original y el código proporcionado.
  • Para mejorar la comprobación de desigualdades y la validación de operaciones matriciales se aconseja revisar dimensiones antes de operar y utilizar las funciones correspondientes para producto escalar, norma y determinantes.
  • Si desea, puedo convertir el código mostrado a un formato ejecutable en Python (NumPy/SciPy) o Sage, corregir comprobaciones lógicas (por ejemplo la comprobación de Cauchy-Schwarz) y calcular los resultados numéricos paso a paso.