Matemáticas con Mathematica

Práctica 8. Gráficos 3D. Derivadas parciales. Extremos relativos y extremos 
                 condicionados

Francisco Javier Pérez González
Departamento de Análisis Matemático
Universidad de Granada

Introducción

Con Mathematica puedes hacer de forma muy sencilla espectaculares representaciones gráficas de superficies y curvas en (ℝ^3). A tal efecto, el programa proporciona una gran variedad de comandos de uso general y también "paquetes" dirigidos a fines más específicos. En esta práctica veremos las herramientas de uso más frecuente cuyo conocimiento te permitirá, si el tema es de tu interés, proseguir el estudio por tu cuenta. Lo que debes aprender en este cuaderno es lo siguiente.

Representar gráficamente superficies definidas de distintas formas.
Calcular derivadas parciales, vectores gradientes y derivadas direccionales.
Calcular y representar planos tangentes a una superficie.
Calcular extremos relativos de campos escalares de dos y tres variables.
Usar la teoría de los multiplicadores de Lagrange para calcular extremos condicionados.
Calcular extremos absolutos en conjuntos compactos.

Representación gráfica de superficies

Para representar una superficie debes tener en primer lugar una descripción matemática de la misma. Las formas más frecuentes de dar una superficie en (ℝ^3) son las siguientes:
a) La superficie viene dada por la gráfica de una función, es decir, se trata de una supercie de la forma

