Cálculo Avanzado: Fórmulas y Métodos Esenciales

Función Inversa

  1. Despejar *x* en función de *y*.
  2. Renombrar *x* por *y*-1.

Paridad de Funciones

  1. *f(x)* es par si *f(x) = f(-x)*.
  2. *f(x)* es impar si *f(x) = -f(-x)*.

Funciones Definidas a Trozos

  • *f(x) := if cond1 then exp1 else exp2*
  • *f(x) := if cond1 then exp1 else if cond2 then exp2 else exp3*

Para calcular el límite, hacerlo sobre cada trozo por separado.

Límites de Funciones

*limit(f(x), x, x0, plus/minus/inf/minf)*

Continuidad de Funciones

  • *f(c)* existe, *lim(x->c) f(x)* existe, *lim(x->c) f(x) = f(c)*: Continua.
  • *f(c)* existe, *lim(x->c) f(x)* existe, *lim(x->c) f(x) ≠ f(c)*: Discontinua evitable.
  • *f(c)* existe, *lim(x->c) f(x)* no existe: Discontinua de salto finito.

Cálculo de Raíces

  • *find_root(exp, var, a, b)*: ***a* e *b* cercanos al punto.
  • *solve(exp, var)*
  • *algsys([exp], [var])*

Derivación

Definición de Derivada

*f'(x) = lim(h->0) [f(x+h) – f(x)] / h*

Cálculo de la Derivada

*diff(exp, var, ord)*

