MATLAB - Diferencial

MATLAB proporciona diffcomando para calcular derivadas simbólicas. En su forma más simple, pasa la función que desea diferenciar al comando diff como argumento.

Por ejemplo, calculemos la derivada de la función f (t) = 3t ² + 2t ^-2

Ejemplo

Cree un archivo de script y escriba el siguiente código en él:

syms t
f = 3*t^2 + 2*t^(-2);
diff(f)

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

ans =
6*t - 4/t^3

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

t = sym("t");
f = 3*t^2 + 2*t^(-2);
differentiate(f,t)

Octave ejecuta el código y devuelve el siguiente resultado:

ans =
   -(4.0)*t^(-3.0)+(6.0)*t

Verificación de reglas elementales de diferenciación

Enunciemos brevemente varias ecuaciones o reglas para la diferenciación de funciones y verifiquemos estas reglas. Para este propósito, escribiremos f '(x) para una derivada de primer orden y f "(x) para una derivada de segundo orden.

Las siguientes son las reglas para la diferenciación:

Regla 1

Para cualquier función f y g y cualquier número real a y b son la derivada de la función -

h(x) = af(x) + bg(x) con respecto ax está dado por -

h'(x) = af'(x) + bg'(x)

Regla 2

los sum y subtraction Las reglas establecen que si f y g son dos funciones, f 'y g' son sus derivadas respectivamente, entonces,

(f + g)' = f' + g'

(f - g)' = f' - g'

Regla 3

los product La regla establece que si f y g son dos funciones, f 'y g' son sus derivadas respectivamente, entonces,

(f.g)' = f'.g + g'.f

Regla 4

los quotient La regla establece que si f y g son dos funciones, f 'y g' son sus derivadas respectivamente, entonces,

(f/g)' = (f'.g - g'.f)/g²

Regla 5

los polynomial o la regla de poder elemental establece que, si y = f(x) = xⁿ, luego f' = n. x^(n-1)

Un resultado directo de esta regla es que la derivada de cualquier constante es cero, es decir, si y = k, cualquier constante, entonces

f' = 0

Regla 6

los chain La regla establece que, derivada de la función de una función h(x) = f(g(x)) con respecto ax es,

h'(x)= f'(g(x)).g'(x)

Ejemplo

Cree un archivo de script y escriba el siguiente código en él:

syms x
syms t

f = (x + 2)*(x^2 + 3)
der1 = diff(f)

f = (t^2 + 3)*(sqrt(t) + t^3)
der2 = diff(f)

f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
der3 = diff(f)

f = (2*x^2 + 3*x)/(x^3 + 1)
der4 = diff(f)

f = (x^2 + 1)^17
der5 = diff(f)

f = (t^3 + 3* t^2 + 5*t -9)^(-6)
der6 = diff(f)

Cuando ejecuta el archivo, MATLAB muestra el siguiente resultado:

f =
   (x^2 + 3)*(x + 2)
 
   der1 =
   2*x*(x + 2) + x^2 + 3
  
f =
   (t^(1/2) + t^3)*(t^2 + 3)
 
   der2 =
   (t^2 + 3)*(3*t^2 + 1/(2*t^(1/2))) + 2*t*(t^(1/2) + t^3)
  
f =
   (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2)
  
der3 =
   (2*x - 2)*(3*x^3 - 5*x^2 + 2) - (- 9*x^2 + 10*x)*(x^2 - 2*x + 1)
 
f =
   (2*x^2 + 3*x)/(x^3 + 1)
  
der4 =
   (4*x + 3)/(x^3 + 1) - (3*x^2*(2*x^2 + 3*x))/(x^3 + 1)^2
  
f =
   (x^2 + 1)^17
  
der5 =
   34*x*(x^2 + 1)^16
  
f =
   1/(t^3 + 3*t^2 + 5*t - 9)^6
  
der6 =
   -(6*(3*t^2 + 6*t + 5))/(t^3 + 3*t^2 + 5*t - 9)^7

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
t = sym("t");

f = (x + 2)*(x^2 + 3) 
der1 = differentiate(f,x) 