\(TraditionalForm\`S = \({\((x, y, 
                z)\) ∈ \(\(ℝ\^3\) : \ \((x, 
                    y)\) ∈ A\), \ 
            z = f(x, y)} = {\((x, y, 
                f(x, y))\) ∈ \(\(ℝ\^3\) : \ \((x, y)\) ∈ A\)}\)\)    donde  A ⊂  (ℝ^2)

b) La superficie está definida implícitamente por una ecuación, es decir, se trata de una superficie de la forma

S = {(x, y, 
                z) ∈ (ℝ^3) : 
                h(x, y, z) = 0}

c) La superficie está definida paramétricamente, es decir, se trata de una superficie de la forma S = ϕ(A) donde ϕ es una función de dos variables con valores en (ℝ^3). La función ϕ transforma un subconjunto \(TraditionalForm\`A ⊂ ℝ\^\(\(2\)\(\ \)\)\)en una superficie en (ℝ^3). En este caso se acostumbra a interpretar los puntos del conjunto A como parámetros que describen la superficie. Si notamos (u, v) ∈ A un elemento genérico de A, la función ϕ debe ser de la forma

ϕ(u, 
        v) = ((Subscript[ϕ, 1])(u, v), (Subscript[ϕ, 2])(u, v), (Subscript[ϕ, 3])(u, 
          v))

y, por tanto S = ϕ(
            A) = {((Subscript[ϕ, 1])(u, v), (Subscript[ϕ, 2])(u, v), (Subscript[ϕ, 3])(
                u, v)),   (u, v) ∈ A}.

Nota: Oberva que a) es un caso particular de b). En efecto, si S es la gráfica de una función f como en a), entonces S también viene dada como en b) sin más que considerar la función h(x, y, z) = z - f(x, y). También a) es un caso particular de c) pues basta definir para (x, y) ∈ A

ϕ(x, y) = (x, y, f(x, y))

Mathematica dispone de comandos que permiten representar fácilmente superficies de cualquier forma que vengan dadas.

Superficies que son gráficas de funciones: El comando Plot3D[ ]

La sintaxis de este comando (muy parecida a la de "Plot[ ]") es "Plot3D[f[x,y],{x,xmin,xmax},{y,ymin,ymax},opciones]" donde se entiende que f[x,y] es una función de dos variables que debe estar definida en el rectángulo [xmin,xmax]x[ymin,ymax].

\(g1 = 
      Plot3D[Sin[\@\(x\^2 + \((3 + x)\) y\^2\)], {x, \(-3\), 3}, {y, \(-4\), 
          4}, 
PlotPoints -> 50, 
		
        ViewPoint -> {0.204, \(-1.212\), 3.153}, 
        
Boxed -> False, 
        
Axes -> None, 
        
AmbientLight -> GrayLevel[ .2]]\)

Fácil, ¿verdad?. Claro está, he elegido las opciones de "Plot3D[ ]" que más me gustan para representar esa bonita superficie. Puedes consultar las opciones en la ayuda de Mathematica.

Options[Plot3D]

Algunas de las opciones se entienden por sí solas y con un poco de práctica aprenderás a usar las más frecuentes que son:
Mesh->True/False  Indica si deben representarse o no la retícula o malla sobre la que se construye la gráfica.
Shading->True/False 	Indica si la superficie debe ser o no ser sombreada. 
PlotPoints->nº de puntos   Es el número de puntos que usará Mathematica para representar la gráfica. Un número muy alto producirá un gráfico más “suave”, pero aumentará, a veces de forma notable, el tiempo empleado para realizarlo.
ViewPoint   Establece el punto de vista desde el que se dibujará la gráfica. Mathematica trata de elegir siempre el punto de vista óptimo. La forma de usar esta opción será “pegarlo” desde una ventana que automatiza el proceso. A dicha ventana se accede a través del menú Input, submenú 3D ViewPoint Selector.
ColorFunction->Hue  Colorea los puntos de la gráfica en función de su altura sobre el plano XY.

A continuación puedes ver el efecto de cambiar algunas opciones. Como hemos puesto nombre a la gráfica podemos representarla con "Show[ ]" y las nuevas opciones prevalecen. Observa la forma en que Mathematica representa los ejes "X", "Y", "Z".

\(Show[g1, Mesh -> False, Boxed -> True, Axes -> True, 
      AxesLabel -> {"x", "y", "z"}, 
      ViewPoint -> {1.300, \ \(-2.400\), \ 2.000}, 
      Ticks -> {Automatic, Automatic, {\(-1\), 1}}, 
      ColorFunction -> Hue]; 
Clear[g1]\)

A veces hay que darle una ayudita a Mathematica para que la gráfica quede bien. Por ejemplo, la siguiente gráfica no parece lo que es: parte de un cono de revolución recto de ecuación z = (Sqrt[(x^2) + (y^2)]).

Plot3D[(Sqrt[(x^2) + (y^2)]), {x, -1, 1}, {y, -1, 1}, 
      AspectRatio -> 1, BoxRatios -> {1, 1, 1}, 
      AxesLabel -> {"x", "y", "z"}, 
      PlotPoints -> 30]

Si te fijas, lo que pasa es que los bordes del cono no están a la misma altura sino que su altura varía desde 1 a (Sqrt[2]). Podemos mejorarla mucho cortando el cono con el plano z = 1.

Plot3D[Min[(Sqrt[(x^2) + (y^2)]), 1], {x, -1, 1}, {y, -1, 1}, 
      AspectRatio -> 1, BoxRatios -> {1, 1, 1}, 
      AxesLabel -> {"x", "y", "z"}, 
      PlotPoints -> 30]

Es muy fácil hacer animaciones gráficas en 3D; basta con que introduzcas un parámetro en la función y uses un "Do[ ]".  Aquí puede ver una onda que se va desplazando producida por una gota que cae en el agua.

Do[Plot3D[
            Cos[(Sqrt[x^2  +  y^2]) + Abs[n - 2 Pi]]/ 
              (Sqrt[x^2  +  y^2  +  1/4]), 
             {x, -4 Pi, 4 Pi}, {y, -4 Pi, 4 Pi},  PlotPoints -> 26, 
            Lighting -> True, PlotRange -> {-2, 2},  
            BoxRatios -> {1, 1, 1}, Boxed -> False, Axes -> None], 
           {n,  0,  2 Pi  -  (2 Pi/16),  2 Pi/16}] ;
SelectionMove[EvaluationNotebook[], All, GeneratedCell];
FrontEndTokenExecute["CellGroup"]FrontEndTokenExecute["OpenCloseGroup"]

Una manera de hacer gráficas muy interesante consiste en levantar cilindros sobre curvas en el plano. Por ejemplo, podemos representar en el plano XY la circunferencia unidad cuya ecuación es {Cos[t],Sin[t]} para -π≤t≤π, o parte de ella controlando el intervalo de variación del parámetro "t", y sobre esa curva podemos levantar un cilidro de la altura que queramos. Claro está que en vez de la circunferencia unidad puedes elegir cualquier otra curva cuyas ecuaciones paramétricas conozcas.

fig1 = 
        ParametricPlot3D[{Cos[t], Sin[t], z}, {t, -π/7, 
            11  π/7}, {z, 0, 1}] ;

Antes de ejecutar la siguiente celda piensa medio minuto (no quiero que te canses...) si Mathematica podrá hacer lo que le pedimos. Se trata de representar la mitad superior de la esfera unidad.

Plot3D[(Sqrt[1 - (x^2) - (y^2)]), {x, -1, 1}, {y, -1, 1}, 
        PlotPoints -> 50, AspectRatio -> 1, 
        Axes -> None];

Ya ves lo que ha pasado: nuestra función no toma valores reales en todos los puntos del rectángulo [-1,1]x[-1,1]. Hay muchas formas de arreglar esto. Por ejemplo tomando parte real con el comando "Re [ ]".

Plot3D[Re[(Sqrt[1 - (x^2) - (y^2)])], {x, -1, 1}, {y, -1, 1}, 
        PlotPoints -> 50, AspectRatio -> 1, 
        Axes -> None];

Pero si quieres representar la esfera completa el comand "Plot3D[ ]" no es el más apropiado porque una esfera no es una gráfica.

Curvas y superficies dadas por ecuaciones paramétricas: El comando ParametricPlot3D[ ]

La sintaxis de este comando (muy parecida a la de "ParametricPlot[ ]") es 
			"ParametricPlot3D[{X[u,v], Y[u,v], Z[u,v]},{u, umin, umax},{v, vmin, vmax},opciones]" 
donde se entiende que X, Y, Z son funciones de dos variables que deben estar definidas en el rectángulo [umin, umax]x[ymin, ymax]. Para usar este comando lo único que necesitas es conocer las ecuaciones paramétricas de la superficie. Aquí tienes una esfera.

ParametricPlot3D[{Sin[ϕ] Cos[θ], 
          Sin[ϕ] Sin[θ], 
          Cos[ϕ]}, {θ, -π, π}, {ϕ, 
          0, π}];

Controlando los parámetros puedes conseguir representar partes de la superficie.

ParametricPlot3D[{Sin[ϕ] Cos[θ], 
          Sin[ϕ] Sin[θ], Cos[ϕ]}, {θ, 0, 
          3  π/2}, {ϕ, π/8, π}];

El comando "ParametricPlot3D[{f[x] Cos[t], f[x] Sin[t], x},{x,a,b},{t,0,2π}]"  representa la gráfica de la superficie de revolución obtenida girando la curva de ecuación y = f(x) alrededor del segmento [a,b] del eje OZ. Por ejemplo, la esfera anterior puedes representarla como sigue

ParametricPlot3D[{(Sqrt[1 - (x^2)]) Cos[t], (Sqrt[1 - (x^2)]) 
            Sin[t], x}, {x, -1, 1}, {t, -π, π}];

Una bonita superficie.

ParametricPlot3D[{u Cos[u] (4 + Cos[v + u]), 
        u Sin[u] (4 + Cos[v + u]), u Sin[v + u]}, {u, 0, 4 π}, {
        v, 0, 2 π}, PlotPoints -> {80, 20}];

Otra bonita superficie.

ParametricPlot3D[{Cos[π t] + ((3 - t)/3) Cos[s], 
        Sin[π t] + ((3 - t)/3) Sin[s], t}, {s, 0, 2  π}, {t, 0, 
        3}, AspectRatio -> 1, BoxRatios -> {1, 1, 1}, PlotPoints -> {30, 30}, 
      Boxed -> False, Axes -> False, 
      ViewPoint -> {-0.005,  -1.359,  -3.099}];

Aquí tienes una pequeña maravilla.

ParametricPlot3D[{{Cos[s] (3 + Cos[t]), Sin[s] (3 + Cos[t]), 
          Sin[t]}, {3 + Sin[s] (3 + Cos[t]), Sin[t], 
          Cos[s] (3 + Cos[t])}}, {s, 0, 2  π}, {t, 0, 2  π}, 
      PlotPoints -> {30, 30}, Boxed -> False, Axes -> False];

Puedes combinar varias superficies en "ParametricPlot3D[ ]".

\(\(ParametricPlot3D[{
		{Sin[v] Cos[u], Sin[v] Sin[u], Cos[v]}, 

        		{Cos[u]/2, Sin[u]/2, v - 1}
	}, {u, 0, 3  Pi/2}, {v, 0, Pi}]; 
    \)\)

El comando ParametricPlot3D[{X[t],Y[t],Z[t]},{t,tmin,tmax},opciones] sirve para representar curvas en (ℝ^3) dadas por sus ecuaciones paramétricas. Si añades al final una función de color, como en el siguiente ejemplo donde se usa la función de color "Hue[ ]", los puntos de la curva se colorean variando los colores de forma continua.

ParametricPlot3D[{3  Cos[t], 3  Sin[t], t, Hue[t]}, {t, 0, 
        4  π}];

También puedes controlar directamente el grosor de la línea.

ParametricPlot3D[{3  Cos[t], 6  Sin[t], 
        t, {Hue[t], Thickness[0.02]}}, {t, 0, 4  π}];

\(\(ParametricPlot3D[{Cos[3\ t], \ Sin[t]\ Cos[5\ t], 
        Sin[t], {Hue[t], Thickness[0.01]}}, 
\ {t, \ 0, \ 2\ Pi}, 
      PlotPoints -> 160]; \)\)

Curvas de nivel: el comando ContourPlot[ ]

Una forma interesante de ver la gráfica de una función es mediante curvas de nivel. Por este método lo que se hace es representar la gráfica de una función en (ℝ^3) proyectando sobre el plano XY las curvas intersección de dicha superficie con planos paralelos al plano XY (curvas de nivel). Estás acostumbrado a ver estas representaciones porque los mapas topográficos representan el relieve del terreno por curvas de nivel. Esta representación permite ver las zonas donde la función varía más rápidamente porque las curvas de nivel están más próximas entre sí. Mathematica representa con tonos más luminosos las zonas donde la función toma valores más grandes y con tonos más oscuros las zonas donde la función es más pequeña. En el siguiente ejemplo muestra claramente lo que se hace (observa, de paso, el uso de la primitiva gráfica "Polygon[ ]" en 3D).

\(graph1\  = 
      Plot3D[\((3  x\^2 + y\^2)\) Exp[1 - x\^2 - y\^2], {x, \(-2\), 2}, {y, 
          \(-2\), 2}, PlotPoints -> 30\ , DisplayFunction -> Identity]; 

    Plane[h_, size_] := 
	
      Graphics3D[{
          Polygon[{{\(-size\), \(-size\), h}, {size, \(-size\), h}, {size, 
                size, h}, {\(-size\), size, h}}]}]\)\(graph2 = Show[{graph1, Plane[1.6, 2]}, \ DisplayFunction -> Identity]; 
    
Show[GraphicsArray[{graph1, graph2}], 
      DisplayFunction -> $DisplayFunction\ ]; 
Clear[graph1, graph2]\)

Como puedes ver, "ContourPlot[ ]" nos va a proporcionar un "mapa topográfico" de la función. Las líneas de contorno unen los puntos de la superficie que tienen la misma altura. Por defecto, Mathematica representa curvas de contorno para una sucesión de valores de altura igualmente espaciados. La sintaxis del comando es

"ContourPlot[f[x,y],{x,xmin,xmax},{y,ymin,ymax},opciones]"

Las opciones son las mismas del comando "ContourGraphics[ ]" que sirve para representar varios "ContourPlot[ ]" y, además, puede controlarse el número de puntos de evaluación con PlotPoints->nº de puntos. Veamos el gráfico de contorno de la superficie anterior.

ContourPlot[
      (3  (x^2) + (y^2)) Exp[1 - (x^2) - (y^2)], {x, -2, 2}, {y, -2, 
        2}];

Puedes observar claramente dos cumbres (dos máximos) y un pozo (un mínimo). Las opciones son muchas.

Options[ContourGraphics]

En el siguiente ejemplo pueden apreciarse claramente dos máximos y dos mínimos.

Show[
      GraphicsArray[
        Plot3D[Sin[x] Sin[y],  {x,  -π,  π}, 
           {y,  -π,  π}], 
        ContourPlot[Sin[x] Sin[y],  {x,  -π,  π}, 
           {y,  -π,  π}, PlotPoints -> 50, PlotPoints -> 50, 
          ColorFunction -> (Hue[If[# > 0, #, # -  .5]]&)]]];

Podemos animar la gráfica de contorno anterior.

\(Do[ContourPlot[Sin[x + n]\ Sin[y + n], 
        \ {x, \(-Pi\), Pi}, {y, \(-Pi\), Pi}, 
        ColorFunction -> \((Hue[# + n/\((2  Pi)\)]&)\), PlotPoints -> 40], {
        n, 0, 2  Pi - 2  Pi/50, 2  Pi/50}]; 

    SelectionMove[EvaluationNotebook[], All, GeneratedCell]; 

    FrontEndTokenExecute["CellGroup"]\)FrontEndTokenExecute["OpenCloseGroup"]

El comando "DensityPlot[f[x,y],{x,xmin,xmx},{y,ymin,ymax},opciones]", parecido al anterior, representa los valores de la función sobre una retícula en el plano. Lo que hace es dividir el rectángulo [xmin,xmax]x[ymin,ymax] en 15x15=225 retangulitos y evaluar en el centro de cada uno de ellos la función. Los tonos más luminosos se corresponden con los valores mayores de la función. Con este comando se pueden hacer gráficas muy hermosas.

DensityPlot[Sin[1/(x*y)], {x, -2, 2}, {y, -2, 2}, 
        PlotPoints -> 200, ColorFunction -> Hue, Mesh -> False];

Curvas y superficies definidas implícitamente

Puedes representar curvas implícitamente definidas con el comando "ImplicitPlot[ecuacion,{x,xmin,xmax}] ". Antes debemos cargar el paquete correspondiente.

<<  Graphics`ImplicitPlot`

ImplicitPlot[((x^2)/9) + ((y^2)/3) == 1, {x, -3, 3}];

Ten en cuenta que una ecuación de la forma f(x, y) = 0 puede representar "algo más" que una curva.

\(g[x_, y_] = 
      \(-12\) + 16\ x + 2\ x\^2 - 8\ x\^3 + 2\ x\^4 + 11\ y\^2 - 
        20\ x\ y\^2 + 7\ x\^2\ y\^2 + 5\ y\^4; 

    ImplicitPlot[g[x, y] == 0, {x, \(-6\), 6}, PlotRange -> All]; \)

Para representar superficies implícitamente definidas hay que cargar el paquete siguiente que pone a nuestra disposición el comando ContourPlot3D[ ] que es el análogo en tres dimensiones de ContourPlot[ ].

<<Graphics`ContourPlot3D`

\(\(\(ContourPlot3D[2  x^2 + y^2 - z^2 - 1, 

      \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ {x, \(-2\), 2}, \ {y, \(-2\), 2}, 
      \ {z, \(-2\), 2}, 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 
      PlotPoints -> {{5, 7}, {5, 7}, {5, 7}}]; 
    \) (*\ Hiperboloide\ de\ una\ hoja\ *) \)\)

\(\(ContourPlot3D[z\^2 + \((2 - \@\(x\^2 + y\^2\))\)\^2 - 1, 
      
	{x, \(-3\), 3}, {y, \(-3\), 3}, {z, \(-1\), 1}, 
      
	PlotPoints -> {{5, 7}, {5, 7}, {5, 7}}]; \)\)

\(\(\(ContourPlot3D[x^2 + 2\ y^2 + 3\ z^2 - 3, 
      
		{x, \(-2\), 2}, {y, \(-2\), 2.2}, {z, \(-1\), 
        1}, 
		PlotPoints -> {{5, 7}, {5, 7}, {5, 7}}]; 
    \)\  (*\ elipsoide\ *) \)\)

Ejercicio 1

Derivadas parciales

Para campos escalares de varias variables (esto es, funciones que "salen'' de (ℝ^n) y "llegan'' a ℝ), el comando "D[f[x,y,...],{x,n1},{y,n2},...]}" nos devuelve la derivada parcial de f respecto de x n1-veces, respecto de y n2-veces,... pudiendo omitirse el número de veces si éste es 1. Si se omite una variable quiere decir que no se deriva respecto de ella ninguna vez.

D[
        (x^y) + Sin[x*y], {x, 3}, {y, 
          2}]//Simplify

Mathematica conoce la regla de la cadena para derivadas parciales. Observa cómo evalúa correctamente las derivadas parciales de una función compuesta. También debes fijarte en la forma en que Mathematica representa las derivadas parciales.

\(f[u_, v_] = g[u\^2 + v\^2, Cos[u*v]]; 
    \  (*\ f[u, v]\ es\ la\ función\ compuesta\ g[x, y]\ con\ x = 
        u\^2 + v\^2, \ y = Cos[u*v]\ *) 
D[f[u, v], u]\)D[f[u, v], u] /. {u -> 1, v -> π/2}

Para definir una función derivada parcial hay que tomar ciertas precauciones. En particular, no es aconsejable usar la asignación diferida.

\(f[x_, y_] = Sin[x*y]; 
fx3[x_, y_] := D[f[x, y], {x, 3}]\)fx3[1, 2]

Al definir fx3[x,y] con una igualdad diferida (:=) lo que Mathematica ha almacenado como definición de fx3[x,y] no es la derivada parcial de f[x,y] respecto a la variable x tres veces, sino el comando "D[f[x,y], {x, 3}]"; pero dicho comando no se ha ejecutado pues se trata de una asignación diferida por lo que dicho comando se ejecuta después de que se llame a la función fx3[x,y]. Por eso cuando escribes fx3[1,2] lo que estás diciendo a Mathematica es que derive f[1,2] respecto a la variable 1 tres veces y, claro está, 1 no es una variable válida para derivar. Naturalmente, esto se arregla definiendo fx3[x,y] con la asignación inmediata (=).

Clear[fx3]\(fx3[x_, y_] = D[f[x, y], {x, 3}]; 
fx3[1, 2]\)

La forma más segura de definir una derivada parcial es localizar la variable respecto de la que se deriva y sustituir después por la variable en cuestión. Haciéndolo de esta forma se puede usar la asignación diferida.

Clear[fx3]fx[x_, y_] := Module[{s}, D[f[s, y], {s, 3}] /. s -> x]fx[1, 2]Clear[f, fx]

Gradiente de un campo escalar

El gradiente de un campo escalar f es el campo vectorial ∇f cuyas componentes son las derivadas parciales de primer orden de f. Para calcular el gradiente de una función de varias variables basta construir el vector formado por las derivadas parciales primeras de la función respecto de todas las variables.

Clear[f]grad[f_][x_, y_] = {D[f[x, y], x], D[f[x, y], y]}   grad[f_][x_, y_, z_] = {D[f[x, y, z], x], D[f[x, y, z], y], 
        D[f[x, y, z], z]}

Aunque estos comandos tienen el mismo nombre Mathematica sabe cuál usar en cada caso porque antes de usarlo comprueba si la función f (que tú debes de haber definido previamente) tiene dos o tres variables.

\(f[x_, y_] = x^2  Sin[x*y]; 
f[x_, y_, z_] = y*z*Cos[x^2 + z^2]; 

    \(grad[f]\)[x, y]\)grad[f][1, Pi]grad[f][x, y, z]grad[f][1, -1, 2]

Con frecuencia hay que evaluar un vector gradiente en vectores. Entonces debemos definirlo de forma que esto pueda hacerse cómodamente.

Clear[f]\(\(grad[f_]\)[{x_, y_}] = \(grad[f]\)[x, y]; 

    \(grad[f_]\)[{x_, y_, z_}] = \(grad[f]\)[x, y, z]; \)

\(f[x_, y_] = x^2  Sin[x*y]; 
f[x_, y_, z_] = y*z*Cos[x^2 + z^2]; 

    \(grad[f]\)[{1, Pi}]\)grad[f][{1, -1, 2}]

El vector gradiente es útil para calcular derivadas de un campo escalar en una dirección dada. Te recuerdo que una dirección en (ℝ^n) es un vector de norma 1. Si f es un campo escalar con derivadas parciales continuas, la derivada de f en un punto a en la dirección dada por el vector u viene dada por el producto escalar \(TraditionalForm
      \`⟨∇\(f(a)\) | u⟩\). Supuesto que ∇f(a) ≠ 0, la dirección en la cual la derivada direccional de f en a es máxima, que indica la dirección en la cual el campo en a crece más rápidamente, viene dada por el vector ∇f(a) / || ∇f(a) || . Por tanto, el vector gradiente en cada punto indica la dirección en la que el campo aumenta más rápidamente en dicho punto. Análogamente, la dirección en la cual la derivada direccional de f en a es mínima, que indica la dirección en la cual el campo en a decrece más rápidamente, viene dada por el vector -∇f(a) / || ∇f(a) || . Si a y b son puntos de (ℝ^n) la dirección del punto a hacia el punto b viene dada por el vector (b - a) / || b - a || .

Ejercicio 2

Ejercicio 3

Ejercicio 4

Ejercicio 5

Extremos relativos

Como ya sabes, para calcular los extremos relativos de un campo escalar de varias variables, lo primero que hay que hacer es calcular  los puntos críticos, es decir, los puntos donde se anula el vector gradiente; y después estudiar la matriz hessiana en esos puntos. Veamos un ejemplo.
Se trata de calcular los extremos relativos de la función f(x, y) = (x^3) + 3  x (y^2) - 15 x - 12 y. Definimos los comandos apropiados para el gradiente y la matriz hessiana.

\(Clear[f]; 

      \(grad[f_]\)[x_, y_] = {D[f[x, y], x], D[f[x, y], y]};  (*\ 
        vector\ gradiente\ *) 
\(grad[f_]\)[{x_, y_}] = \(grad[f]\)[x, y]; 
      \  (*\ para\ que\ el\ gradiente\ pueda\ evaluarse\ en\ vectores
          \ {x, y}\ *) 
        
\(H[f_]\)[x_, 
          y_] = {{D[f[x, y], {x, 2}], D[f[x, y], x, y]}, {D[f[x, y], x, y], 
            D[f[x, y], {y, 2}]}};  (*\ matriz\ hesiana\ *) 

      \(H[f_]\)[{x_, y_}] = \(H[f]\)[x, y]; \)

\(f[x_, y_] = x\^3 + 3\ x*y\^2 - 15  x - 12  y; 
    
 (*calculamos\ los\ puntos\ críticos\ y\ los\ sacamos\ como\ una
          \ lista\ usando\ el\ comando\ de\ sustitución\  /. \ *) 

    pcrit = {x, y} /. Solve[\(grad[f]\)[x, y] == {0, 0}, {x, y}]\)

Si hubiéramos obtenido soluciones imaginarias deberíamos elegir solamente las soluciones reales. Ahora estudiaremos la matriz hesiana en cada uno de los puntos críticos. Primero evaluamos la matriz hesiana en dichos puntos.

hesis = Map[H[f], pcrit]

Ahora necesitamos el comando "Det[m]" que proporciona el determinante de la matriz cuadrada m. Nuestro objetivo será calcular el determinante de la matriz hessiana en cada punto crítico.

Map[Det, hesis]

Como el determinante de la matriz hesiana es negativo en los puntos (-1,-2) y (1,2) ya podemos asegurar que dichos puntos son puntos de silla. Nos queda por ver el primer elemento de la matriz hessiana en los puntos (-2,-1) y (2,1).

{H[f][-2, -1][[1, 1]], 
      H[f][2, 1][[1, 1]]}

Concluimos que en (-2,-1) hay un máximo relativo y en (2,1) hay un mínimo relativo. Podemos comprobar gráficamente los resultados obtenidos.

Plot3D[f[x, y], {x, -3, 3}, {y, -3, 3}, 
      BoxRatios -> {1, 1, 1}];

ContourPlot[f[x, y], {x, -2.5, 2.5}, {y, -2.5, 2.5}];

Para una función de tres variables podemos construir cómodamente su matriz hessiana con la ayuda del comando "Outer[ ]". Si h es una función, pongamos de 2 variables, y α = {a, b, c, d},  β = {u, v, w} son listas, el comando

Outer[h,α,β]

proporciona una matriz de orden 4x3 cuyos elementos son h[α[[i]], β[[j]]]. Si aplicamos el comando "Outer[ ]" al operador diferencial D, al vector gradiente de una función y a las variables de dicha función, obtenemos la matriz hessiana.

\(\(grad3[f_]\)[x_, y_, z_] = {D[f[x, y, z], x], D[f[x, y, z], y], 
        D[f[x, y, z], z]}; 

    \(H3[f_]\)[x_, y_, z_] = Outer[D, \(grad3[f]\)[x, y, z], {x, y, z}]\)H3[f][x, y, z] // MatrixForm

Ejercicio 6

Extremos condicionados

Hagamos un problema de extremos condicionados. Se trata de calcular el máximo y el mínimo absolutos de (x^3) + (y^3) + (z^3) en el elipsoide 4  (x^2) + 9  (y^2) + 16  (z^2) - 25 = 0.

F[x_, y_, z_, λ_] = 
      (x^3 + y^3 + z^3) + 
        λ (4  x^2 + 9  y^2 + 16  z^2 - 25)

gradF[x_, y_, z_, λ_] = {D[F[x, y, z, λ], x], 
        D[F[x, y, z, λ], y], D[F[x, y, z, λ], z], 
        D[F[x, y, z, λ], λ]}

pcritic = 
      Solve[gradF[x, y, z, λ] == {0, 0, 0, 0}, {x, y, z, 
          λ}]

La existencia de los extremos absolutos buscados está garantizada por la compacidad de la esfera y dichos extremos tienen que alzanzarse en alguno de los puntos obtenidos. Para evaluar (x^3) + (y^3) + (z^(3 ))nos están sobrando las λ así que las quitamos y evaluamos.

pcrit = {x, y, z} /. pcritic

\(f[{x_, y_, z_}] = x^3 + y^3 + z^3; 

valores = Map[f, pcrit]\)

Max[valores]

Min[valores]

Cálculo de extremos absolutos en un compacto

Finalmente, haremos un ejercicio que combina extremos relativos y condicionados. Se considera la función

\(TraditionalForm
    \`f(x, y, z) = 
      \(\@48\) x\ y\ z\  - \((1 - x\^2 - y\^2 - z\^2)\)\^\(3/2\)\)

definida en la bola cerrada unidad: (x^2) + (y^2) + (z^2) ≤ 1. Se trata de calcular su máximo absoluto y su mínimo absoluto en dicha bola. 
Este problema consta realmente de dos problemas: calcular los extremos relativos de la función en la bola abierta y calcular los extremos de la función en la frontera de la bola, es decir, en la esfera unidad (un problema de extremos condicionados). Empecemos por el primero.

\(f[x_, y_, z_] = 
      \(\@48\) x\ y\ z\  - \((1 - x^2 - y^2 - z^2)\)^\((3/2)\); 

    pt = {x, y, z} /. 
        Solve[{D[f[x, y, z], x], D[f[x, y, z], y], D[f[x, y, z], z]} == {0, 
              0, 0}, 
			{x, y, z}]\)

Hessin[f_][x_, y_, z_] = 
      Outer[D, {D[f[x, y, z], x], D[f[x, y, z], y], D[f[x, y, z], z]}, {x, y, 
          z}]  Hessin[f_][{x_, y_, z_}] = Hessin[f][x, y, z];

\(\(normamenorqueuno[x_] := \@\(x . x\) < \(1\ \ \ \) (*\ 
      criterio\ para\ seleccionar\ los\ puntos\ con\ norma\ euclídea
          \  < 1\ *) ; 
			

    prt = Select[pt, normamenorqueuno]
 (*\ 
      seleccionamos\ entre\ los\ puntos\ críticos\ los\ que\ 
        están\ en\ el\ interior\ de\ la\ bola\ *) \)\)

\(matriceshesianas = Map[Hessin[f], prt]
 (*\ 
      calculamos\ las\ mateices\ hesianas\ en\ cada\ punto\ *) \)\(valorespropiosmatriceshesianas = Map[Eigenvalues, matriceshesianas]
 (*
      \ calculamos\ los\ valores\ propios\ de\ las\ matices\ hesianas\ *) 
      \)

A la vista de este resultado, se sigue que hay un único extremo relativo dentro de la bola que se encuentra en el origen y corresponde a un mínimo. Calculemos los extremos de la función en la esfera unidad.

\(F[x_, y_, z_, λ_] = 
      f[x, y, z] + λ \((x^2 + y^2 + z^2 - 1)\); 

    pcond = Solve[{D[F[x, y, z, λ], x], D[F[x, y, z, λ], y], 
            D[F[x, y, z, λ], z], 
            D[F[x, y, z, λ], λ]} == {0, 0, 0, 0}, {x, y, z, 
          λ}]\)

Ahora lo que hay que hacer es calcular los valores de la función f en los puntos de la esfera unidad obtenidos. Para evaluar f sobran los valores de λ. Los quitamos y evaluamos.

npcon = {x, y, z} /. pcond

\(f[{x_, y_, z_}] = f[x, y, z]; 

Map[f, npcon]\)

Como f(0, 0, 0) = -1 (no debemos olvidar este valor, aunque en este caso no influye en el resulado final), concluimos que al máximo absoluto de f es (4/3) y el mínimo absoluto es -(4/3).

Ejercicio 7

Ejercicio 8