Evaluación de la Derivada en un Punto *k*

  1. *define(f'(x), diff(exp, var, ord))*
  2. *f'(k)*

Recta Tangente

*y – f(x0) = f'(x0) * (x – x0)*

Recta Normal

*y = y0 – (1 / f'(x0)) * (x – x0)*

Función Inversa (Derivación)

  1. Definir la función.
  2. *diff(exp, var, ord)*
  3. *solve(exp = 0, x) –> x0*
  4. *algsys([exp = 0], [x]) –> x0*
  5. *define(df(x), diff(exp, var, ord))*
  6. Calcular *df(x0)*

Función Implícita

  1. *depends(y, x)*
  2. *diff(f(x, y), x, 1)*
  3. *solve(, diff(y, x))*
  4. *y'(x, y) :=*
  5. *y'(a, b) –> (a, b) punto designado*

Función Paramétrica

  1. Definir *x(t)* e *y(t)*.
  2. *define(dy(t), diff(y(t), t, 1) / diff(x(t), t, 1))*
  3. *dy(x0) –> evaluar en x0*

Método de Newton-Raphson

  1. *load(mnewton)*
  2. Definir la función.
  3. Graficar la función.
  4. *mnewton(exp, x, x0)*: ***x0* muy cercano a la raíz.

Funciones Definidas a Trozos (Derivación)

  1. Definir la función completa.
  2. Graficar la función.
  3. Definir cada trozo por separado.
  4. Hacer el límite de cada trozo en el punto objetivo.
  5. Límites laterales (= o no): la función es (derivable o no).

Polinomio de Taylor

  1. Definir la función.
  2. *taylor(exp, var, xo, ord)*
  3. Evaluar en un *x* dado.
  4. *define(f(x), trunc(taylor(exp, var, x0, ord)))*

Cálculo de Límites de Funciones Usando Taylor

  1. *limit(x->a) p(x)*

    *tlimit(trunc(taylor(p(x), x, 0, orden_derivada)), x, a)*

  2. *limit(x->a) p(x) / q(x)*

    *tlimit(trunc(taylor(p(x), x, 0, orden_derivada)) / trunc(taylor(q(x), x, 0, orden_derivada)), x, a)*

    1. Definir la función (o polinomio).
    2. Definir *p(x)* y *q(x)* por separado.
    3. Aplicar instrucción.

Cálculo del Orden de Derivación *n* para un Error Esperado *e*

Determinar el grado *n* del polinomio de McLaurin requerido para que el error de aproximación de la función en el valor *x* indicado sea menor a *e* (0.001).

Ejemplo: sin(0.3)

  1. *k: 1*
  2. *define(tn(x), trunc(taylor(sin(x), x, 0, k)))* [shift+enter]
  3. *while abs(sin(0.3) – tn(0.3)) >= 0.001 do* [enter]

    *(k: k+1, define(tn(x), trunc(taylor(sin(x), x, 0, k))))* [shift+enter]

  4. *print(“el valor mínimo del orden de derivación requerido es “, k)*

Interpolación Polinómica

  1. *load(interpol)*
  2. *datos: [[x1, y1], [x2, y2], …, [xn, yn]]*

    Ejemplo: *p: [[1, 1], [2, 2], [3, 2]]*

  3. *define(ipn(x), lagrange(datos))*

    Ejemplo: *define(ipn(x), lagrange(p))*

  4. *ratsimp(%)* (Simplificar el polinomio, si procede)
  5. *ipn(x0)* (Evaluar el polinomio, si procede)
  6. *plot2d([ipn(x), [discrete, p]], [x, 0.5, 3.5], [style, [lines], [points]])* (Graficar)

Interpolación Lineal

  1. *load(interpol)*
  2. *define(sl(x), linearinterpol(datos))*

Interpolación Cúbica

  1. *load(interpol)*
  2. *define(scnat(x), cspline(datos))*

Aplicaciones de la Derivada

  • Monotonía: *f'(x) > 0* (creciente) | *f'(x) < 0* (decreciente)
  • Puntos Críticos: *f'(x) = 0* (raíces) | Puntos de Inflexión: *f”(x) = 0*
  • Máximo Relativo: *f'(x) < 0* | Mínimo Relativo: *f'(x) > 0*
  • Curvatura: *f”(x) > 0* (convexa) | *f”(x) < 0* (cóncava)

Integración

Integrales Indefinidas

*integrate(f(x), variable)*

Integrales Definidas

*integrate(f(x), x, lim_inf, lim_sup)*

Integrales Impropias

  1. Probar *integrate(f(x), x, lim_inf, lim_sup)*: ok (convergente, principal_value)
  2. Si divergente: *limit(integrate(f(x), x, lim_inf, lim_sup), lim_sup, inf)*
  3. En las diapositivas:
    • *define(funcion2, integrate(funcion1, var_int, lim_inf, lim_sup))*
    • *limit(funcion2, var_int, limite)*
    • *integrate(funcion1, var_int, lim_inf, lim_sup)*

Integración Numérica (Romberg y Quadpack)

  • *load(romberg)*
  • *romberg(expresion, var_int, lim_inf, lim_sup)*

    Valores por defecto: *rombergit: 11, rombergtol: 0.0001*

  • *quad_qags(expresion, var_int, lim_inf, lim_sup)*

    Resultado: *[aproximacion_int, error_abs, iteraciones, cod_error]*

Cálculo de Áreas

  1. Definir las funciones.
  2. Graficar las funciones (ver la que está por encima).
  3. Calcular los puntos de intersección (raíces).
  4. Integral definida de cada tramo del área:
    • Una función: *integrate(exp, var, lim_inf, lim_sup)*
    • Dos funciones: *integrate(exp1 – exp2, var, lim_inf, lim_sup)*
  5. Sumar las áreas que intervienen.

Cálculo de Superficies de Revolución

*s = 2 * %pi * (integrate((f(x) * sqrt(1 + ((f'(x))^2))), var, lim_inf, lim_sup)*

Con *f'(x) = diff(f(x), x, 1)*

Cálculo de Volúmenes de Revolución

  • Eje x: *v = %pi * (integrate((f(x))^2, var, lim_inf, lim_sup))*
  • Eje y: *v = %pi * (integrate((x^2) * f'(x), var, lim_inf, lim_sup))*

Con *f'(x) = diff(f(x), x, 1)*

Matrices y Sistemas de Ecuaciones

Matriz: *a = [a b c; d e f; …]* –> filas * columnas (m * n)

Matriz Inversa

*a-1 = adj(a) / |a|*

*adj(a) = [(-1)^(i+j) * det(*)]* en cada elemento.

*) Elementos restantes al suprimir la fila y columna del elemento.

Matrices y Órdenes Útiles

  • Inversa: *inv(a)*
  • Determinante: *det(a)*
  • Ceros: *zeros(m, n)*
  • Unos: *ones(m, n)*
  • Identidad: *eye(m)*
  • Adjunta: *inv(a) * det(a)*

Operaciones con Matrices

  • +: Suma elemento a elemento
  • –: Resta elemento a elemento
  • *: Producto matricial no conmutativo (*a * b* es *a · b*)
  • /: División a la derecha (*a / b* es *a · (b-1)*)
  • \: División a la izquierda (*a \ b* es *(a-1) · b*)
  • ˆ: Potencias (*aˆ2* es *a2 = a · a*)
  • a’: Matriz traspuesta y conjugada
  • a.’: Matriz traspuesta
  • .*: Producto elemento a elemento
  • ./: División a la derecha elemento a elemento
  • .\: División a la izquierda elemento a elemento
  • .ˆ: Potencia elemento a elemento

Sistemas de Ecuaciones Lineales

Resolución de un Sistema de Ecuaciones (Tradicional)

  1. Introducir las matrices:
    • *a = [_ _ …]* – Matriz de los coeficientes.
    • *b = [_ _ …]* – Matriz de términos independientes.
  2. *x = a \ b* –> Solución
  3. *rank(a)* –> Comprobar rangos (opcional).
  4. *a * x = b* –> Comprobar la solución (opcional).

Resolución de un Sistema de Ecuaciones (Cramer)

  1. Calcular el *det(a)* (*a* matriz de coeficientes).
  2. *xi = |bi| / |a|* (*bi* matriz *a* con columna *i* sustituida por *b*)

Resolución de un Sistema de Ecuaciones (Numérica)

Descomposición LU (Lower-Tri.Inf / Upper-Tri.Sup)

  1. Introducir las matrices (*a*) y (*b*).
  2. *[l, u] = lu(a)* –> (*a = l * u*)
  3. *y = l \ b*
  4. *x = u \ y* –> Solución

Descomposición de Choleski

  1. Introducir las matrices (*a*) y (*b*).
  2. *lt = chol(a)* –> (Devuelve *l* traspuesta)
  3. *l = lt’* –> (Se vuelve a trasponer)
  4. *y = l \ b* –> (*l* matriz auxiliar)
  5. *x = lt \ y* –> Solución

Descomposición QR

*a = q * r*

  1. Introducir las matrices (*a*) y (*b*).
  2. *[q, r] = qr(a)* –> (Devuelve *q* y *r*)
  3. *b = q’ * b* –> (*b* matriz auxiliar)
  4. *x = r \ b* –> Solución

Normas Matriciales Subordinadas

  • ||a||f –> *norm(a, “fro”)*
  • ||a||max –> *max(max(abs(a)))*
  • ||a||1 –> *norm(a, 1)*
  • ||a||2 –> *norm(a, 2)*
  • ||a||inf –> *norm(a, inf)*

Independencia Lineal

Dado el sistema {v1, v2, …, vp} –> a1 * v1 + a2 * v2 + … + ap * vp = 0

  • Si a1 = 0, a2 = 0, …, ap = 0 –> Solución trivial (siempre)
  • Si no hay más soluciones –> Sistema linealmente independiente o libre
  • Si sí hay más soluciones –> Sistema linealmente dependiente o ligado

Rango de un Sistema

Dado el sistema {v1, v2, …, vp}

  • Si sistema libre –> rg = p
  • Si sistema ligado:
    • Sin sub-sistema libre –> rg = 0
    • Con sub-sistema libre –> rg = rg del mayor sub-sistema

Dimensión de un Espacio Vectorial

dim(v) = mayor rango de los sub-sistemas libres

Base de un Espacio Vectorial

base(v) = cualquier sistema libre de rango máximo

Teorema de Representación

dim(v) = n >= 1, b = {v1, …, vn}, w ∈ v

x1, …, xn coordenadas de w en b

w = x1v1 + … + xnvn

Base canónica o natural –> {(1, …, 0), (0, 1, …, 0), …, (0, …, 1)}

Coordenadas

Matriz columna de coordenadas: coordenadas de w (x1, …, xn) colocadas en vertical.

Todos los vectores de *v* tienen su propia columna de coordenadas en la base *b*.

Ejemplo

Hallar la dimensión y la base del sistema *q = {v1, v2, v3, v4}* y calcular las coordenadas de un vector *w* respecto de su base:

v1 = (1, 2, 3)

v2 = (2, 6, 10)

v3 = (0, -3, -6)

v4 = (-1, -3, -5)

  1. Colocar los vectores en una matriz *a* y hallar su rango por columnas.

    1 2 0 -1 a = 2 6 -3 -3 –> operaciones –> 2 1 0 0 –> c-rg(a) = 2 = f-rg(a) 3 10 -6 -5 3 2 0 0

  2. Hallar la dimensión del sistema.

    dim(a) = rg(a) = 2 –> la base de *a* será de dimensión 2

  3. Hallar la base de *a*.

    base(a) = {(1, 2, 3), (0, 1, 2)} con dim(base(a)) = 2

  4. Hallar las coordenadas de un vector de la base.

    En la base: v1 = (1, 2, 3) y v2 = (0, 1, 2)

    w = x1v1 + x2v2 –> x1 e x2 se eligen arbitrariamente

Subespacios Vectoriales

Es un subconjunto de un espacio vectorial que es también espacio vectorial.

Si en el sistema anterior *v2* y *v3*, por ejemplo, fueran un espacio vectorial, este espacio sería un subespacio de *q*.

Si un subespacio no es trivial (la mayoría) –> 1 <= dim(v) = n

Representación de Subespacios

Sistema generador de *s* –> sistema ligado de vectores combinación lineal del subespacio *s*.

Sistema libre, que basta con dar una de las bases de *s*.

Matriz de generadores (*ms*) –> vectores del sistema colocados en columna

c-rg(ms) = dim(s)

*s* = espacio de columnas de *ms* = img(ms)

Representación de Subespacios 2

Subespacio *s* como solución a un sistema homogéneo de ecuaciones lineales.

Matriz de coeficientes *as* –> matriz de ecuaciones de *s*.

Sus filas son las ecuaciones del subespacio –> *as * ms = 0*

dim(s) = n – rg(as), con *n* número de parámetros (*xn*).

La solución del sistema es una c.l. de los vectores de una base de *s* (columnas de *ms*)

*s* = espacio nulo(as) = ker(as) = núcleo(as)

Subespacio *s* –> matriz de generadores *ms* –> matriz de ecuaciones *as* –> dim(s) = rg(ms) = n – rg(as)

dim(ker(a)) + dim(img(a)) = n

Producto Escalar

Entre los vectores *u* y *v* –> *dot(u, v)*

Si *dot(u, v) = 0* –> ortogonales (perpendiculares)

Norma Euclídea

Del vector *u* –> *norm(u)*

Distancia entre Vectores

Entre los vectores *u* y *v* –> *norm(u – v)*

Ángulo entre Dos Vectores

Entre los vectores *u* y *v* –> cos(θ) = dot(u, v) / (norm(u) * norm(v))

  • θ = 0 –> paralelos
  • θ = pi/2 –> perpendiculares u ortogonales
  • θ = pi –> antiparalelos

Vector Unitario

Del vector *u* –> dividir cada componente por *norm(u)*

Proyección de un Vector sobre Otro

proy(u, v) = dot(u, v) / (norm(v)2) * v

Sistemas Ortogonales

Vectores ortogonales dos a dos.

Sistema siempre libre.

Sistema ortogonal de dimensión *n = dim(v)* es una base de *v*.

Base ortonormal –> *b = orth(q)*

Con norma 1 se llama unitario.

Bases Ortonormales

Base ortogonal de vectores unitarios.

Matriz ortonormal –> *q’ * q = i*

Proyección de un Subespacio

Dados los subespacios *s* y *l* mediante las matrices *ms* y *ml*, calcular la proyección de *v* sobre *s* y *l*:

  1. Escribir *ms*, *ml* y *v*.
  2. Calcular las bases ortonormales y las unimos –> *ms = orth(ms), ml = orth(ml), m = [ms, ml]*
  3. Obtenemos las coordenadas de *v* sobre *s* –> *x = m \ v, xs = x(1:rank(ms))*
  4. La proyección de *v* sobre *s* –> *vs = ms * xs* (*v – vs* sobre *l*)
  5. Ángulo entre *v* y *v – vs* –> *vs’ * (v – vs) / (norm(vs) * norm(v – vs))*
  6. El proyector ortogonal sobre *s* –> *ps = ms * ms’*
  7. La proyección ortogonal –> *vso = ps * v*

Diagonalización

Opción 1 – Matrices Simétricas (a’ = a) y Normales – Diagonalización con Octave

  1. *a = [a b c; d e f; g h i]*
  2. *a’* –> Comprueba si es simétrica
  3. *eig(a)*
  4. *[m, d] = eig(a)*
    • *m* = Matriz de vectores propios
    • *d* = Matriz diagonal

Opción 2 – Usa Maxima y Octave – Ejemplo del día 14/12 – Solo cambiar valores

  1. Matriz *a*

    (mx) *a: matrix([3, 1, 1], [1, 3, 1], [3, 3, 3])*

  2. Polinomio característico de *a*

    (mx) *charpoly(a, x)*

  3. Valores propios o espectro de *a* = raíces del pol. car.

    (mx) *expand(%) solve(%=0, x) –> [x=1, x=2, x=6]*

  4. Multiplicidad (*mj*) = número de veces que se repite un v.p.

    (mano) *mj(1) = 1, mj(2) = 1, mj(6) = 1*

  5. Radio espectral de *a* = módulo del mayor de los v.p.

    (mano) *c = 6*

  6. Subespacio propio de *a* asociado a un v.p.

    (oc) *m1 = null(a – 1 * eye(3)) m2 = null(a – 2 * eye(3)) m6 = null(a – 6 * eye(3))*

  7. Matriz *m* de vectores propios

    (oc) *m = [m1, m2, m6]*

  8. Comprobación de la diagonalización:

    (oc) *d = inv(m) * a * m* y *a = m * d * inv(m)*

Funciones de Matrices (día 17/12) – Cálculo de Inversa de una Matriz

  1. *a = [a b c; d e f; g h i]*
  2. *eig(a)*
  3. *[m, d] = eig(a)*
    • *m* = Matriz de vectores propios
    • *d* = Matriz diagonal
  4. *fd = diag(1 ./ [d1 d2 d3])* –> *d1, d2, d3* = valores propios (diagonal de *d*)
  5. *inva = m * fd * inv(m)*

Descomposición de Schur

Diagonaliza matrices que no son normales (matriz normal conmuta con su adjunta)

  1. *a = [a b c; d e f; g h i]*
  2. *[m, u] = schur(a)*
    • *m* = Matriz de vectores propios
    • *u* = Matriz triangular superior –> si *a* es normal -> *u = d*

Valores Singulares

  1. *a = [a b c; d e f; g h i]*
  2. *[v, s, u] = svd(a)*
    • *v, u* = Matrices cuadradas unitarias
    • *s* = Diagonal con = dimensiones que *a*