f = (t^2 + 3)*(t^(1/2) + t^3) 
der2 = differentiate(f,t) 

f = (x^2 - 2*x + 1)*(3*x^3 - 5*x^2 + 2) 
der3 = differentiate(f,x) 

f = (2*x^2 + 3*x)/(x^3 + 1) 
der4 = differentiate(f,x) 

f = (x^2 + 1)^17 
der5 = differentiate(f,x) 

f = (t^3 + 3* t^2 + 5*t -9)^(-6) 
der6 = differentiate(f,t)

Octave ejecuta el código y devuelve el siguiente resultado:

f =

(2.0+x)*(3.0+x^(2.0))
der1 =

3.0+x^(2.0)+(2.0)*(2.0+x)*x
f =

(t^(3.0)+sqrt(t))*(3.0+t^(2.0))
der2 =

(2.0)*(t^(3.0)+sqrt(t))*t+((3.0)*t^(2.0)+(0.5)*t^(-0.5))*(3.0+t^(2.0))
f =

(1.0+x^(2.0)-(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))
der3 =

(-2.0+(2.0)*x)*(2.0-(5.0)*x^(2.0)+(3.0)*x^(3.0))+((9.0)*x^(2.0)-(10.0)*x)*(1.0+x^(2.0)-(2.0)*x)
f =

(1.0+x^(3.0))^(-1)*((2.0)*x^(2.0)+(3.0)*x)
der4 =

(1.0+x^(3.0))^(-1)*(3.0+(4.0)*x)-(3.0)*(1.0+x^(3.0))^(-2)*x^(2.0)*((2.0)*x^(2.0)+(3.0)*x)
f =

(1.0+x^(2.0))^(17.0)
der5 =

(34.0)*(1.0+x^(2.0))^(16.0)*x
f =

(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-6.0)
der6 =

-(6.0)*(-9.0+(3.0)*t^(2.0)+t^(3.0)+(5.0)*t)^(-7.0)*(5.0+(3.0)*t^(2.0)+(6.0)*t)

Derivadas de funciones exponenciales, logarítmicas y trigonométricas

La siguiente tabla proporciona las derivadas de funciones exponenciales, logarítmicas y trigonométricas de uso común:

Función	Derivado
ca.x	c a.x .ln ca (ln es el logaritmo natural)
ex	e x
ln x	1 / x
lncx	1 / x.ln c
xx	x x . (1 + ln x)
sin(x)	cos (x)
cos(x)	-pecado (x)
tan(x)	seg 2 (x), o 1 / cos 2 (x), o 1 + tan 2 (x)
cot(x)	-csc 2 (x), o -1 / sin 2 (x), o - (1 + cot 2 (x))
sec(x)	sec (x) .tan (x)
csc(x)	-csc (x) .cot (x)

Ejemplo

Cree un archivo de script y escriba el siguiente código en él:

syms x
y = exp(x)
diff(y)

y = x^9
diff(y)

y = sin(x)
diff(y)

y = tan(x)
diff(y)

y = cos(x)
diff(y)

y = log(x)
diff(y)

y = log10(x)
diff(y)

y = sin(x)^2
diff(y)

y = cos(3*x^2 + 2*x + 1)
diff(y)

y = exp(x)/sin(x)
diff(y)

Cuando ejecuta el archivo, MATLAB muestra el siguiente resultado:

y =
   exp(x)
   ans =
   exp(x)

y =
   x^9
   ans =
   9*x^8
  
y =
   sin(x)
   ans =
   cos(x)
  
y =
   tan(x)
   ans =
   tan(x)^2 + 1
 
y =
   cos(x)
   ans =
   -sin(x)
  
y =
   log(x)
   ans =
   1/x
  
y =
   log(x)/log(10)
   ans =
   1/(x*log(10))
 
y =
   sin(x)^2
   ans =
   2*cos(x)*sin(x)
 
y =
   cos(3*x^2 + 2*x + 1)
   ans =
   -sin(3*x^2 + 2*x + 1)*(6*x + 2)
  
y =
   exp(x)/sin(x)
   ans =
   exp(x)/sin(x) - (exp(x)*cos(x))/sin(x)^2

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
y = Exp(x)
differentiate(y,x)

y = x^9
differentiate(y,x)

y = Sin(x)
differentiate(y,x)

y = Tan(x)
differentiate(y,x)

y = Cos(x)
differentiate(y,x)

y = Log(x)
differentiate(y,x)

% symbolic packages does not have this support
%y = Log10(x)
%differentiate(y,x)

y = Sin(x)^2
differentiate(y,x)

y = Cos(3*x^2 + 2*x + 1)
differentiate(y,x)

y = Exp(x)/Sin(x)
differentiate(y,x)

Octave ejecuta el código y devuelve el siguiente resultado:

y =

exp(x)
ans =

exp(x)
y =

x^(9.0)
ans =

(9.0)*x^(8.0)
y =

sin(x)
ans =

cos(x)
y =

tan(x)
ans =

1+tan(x)^2
y =

cos(x)
ans =

-sin(x)
y =

log(x)
ans =

x^(-1)
y =

sin(x)^(2.0)
ans =

(2.0)*sin(x)*cos(x)
y =

cos(1.0+(2.0)*x+(3.0)*x^(2.0))
ans =

-(2.0+(6.0)*x)*sin(1.0+(2.0)*x+(3.0)*x^(2.0))
y =

sin(x)^(-1)*exp(x)
ans =

sin(x)^(-1)*exp(x)-sin(x)^(-2)*cos(x)*exp(x)

Cálculo de derivados de orden superior

Para calcular derivadas más altas de una función f, usamos la sintaxis diff(f,n).

Calculemos la segunda derivada de la función y = f (x) = x .e ^-3x

f = x*exp(-3*x);
diff(f, 2)

MATLAB ejecuta el código y devuelve el siguiente resultado:

ans =
9*x*exp(-3*x) - 6*exp(-3*x)

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
f = x*Exp(-3*x);
differentiate(f, x, 2)

Octave ejecuta el código y devuelve el siguiente resultado:

ans =

(9.0)*exp(-(3.0)*x)*x-(6.0)*exp(-(3.0)*x)

Ejemplo

En este ejemplo, resolvamos un problema. Dado que una funcióny = f(x) = 3 sin(x) + 7 cos(5x). Tendremos que averiguar si la ecuaciónf" + f = -5cos(2x) se mantiene cierto.

Cree un archivo de script y escriba el siguiente código en él:

syms x
y = 3*sin(x)+7*cos(5*x);  % defining the function
lhs = diff(y,2)+y;        %evaluting the lhs of the equation
rhs = -5*cos(2*x);        %rhs of the equation
if(isequal(lhs,rhs))
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

Cuando ejecuta el archivo, muestra el siguiente resultado:

No, the equation does not hold true
Value of LHS is: 
-168*cos(5*x)

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
y = 3*Sin(x)+7*Cos(5*x);           % defining the function
lhs = differentiate(y, x, 2) + y;  %evaluting the lhs of the equation
rhs = -5*Cos(2*x);                 %rhs of the equation

if(lhs == rhs)
   disp('Yes, the equation holds true');
else
   disp('No, the equation does not hold true');
end
disp('Value of LHS is: '), disp(lhs);

Octave ejecuta el código y devuelve el siguiente resultado:

No, the equation does not hold true
Value of LHS is: 
-(168.0)*cos((5.0)*x)

Encontrar los máximos y mínimos de una curva

Si estamos buscando los máximos y mínimos locales para un gráfico, básicamente buscamos los puntos más altos o más bajos en el gráfico de la función en una localidad en particular, o para un rango particular de valores de la variable simbólica.

Para una función y = f (x), los puntos en la gráfica donde la gráfica tiene pendiente cero se llaman stationary points. En otras palabras, los puntos estacionarios son donde f '(x) = 0.

Para encontrar los puntos estacionarios de una función que diferenciamos, necesitamos igualar la derivada a cero y resolver la ecuación.

Ejemplo

Encontremos los puntos estacionarios de la función f (x) = 2x ³ + 3x ² - 12x + 17

Siga los siguientes pasos:

First let us enter the function and plot its graph.

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y)

MATLAB ejecuta el código y devuelve el siguiente gráfico:

Aquí está el código equivalente de Octave para el ejemplo anterior:

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y)
print -deps graph.eps

Our aim is to find some local maxima and minima on the graph, so let us find the local maxima and minima for the interval [-2, 2] on the graph.

syms x
y = 2*x^3 + 3*x^2 - 12*x + 17;   % defining the function
ezplot(y, [-2, 2])

MATLAB ejecuta el código y devuelve el siguiente gráfico:

Aquí está el código equivalente de Octave para el ejemplo anterior:

pkg load symbolic
symbols

x = sym('x');
y = inline("2*x^3 + 3*x^2 - 12*x + 17");

ezplot(y, [-2, 2])
print -deps graph.eps

Next, let us compute the derivative.

g = diff(y)

MATLAB ejecuta el código y devuelve el siguiente resultado:

g =
   6*x^2 + 6*x - 12

Aquí está el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

Octave ejecuta el código y devuelve el siguiente resultado:

g =
   -12.0+(6.0)*x+(6.0)*x^(2.0)

Let us solve the derivative function, g, to get the values where it becomes zero.

s = solve(g)

MATLAB ejecuta el código y devuelve el siguiente resultado:

s =
   1
   -2

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)
roots([6, 6, -12])

Octave ejecuta el código y devuelve el siguiente resultado:

g =

-12.0+(6.0)*x^(2.0)+(6.0)*x
ans =

  -2
   1

This agrees with our plot. So let us evaluate the function f at the critical points x = 1, -2. Podemos sustituir un valor en una función simbólica usando el subs mando.

subs(y, 1), subs(y, -2)

MATLAB ejecuta el código y devuelve el siguiente resultado:

ans =
   10
ans =
   37

A continuación se muestra el equivalente en octava del cálculo anterior:

pkg load symbolic
symbols

x = sym("x");
y = 2*x^3 + 3*x^2 - 12*x + 17;
g = differentiate(y,x)

roots([6, 6, -12])
subs(y, x, 1), subs(y, x, -2)

ans =
   10.0
ans =
   37.0-4.6734207789940138748E-18*I

Por lo tanto, los valores mínimo y máximo de la función f (x) = 2x ³ + 3x ² - 12x + 17, en el intervalo [-2,2] son ​​10 y 37.

Resolver ecuaciones diferenciales

MATLAB proporciona dsolve comando para resolver ecuaciones diferenciales simbólicamente.

La forma más básica del dsolve El comando para encontrar la solución a una sola ecuación es

dsolve('eqn')

donde eqn es una cadena de texto utilizada para ingresar la ecuación.

Devuelve una solución simbólica con un conjunto de constantes arbitrarias que MATLAB etiqueta C1, C2, etc.

También puede especificar las condiciones iniciales y de contorno para el problema, como una lista delimitada por comas siguiendo la ecuación como -

dsolve('eqn','cond1', 'cond2',…)

Con el fin de utilizar el comando dsolve, derivatives are indicated with a D. Por ejemplo, una ecuación como f '(t) = -2 * f + costo (t) se ingresa como -

'Df = -2*f + cos(t)'

Las derivadas superiores se indican siguiendo a D por el orden de la derivada.

Por ejemplo, la ecuación f "(x) + 2f '(x) = 5sin3x debe ingresarse como -

'D2y + 2Dy = 5*sin(3*x)'

Tomemos un ejemplo simple de una ecuación diferencial de primer orden: y '= 5y.

s = dsolve('Dy = 5*y')

MATLAB ejecuta el código y devuelve el siguiente resultado:

s =
   C2*exp(5*t)

Tomemos otro ejemplo de una ecuación diferencial de segundo orden como: y "- y = 0, y (0) = -1, y '(0) = 2.

dsolve('D2y - y = 0','y(0) = -1','Dy(0) = 2')

MATLAB ejecuta el código y devuelve el siguiente resultado:

ans =
   exp(t)/2 - (3*exp(-t))/2