Notebook de introducción.

Introducción al uso de Mathematica
(Curso de Aplicaciones Informáticas para la Química)

Para ver el contenido de cada sección haga "click" dos veces en el corchete azul situado en el extremo derecho de la misma

INNOVACIÓN EDUCATIVA: Extracto Guía Docente 2008-09

En la Guía Docente de la asignatura "Aplicaciones Informáticas para la Química" para el curso 2008-2009 se establecen Contenidos Mínimos y Destrezas a adquirir relacionadas con Mathematica.  Todas ellas (y muchas otras) pueden adquirirse a partir de la información  contenida en este documento, si bien en algunos casos puede ser necesario realizar ejercicios adicionales similares a los ejemplos propuestos.

Contenidos mínimos

1.	Conocer la sintaxis básica del manipulador algebraico (MA) para funciones, expresiones, listas y operadores..
2.	Saber representar una función de una variable con el MA.
3.	Saber representar una lista de puntos con el MA.
4.	Saber resolver una ecuación de una variable con el MA.
5.	Saber resolver un sistema de ecuaciones de varias variables con el MA.
6.	Saber calcular derivadas explícitas de una variable con el MA.
7.	Saber calcular integrales de una variable con el MA.

Destrezas

1.	Aprender las normas de uso básicas del manipulador algebraico(MA).
2.	Aprender las normas de sintaxis básicas del manipulador algebraico(MA).
3.	Saber buscar información en la ayuda del programa tipo MA.
4.	Saber reconocer mensajes de error y de advertencia en el MA.
5.	Saber manipular expresiones algebraicas y trascendentes básicas.
6.	Saber sustituir una expresión en otra (operador sustitución)
7.	Aprender a usar el manipulador para resolver ecuaciones y sistemas de ecuaciones.
8.	Aprender a usar el manipulador para derivar e integrar funciones.
9.	Aprender a usar el manipulador para realizar operaciones básicas con vectores y matrices.
10.	Aprender a usar el manipulador para realizar de forma controlada representaciones gráficas de funciones.
11.	Saber representar dos funciones de una variable en el mismo gráfico con el MA

Notas preliminares

Estas notas son un brevísimo resumen de algunas de las funciones, comandos y operaciones que Mathematica puede realizar. Su finalidad es ayudarle a comprender primero y recordar después la forma en que trabaja  Mathematica .  Mathematica usa sus propios convenios de programación, pero muchos de ellos son reglas que, una vez aprendidas para un comando concreto,  se pueden usar en muchos otros contextos diferentes. Cuanto más trabaje con Mathematica más fácil le resultará seguir haciéndolo porque aprenderá más pautas de trabajo que se aplican del mismo modo en contextos diferentes.

Uso de los "notebook" de Mathematica

El "kernel" y el "notebook"

Mathematica consta de dos aplicaciones diferentes. Una de ella, llamada kernel (núcleo) es la que opera y resuelve los problemas matemáticos. La otra, es la interfaz con el usuario (o sea, con Ud.). Si la interfaz es de tipo gráfico, en formato de ventanas, se denomina notebook, (bloc de notas).  El notebook se organiza en celdas ("cells"). Cada celda se reconoce por el símbolo azul en forma de corchete situado en el extremo derecho del "notebook". Dicho corchete individualiza las celdas, marca su extensión y señala alguna de las propiedades de la celda.

Las celdas como ésta que está Ud. leyendo son de tipo Texto y en ellas no se puede operar. Las celdas en las que se puede operar son celdas tipo Input. Mathematica da sus respuestas en celdas tipo Output. En éste documento (si no cambia Ud. el estilo del mismo) las distinguira facilmente por su color de fondo. Toda celda nueva es de tipo Input por defecto.

Mathematica actúa como un intérprete informático. Cada vez que se le proporciona información escrita en una celda de tipo Input y se pulsa Mayúscula+"Enter" (Shift+Enter) o la tecla  "Intro" del teclado numérico,  Mathematica trata de interpretar lo que se ha escrito y ejecutar las instrucciones. Si no puede ejecutarlas, o no las entiende, escribe un mensaje tratando de explicar que dificultad ha encontrado. A veces escribe mensajes de "warning" para avisarle de posibles fuentes de error , pero que no impiden que Mathematica haya ejecutado la o las operaciones solicitadas. Entenderá esto facilmente  en cuanto empiece a trabajar en la sección siguiente.

Las celdas de tipo texto no son interpretadas, y por lo tanto son tratadas por el programa como comentarios.

Cuando Ud. arranca Mathematica sólo arranca el módulo de "interfaz". Cuando ejecute el primer input, arrancará el "kernel". Por ese motivo notará que  la primera operación, aunque sea una operación muy sencilla, siempre tarda un poco más que las demás.

El comando ";"

Una celda de input puede contener varios comandos. Cada vez que se pulsa "Enter" se salta a la línea siguiente y comienza otro comado. Mathematica producirá una celda de "output" por cada comando, de modo que una celda de input puede originar varias celdas de output.  Recuérdese que los comandos no se ejecutarán hasta que no se pulse Mayúsculas+Enter estando el cursor situado en la celda de input. No importa donde este el cursor dentro de la celda de input. Todos los comandos que contiene se ejecutaran por orden cuando se pulse Mayúsculas+Enter.

Si por alguna razón se desea que un comando u operación en el "input" se ejecute pero su "output" no se escriba, basta añadir un   ;   al final del mismo.

NOTA: Esta opción es muy útil porque algunos comandos producen "outputs" muy largos o poco interesantes cuando ya se conoce un  poco más de Mathematica. En este "notebook" no se ha hecho apenas uso del comando "; " por razones pedagógicas. En ocasiones los "outputs" que obtendrá quizás le resultarán algo repetitivos. Conforme vaya Ud. progresando le resultará interesante utilizar el ; al final de algunas líneas de input. Hay algunos casos excepcionales, relacionados con comandos que no generan un "output" estándar, como el comando Print[ ], en que el comando ";"  no actua.

El comando "%"

El caracter % usado en una celda de input representa el "output" del último comando ejecutado en la misma sesión. 
Se observará que cada vez que se ejecuta una celda, Mathematica iguala cada "input" a un símbolo In[n] donde n es un número de orden de ejecución.  Los diferentes "outputs" que se generan también aparecen igualados a símbolos de forma Out[n].  El caracter % representa el último Out[n] disponible, aquel que tiene el número n más alto en la sesión en la que se está.

ATENCION: El número n en Out[n] no depende de la posición que ocupa la celda en el "notebook" sino del orden temporal en que se ejecutan las instrucciones de "input". % equivale al "ultimo output" en el tiempo. Las celdas borradas no alteran los valores de "n" y siguen "existiendo" en la memória de la sesión. Si se tienen varios notebooks abiertos en la misma sesión, % corresponde al "ultimo output" en el tiempo independientemente de en qué "notebook" se ejecutó.
NOTA: La misma nota indicada arriba para el comando ";" puede aplicarse al comado "%". En este "notebook" se ha evitado usar este comando por razones pedagógicas pero es muy útil en sesiones interactivas y Ud. se acostumbrará a su uso facilmente. El uso de % debe moderarse si se pretende crear "notebooks" que actuen como programas (por ejemplo, para ser ejecutados de nuevo en sesiones diferentes) a no ser que se asegure la secuencia temporal de los comandos a ejecutar.

Cálculos aritméticos con Mathematica

Calculadora de sobremesa:

Ejecute la celda siguiente. Para ello, haga "clic" en  cualquier lugar dentro de ella  para que el cursor quede en su interior y pulse a continuación Mayuscula+"Enter" o simplemente "intro".  Mathematica responde asignando su "input" a una función interna llamada In[n] , interpretándolo, y dando el resultado en una celda tipo "output".  Dicho resultado aparece asignado a una función interna llamada Out[n].

2 + 9 - 3

Practique la  misma forma de calcular en las siguientes celdas de "input". Observe atentamente las respuetas que obtiene.

2.5 + 9.3 - 1 - 0.001

(1/5) + (6/7)

Los operadores suma, resta, multiplicación y división son: + , -, *,   / .  El operador "elevar a una potencia" es el acento circunflejo ^
ATENCIÓN: Uno o más  espacios en blanco entre dos números es interpretado como el operador *.  Así, 45 es interpretado como el número cuarenta y cinco. En cambio  4 5 , con al menos  un espacio en blanco  entre el 4 y el 5, es interpretado como su producto, 20.
ATENCIÓN: El operador  ^  es un acento en el teclado español. Por lo tanto se escribe con dos pulsaciones sucesivas; primero se pulsa la tecla ^ y a continuación se pulsa el espaciador (espacio en blanco).
NOTA: Un texto encerrado entre " (*  "  y   " *)  "  es considerado un comentario por Mathematica aunque esté situado dentro de una celda de "input"

Obsérvense los ejemplos que siguen y comparense los resultados

4 5 +1

4*5 + 1

La división se puede representar por el operador  /  o por las fracciones introducidas por medio de la paleta. La paleta está en una ventana aparte. Si no está abierta, se abre con el menu:File:Palettes:BasicInput.  Compárense los resultados de las dos celdas de "input" que siguen.

1/9 + 1/8 + 1/7

(1/9) + (1/8) + (1/7)

Los operadores * , / prevalecen frente a los operadores + ,- . El operador ^ prevalece sobre todos ellos. Si se desea controlar exáctamente el orden en que se ejecutan las operaciones pueden usarse paréntesis curvos ( ) como es usual en matemáticas. (No use otros tipos de paréntesis, pues Mathematica les reserva otros significados).

1/9 + 1/8

1/(9 + 1/8)

(1/9) + (1/8)

(1/(9 + (1/8)))

Comparando los resultados de las celdas anteriores puede verse el interés de usar paréntesis (en fórmulas 1D) o de usar las formas fraccionarias tradicionales (fórmulas 2D)

Si ha ejecutado los ejemplos anteriores habrá observado que Mathematica, cuando trabaja con números enteros, mantiene el resultado en la forma más exacta posible. Si un resultado es 1/3 lo mantendrá así (que es un número exacto) en vez de dar el valor 0.3333... que siempre será un valor  aproximado a no ser que contuviera infinitas cifras decimales, lo que es imposible para el ordenador. Sin embargo, si las operaciones contienen como datos ("operandos") números decimales de precisión limitada, Mathematica dará el resultado aproximado (con un número limitado de cifras decimales).  Obsérvese la diferencia de resultados entre las dos operaciones que siguen. Verifique que en el segundo caso basta que uno de los tres operandos tenga un punto decimal (ni siquiera hace falta dar la primera cifra decimal) para que el resultado se obtenga en forma de número aproximado.

11/3 + 3

11.0/3 + 3

11/3 + 3.

NOTA: Mathematica trabaja siempre que puede con la precisión que le da el ordenador pero en condiciones adecuadas  puede trabajar con la precisión que se desee.  En otra sección veremos cómo se le piden las respuestas numéricas con el número de cifras decimales que se desee (siempre que el cálculo esté efectuado de forma adecuada para ello).

Compárense los resultados de estas dos operaciones y verifíquese que Mathematica admite las formas 1D y 2D de la operación "elevar a la potencia"

2^10

(2^10)

2.4^-1/ .33

2.4^(-1/ .33)

Los exponentes fraccionarios entre enteros (exponentes  racionales) también pueden representarse con los operadores (Sqrt[□]) y (□^(1/□))

NOTA: El único caso en que pueden escribirse dos operadores juntos es para escribir de forma cómoda las potencias de 10. Así, el número deAvogadro puede escribirse como 6.02214*^23  (mol^(-1)). Observese cómo lo interpreta Mathematica

6.02214*^23

Variables , Listas y Funciones predefinidas

Variables

Cualquier palabra que comienza por una letra, y se componga de letras y números (caracteres alfanuméricos) puede ser usada como variable. Pueden usarse algunos otros caracteres, pero no se recomienda su uso pues muchos caracteres tienen significados especiales en Mathematica. 
NOTA: Las funciones y variables internas o predefinidas de Mathematica son palabras comunes o conjuntos de varias palabras comunes yuxtapuestas del idioma inglés.  Comienzan siempre con una letra mayúscula. Se recomienda EVITAR el uso de mayúsculas como primera (o única) letra de las variables definidas por los usuarios.

La forma más directa de asignar valor a una variable es por medio del operador  =  . El valor atribuido asigna también el tipo de variable que es. Así,  si el valor es un número entero, la variable es considerada entera por el Mathematica; si el valor es un número con decimales, la variable es considerada real (en informática se dice que es una "variable de coma flotante"), etc..

x = 7
y = 3.75

ATENCION: Obsérvense los "outputs" de la celda anterior. Se verá que Mathematica no hace uso del operador  = en el "output" pero las variables x e y han quedado asignadas (tienen atribuido un valor) para el resto de la sesión. Así, x seguirá valiendo 7 hasta que suceda alguna de estas cosas: 1)Se cierre la sesión de Mathematica,  2)se redefina la variable  con x = valor , 3)se elimine la asignación escribiendo "x = . ",  o 4)se borre la asignación  con la función predefinida Clear[x]. Por lo tanto, el simple borrado de la celda o la simple ejecución de otras intrucciones en la misma celda tras borrar la expresión x=7 por ejemplo, NO DESASIGNARÁ la variable x.

NOTA: Para cerrar una sesión de Mathematica y abrir otra no es imprescindible "salir" del programa (menú Mathematica:Quit Mathematica).  Basta "salir" del Kernel (menú Kernel:Quit Kernel:Local) y a continuación arrancarlo de nuevo (menú Kernel:Start Kernel:Local).

Algunas  constantes bien conocidas están predefinidas en Mathematica. Véase como responde Mathematica a los siguientes "inputs"

Pi

para el número π

E

para el número e (base de los logaritmos Neperianos y de la función exponencial)

I

para la unidad imaginaria (Sqrt[-1])
Obsérvese como siempre se comienza por una letra mayúscula en las palabras que tienen significados predefinidos, aunque consten de una sola letra.

Puede operarse con las variables igual que con los números. Una vez más, un blanco entre dos variables equivale a multiplicarlas. Un número seguido de una variable tambien se interpreta como un  producto aunque no haya blanco entre ellos. Por esa razón, una variable nunca puede comenzar por un número.

x*y

x y

2  x + 2  y

Obsérvese la diferencia de la respuesta de Mathematica en estos dos casos que siguen:

2  Pi

2.  Pi

La diferencia en la respuesta se debe a que π es un valor exacto, pero en el segundo caso el valor exacto ya no tiene sentido, pues uno de los factores sólo se conoce hasta las unidades.

ATENCION: La simple yuxtaposición de dos letras no representa su producto, sino una nueva variable. Obsérvese la diferencia de respuesta de Mathematica en estos dos casos. (En este ejemplo se usa el comando " ;" que se explicó en otra sección más arriba para evitar la proliferación de celdas de output)

a = 3; b = 5;
a b
ab

Ahora procedemos a desasignar las variables x e y que se asignaron al principio de esta subseccion "Variables".  Obsérvese lo que ocurre si  operamos con ellas, después de desasignarlas.

x + y

x =. 
y =.

x + y

Listas

Una lista en Mathematica es un conjunto de objetos matemáticos separados por comas y encerrados entre llaves { , , , ... , ,}. Conforme se vaya familiarizando con Mathematica, descubrirá que éste utiliza las listas en muchas ocasiones para ofrecer resultados y en otras situaciones. Entre otros usos, Mathematica se vale de las listas para trabajar con vectores y matrices.

lista1 =  {1, 3, 7}
lista2 = {a, b, c}

Obsérvense los resultados de operar con listas, o de operar números o variables con listas

3*lista1

Pi lista1

Pi {x, y, z}

lista1 + lista2

lista1*lista2

Asignar una lista a una variable, var={ , , , ..., }, como hemos hecho en los ejemplos anteriores, es muy útil, porque para referirnos al elemento n-ésimo de una lista llamada  var basta con escribir var[[n]]. De éste modo podemos referirnos a una componente concreta de un vector. Vease el ejemplo siguiente:

v = {4, 5, 7}
w = {a, b, c}

vx = v[[1]]
wy = w[[2]]

vx + wy

El producto escalar o producto punto , v.w , de los vectores v y w, se puede obtener asi:

v[[1]]*w[[1]] + v[[2]]*w[[2]] + 
      v[[3]]*w[[3]]

aunque Mathematica puede calcularlo usando el punto " . " como operador entre dos vectores (es decir, entre dos listas)

v . w

Matrices

Se pueden construir en la forma convencional de matriz (arreglo bidimensional de números o expresiones) usando la paleta "BasicInput" para generar una matriz (2x2). Para añadir columnas, basta pulsar control+, y para generar filas basta pulsar control+"enter". Para borrar una fila (o columna) entera  basta usar la tecla de borrado ("backspace") cuando esta seleccionado un elemento de la primera columna (o fila)

(({{\[Placeholder], \[Placeholder]}, {\[Placeholder], \[Placeholder]}}))

(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))

A toda matriz cuadrada le corresponde un valor numérico llamado Determinante de dicha matriz.  Se obtiene mediante la función Det[mat]

m=(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}));Det[m]

La matriz m definida en los ejemplos anteriores es singular (su determinante es nulo).

mat=(({{a, b, c}, {d, e, f}, {g, h, i}}))

Det[mat]

La operación de invertir una matriz utiliza el determinante de la misma. Observe atentamente el resultado de la siguiente operación:

Inverse[mat]

Para multiplicar matrices se usa el operador "." (¿Qué pasa si se utiliza el operador " * " ?)

(({{a, b}, {c, d}})).(({{p, q}, {r, s}}))

Para obtener el resultado en la notación matricial convencional (como arreglo bidimensional de numeros) en vez de obtenerlo en forma de lista, se puede usar el comando "// MatrixForm" despues de la operación

(({{a, b}, {c, d}})).(({{p, q}, {r, s}}))//MatrixForm

NOTA: La función Simplify[ ] se explica en la sección siguiente, pero su significado y su necesidad en el ejemplo que sigue le resultaran evidentes cuando ejecute las celdas.

mat  .  Inverse[mat] // MatrixForm

Simplify[mat  .  Inverse[mat]] // MatrixForm

Tablas

El comando Table[ expr, {i, i_mínimo, i_máximo}] construye una lista de valores de la expresion expr en la que los valores de i varian de uno en uno desde i_mínimo a i_máximo. Si "i" no figura en la expresion "expr" se obtienen réplicas de "expr". Si se añade el comando //TableForm el resultado se obtiene en forma de tabla. 
Pueden añadirse instrucciones adicionales {j, j_mínimo, j_máximo}...  Table[ expr, {i, i_minimo, i_máximo}, {j, j_minimo, j_máximo}...] 
Table[ expr, {i, i_mínimo, i_máximo, incre}] incrementa i entre i_mínimo y i_máximo usando "incre" como incremento

Table[i, {i, 1, 5}]
Table[a, {i, 1, 10}]
Table[(E^n), {n, -5, 5}]
Table[i a, {i, 0, 20, 2}]
Table[2 a + p,  {p, 1, 7}]
Table[{a*i + j}, {i, 1, 5}, {j, 1, 3}]

Table[i, {i, 1, 5}] // TableForm
Table[2 a + p,  {p, 1, 7}] // TableForm
Table[{a*i + j}, {i, 1, 5}, {j, 1, 3}] // TableForm

Funciones predefinidas

Mathematica dispone de un enorme conjunto de funciones matemáticas predefinidas o intrínsecas, que permiten trabajar con las dependencias funcionales más comunes.  Todas las funciones predefinidas comienzan por una letra mayúscula. Los argumentos de las funciones van siempre entre corchetes (paréntesis cuadrados). Damos una breve lista aquí, de algunas funciones muy comunes, que nos servirán de ejemplo.

Función exponencial ((e^x))

Exp[2]

Exp[2. ]

Exp[2.00000000000000000]

Funciones trigonométricas (Sin[x],Cos[x],Tan[x], ArcSin[x],ArcCos[x],ArcTan[x]).

ATENCIÓN: Obsérvese que el argumento de estas funciones se toma en radianes. Para calcular la función de un ángulo en grados, se multiplica éste por la constante  "Degree" : Sin[x Degree]

Sin[30. ]

Sin[30.  Degree]

Sin[Degree*30. ]

NOTA: "Degree" es  una constante predefinida (los radianes que corresponden a un grado sexagesimal). Observe el "output" de las celdas siguientes. La segunda usa "un truco" para obtener el valor numérico asignado a "Degree".  Hay otras formas de obtener el valor asignado a una expresión pero aún no se han explicado.

Degree

Degree * 1.

Raices cuadradas(Sqrt[x])

Sqrt[121]

ATENCIÓN: La raiz cuadrada de un número negativo da como resultado un número imaginario puro.

Sqrt[-9]

Valores absolutos (Abs[x])

Abs[-5]

Abs[-5 p]

ATENCIÓN: La función Abs[z] aplicada a un número imaginario z da como respuesta lo que se conoce como "módulo" o "valor absoluto" del número z. Si  z= a+b i  es un número complejo, su módulo es  r =(Sqrt[(a^2) + (b^2)]).  La funcion Norm[z] da también la "norma" o "valor absoluto" del número imaginario z

Abs[2 + I]

Abs[1 + 2  I]

Abs[1 - 2  I]

Norm[2 + I]
Norm[1 + 2  I]
Norm[1 - 2  I]

Logaritmo neperiano (Log[x]) y logaritmo decimal (Log[10, x]).

Log[10^5]

Log[10. ^5]

Log[10, 10^5]

NOTA: El logaritmo base a de x se calcula como Log[a,x]

Log[2, (2^6)]

Log[a, (a^(-b))]

ATENCION: El logaritmo de un número negativo da como resultado un número imaginario. Cuando se trabaja sólo con números reales (por ejemplo en Hojas de Cálculo) se suele decir que "los números negativos no tienen logaritmo".

Log[-9. ]

Función para obtener valores numéricos (N[x]).

Si se desean n cifras significativas (y Mathematica concluye que tiene sentido calcularlas) se puede usar la forma N[x, n]

N[Log[10]]

N[Log[10], 20]

N[Pi, 100]

N[1/5  + 1/3]

N[1/5  + 1/3,  20]

Se puede solicitar a Mathematica que dé el valor numérico (con seis cifras significativas) de una operación o un cálculo usando la función N de la siguiente manera, que usa el siguiente "operador" especial: "//"  . Obsérvese su uso en estos ejemplos:

1/5 + 1/3
1/5 + 1/3 //N

Exp[2] // N

Funciones definidas por el usuario

Se puede definir una función dándole un nombre arbitrario mediante la sintaxis  nombre[x_]=expr  donde nombre no puede empezar por un número y expr suele contener la variable x.  En la definición de una función se usa el símbolo " _" detrás de la variable. Este símbolo, que sólo se usa en el miembro de la izquierda, le indica a Mathematica que se trata de una variable genérica. Obsérvese la obligación de usar corchetes cuadrados despues del nombre por tratarse de una función.
NOTA: en algunos ejemplos ejecutamos un Clear[ ...] antes de definir la función para eliminar las posibles asignaciones previas que tuvieramos.

Clear[fun1, x]
fun1[x_] = x*Sin[(x^2)]

En este ejemplo, se usa otra función que llamamos deltaY  para calcular incrementos de la función y  cuando x se incrementa en 2 unidades (la función fun1[  ] que habiamos definido antes hace el papel de y en este ejemplo):

deltaY[x_] = fun1[x + 2] - fun1[x]

deltaY[1] // N
deltaY[Pi/2] // N
deltaY[Pi] // N

El ejemplo que sigue ayuda a recordar que el símbolo "_" detrás de la variable sólo se usa en el miembro de la izquierda de la definición de la función.  Obsérvese que Clear[ ] no genera output pero las otras cuatro instrucciones sí.

Clear[fun1, x]
fun1[x_] = x*2  Sin[(x^2)]
y[x_] = fun1[x]
fun1[3. ]
y[3. ]

También podría haberse escrito como sigue y el resultado es el mismo.

Clear[fun1, x]
fun1[x_] = x*2  Sin[(x^2)]
y[u_] = fun1[u]
fun1[3. ]
y[3. ]

Pueden definirse funciones de más de una variable.

Clear[f, x, y]
f[x_, y_]  =  2  x^2 + 3  y^2

f[1, 1]
f[1, 2]
f[2, 1]
f[2, 2]

El  mismo resultado en forma de lista se obtiene haciendo:

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

Otro ejemplo.

Clear[fun, x,  deltaY, h]
fun[x_]  =  (x^2)*Sin[(x^2)]
   
deltaY[x_, h_]  =  fun[x + h] - fun[x]
fun[5. ]
deltaY[a, 2. ]
deltaY[5. , 2. ]

Expresiones algebraicas

En álgebra se manipulan símbolos que representan números, combinados o no con éstos. Los símbolos son generalmente letras, aunque Mathematica puede manejar símbolos de más de una letra como todos los lenguajes de programación comunes de alto nivel. Según el papel que juegan en el problema que se trata de resolver, estos símbolos reciben en ocasiones diversos nombres (incógnitas, parámetros, coeficientes, variables dependientes, variables independientes, etc.).

Manipulación de expresiones

Un ejemplo clásico de expresión algebraica es la conocida receta "suma por diferencia igual a diferencia de cuadrados". La forma normal de trabajar con Mathematica es escribir una expresión y tratar de que Mathematica nos dé como respuesta una expresión equivalente. Ello se hace mediante la manipulación de expresiones.

Expand[ ] y Factor[  ]

Si queremos que Mathematica desarrolle la expresión que le damos, usamos el comando Expand[ ]

a =. 

    b =. 
  

    a = b =.    
   

    Clear[a, b]

Expand[(a + b) (a - b)]

Expand[  ] también puede usarse para expandir potencias o radicales

Expand[(((a + b))^5)]

Otros ejemplos...

Expand[(((a + b))^2) (((a - b))^2)]

Expand[(((a + b))^3) (((a - b))^3)]

Expand[(((a + b))^3) (((a - b))^2)]

Si queremos que Mathematica nos convierta  una expresión en productos, en la medida de lo posible, se usa Factor[  ]

Factor[(a^2) - (b^2)]

Factor[(a^4) - 2 (a^2) (b^2) + (b^4)]
Factor[
      (a^6) - 3 (a^4) (b^2) + 3 (a^2) (b^4) - (b^6)]
Factor[
      (a^5) + (a^4) b - 2 (a^3) (b^2) - 2 (a^2) (b^3) + a (b^4) + 
        (b^5)]

Obsérvese atentamente la diferencia entre estos dos ejemplos:

Factor[(a^2) - (b^2) + c]
Factor[(a^2) - (b^2)] + c

Factor[  ] puede usarse para "sacar factor común" en algunos casos

Factor[4  x y  +  6 a (y^2)]

Suma de fracciones algebraicas

Pueden sumarse fracciones algebraicas con el comando Together[  ]

Together[(a/x) + (b/(x + 1))]

Sacar factor común

La extracción de un factor común a un conjunto de términos no siempre es realizada por Mathematica como uno desea. En ocasiones el comando Factor[ ] puede servir. También es útil el comando Collect[  ] que se usa de esta manera:

Collect[a (x^2) + b x y  + a (y^3), a]

Se extrae el factor "a" (segundo argumento de Collect[  ]) de todos los términos del primer argumento que lo contienen. También se puede usar una lista como segundo argumento de Collect[ ]

expr = 
      a (x^2) + b x y  + a (y^3) + b x (y^2)
Collect[expr, {a, b}]

ATENCION: En realidad, Collect[  ] agrupa todos los términos que tienen las mismas potencias de las variables que se le indican. Por ello no siempre es facil prever qué se obtendrá: Considerese el siguiente ejemplo :

Collect[expr, {x, y}]

Substituciones: Los operadores " /. "  y  " -> "

La sustitución de una expresión por otra equivalente es una operación muy común en algebra y otras ramas de las matemáticas. 
El operador " -> " (que puede introducirse en el "input" pulsando  "menos" seguido de "mayor que" ->) indica  asignación temporal.  Mathematica llama a cada una de estas asignaciones regla de reemplazamiento (replacement rule).  El operador " -> " se usa así:    var -> expr. 
El operador " /.  " escrito detrás de una expresión hace que se apliquen a dicha expresión las asignaciones temporales (o reglas de reemplazamiento) que siguen  al operador.

Ejemplo: queremos ver qué ocurre en 4(x^3)-2(x^2)+5/x cuando x vale 3. Podemos hacer

Clear[x]

4(x^3)-2(x^2)+5/x /. x -> 3

¿Y cuando x se sustituye por -(2^(1/3))? Hacemos

4(x^3)-2(x^2)+5/x /. x -> (2^(1/3))

¿Y cuando x se sustituye por (z^2)/5? Hacemos

4(x^3)-2(x^2)+5/x /. x -> ((z^2)/5)

ATENCIÓN: Obsérvese que despues de cada sustitución no ha quedado asignado ningún valor ni expresión a x. Puede verificarse ejecutando la siguiente celda de "input":

x

Si  hubieramos hecho en cambio

x = ((z^2)/5)
4(x^3)-2(x^2)+5/x

obtendriamos el mismo valor que antes para la expresión sustituida, pero ahora x tiene un valor asignado "permanente" por haber usado el operador " = "

x

Pero además, y como consecuencia de ello, la expresión completa que dependia de x ha quedado también con un valor fijo asignado, como puede verificarse "ejecutando" el "input" siguiente

4(x^3)-2(x^2)+5/x

Recuperamos la expresión como era, sin valor prefijado de x si desasignamos x

x =.      
4(x^3)-2(x^2)+5/x

Pueden hacerse varias sustituciones en una etapa usando listas:

Clear[a, b]
(a^2) + (b^2)   /.  {a -> Cos[α], 
        b -> Sin[α]}

Pueden realizarse aplicaciones sucesivas del operador "/." . Mathematica aplica las sustituciones progresivamente empezando por la izquierda. Compare los resultados de estas dos secuencias:

a /. a -> b /. b -> c

a /. b -> c /. a -> b

En este segundo caso la primera sustitución (yendo de izquierda a derecha) no produce ningún efecto, sólo puede producirlo la segunda. En el primer caso producen efecto las dos substituciones.

Simplify[] y FullSimpliy[]

Podriamos esperar que el resultado de la operación (a^2) + (b^2)   /.  {a -> Cos[α], 
          b -> Sin[α]} efectuada antes fuera 1 pues la suma del cuadrado del seno y del coseno del mismo ángulo es la unidad. Este resultado se consigue pidiendole a Mathematica que simplifique mediante el comando Simplify[ ]

Simplify[
      (a^2) + (b^2)   /.  {a -> Cos[α], 
          b -> Sin[α]}]

En ocasiones Simplify[ ] se nos queda corto y puede pedirse a Mathematica que lo siga intentando con más alternativas con FullSimplify[ ]

Asignación y sustitución diferidas ("delayed"): Operadores " := " y " :> "

En ocasiones puede convenir que una asignación o una sustitución no sean efectivas hasta que no se ejecute el comando donde son necesarias. Esto se puede conseguir usando los operadores " := "  y " :> "

NOTA: el operador " :> " también puede escribirse " :> "

Ejemplo de asignación diferida:

Asignamos un valor a x

Clear[x]
x = 3

Asignamos ahora dos expresiones, una con " = " y otra con " := "

ex1 = x^3

ex2 := x^3

Verifiquemos ahora los valores de ex1 y ex2

ex1

ex2

Ahora reasignamos x

x = 5

Verifiquemos de nuevo ahora los valores de ex1 y ex2

ex1

ex2

Se puede ver que el valor de ex1 quedó fijado por el " = " mientras que el valor de ex2 "se adapta", cada vez que se ejecuta, a la nueva asignación de x. Obsérvese como la asignación diferida con " :> " no generó "output" mientras que la asignación ordinaria, con " = ", si lo generó.

Ejemplo de regla de sustitución diferida

NOTA: El uso de " :> " puede considerarse una utilidad avanzada. Puede ser una buena idea saltarse este ejemplo la primera o las primeras veces que se trabaje este documento, si no se está familiarizado con Mathematica.

La sustitución diferida puede ser interesante cuando la regla de sustitución es un poco complicada. En el ejemplo que sigue, definimos una regla de sustitución en forma de función. Si usamos el operador " ->" la instrucción Together[ ] incluida en la regla de sustitución se ejecuta inmediatamente. Si usamos " :> " se ejecutará cuando se aplique con el operador  "  /. "

f[u_] -> Together[(1/u) + (1/(u + 1))]

g[u_] :> Together[(1/u) + (1/(u + 1))]

g[r + 1] /. 
      g[u_] :> Together[(1/u) + (1/(u + 1))]

Solución de ecuaciones. El comando Solve[  ] . El operador ==

Ecuaciones de 1º, 2º, ... , nº grado

Un polinomio en x , (o forma polinomial en x) que podemos notar como P(x), es un conjunto de términos sumados en los que la variable x aparece sucesivamente elevada a las potencias 0, 1, 2,3,...,n. (Pueden faltar o no algunas de ellas). La potencia más alta nos da el orden del polinomio. Los polinomios de orden cero son constantes. Los de orden uno, son lineales (corresponden a lineas rectas). Los de orden dos, son cuadráticos (corresponden a parábolas). Los de orden 3, cúbicos, etc...
El problema algebraico por excelencia es la resolución de ecuaciones de tipo P(x )=0.

NOTA: véase que P(x) representa una expresión genérica. Por lo tanto, tanto la expresión general  P(x) = a donde "a" es una constante como la expresión general P(x)=Q(x) (donde Q(x) es cualquier forma polinomial en x),  siempre pueden escribirse con la expresión genérica P(x)=0 pues P(x) representa "cualquier polinomio" y no un polinomio en particular. Por citar un ejemplo concreto, tanto
4(x^3)-2x = 5(x^2)-6   como  4(x^3)-2x-5(x^2) = 6 son expresiones que pueden escribirse como  4(x^3)-2x-5(x^2)-6=0 y por tanto representarse por P(x) = 0.

El comando para resolver ecuaciones es Solve[ ]. Asi, para resolver 4x+7=0 se escribe

Clear[x]
Solve[4  x + 7 == 0, x] // N

(Se añade //N para obtener el resultado numérico en forma decimal)

Obsérvese que 
1) Al escribir la ecuación se usa un doble igual ==  en vez de uno solo. La razón de ésto se comenta más abajo.
2) Mathematica da el resultado en forma de "regla de sustitución" o asignación temporal {x->-1.75}.  Ésto facilita su uso, por ejemplo, para verificar que la solución es correcta

4  x + 7  /.  x -> -1.75

No es necesario que la ecuación esté en la forma canónica, con todos los términos agrupados (es decir, cumpliendo estrictamente la forma P(x)=0). Véanse estos ejemplos

Ecuaciones lineales o de primer grado

Solve[4  x + 3 == -4, x] // N

Solve [6 + 3  x == 2  x + 8  x + 1] // N

¿Por qué se usa == en vez de = en el comando Solve?
En una ecuación, el signo igual NO AFIRMA que el miembro de la izquierda es igual al de la derecha siempre y bajo cualquier circunstancia . En una ecuación  la igualdad entre los miembros ES UNA CONDICIÓN, no es una asignación permanente. Por eso, Mathematica exige que se pongan dos signos igual seguidos  == .   Se trata de un operador de condición. Si se pusiera un signo = significaría que para cualquier valor de x, el miembro de la izquierda es igual al de la derecha. Esto no es así en una ecuación. Sólo es cierto para los valores de x que resuelven la ecuación. Esos valores privilegiados de x que hacen verdadera la CONDICION son las "raices" o "soluciones" de la ecuación.  El comando Solve[ ] es una intrucción que puede interpretarse como "busca que valores de la variable x hacen que la condición 
expr1== expr2
 sea verdadera".

Ecuaciones no lineales: Veanse estos ejemplos

Solve[a (x^2) + b x + c == 0, x]

Solve[2  x + 3.2  (x^3) - (x^5) == 0, x]

ATENCION: Algunas o todas las raices de una ecuación no lineal pueden ser números complejos. Si todas las raices son imaginarias, se dice que la ecuación "no tiene soluciones reales". Vease el ejemplo siguiente:

Solve[5  (x^2) + 2 x + 3 == 0, x] // N

Despejar una variable

Solve[ ] es la función de Mathematica que nos permite obtener una variable o constante expresada en función de todos los demas objetos presentes, cuando ello es posible.

Solve[F == G (( m M)/(R^2)), G]
Solve[F == G (( m M)/(R^2)), R]

Solve[T == 2  π (Sqrt[ (L/g)]), g]

Solve[(x^2) + x y + (y^2) == 4, x]

Obsérvese, sin embargo, que Solve[ ] tiene algunas limitaciones si se quiere usar para "despejar". Por ejemplo, si queremos "despejar" el producto m M en este ejemplo:

Solve[F == G (( m M)/(R^2)), m M]

nos encontramos con un aviso de error:    "General::ivar: m M is not a valid variable".  A veces, especialmente en Física, Química, Ingeniería... es conveniente por razones de notación, agrupar las variables. El procedimiento recomendado en estos casos puede ser agrupar previamente las variables que nos interesan. Por ejemplo

Solve[F == G  (mporM/(R^2)),  mporM]

Solve[mporM /. mporM -> m M == ((F (R^2))/G), M ]
Solve[mporM == ((F (R^2))/G) /. mporM -> m M, M ]

OBSERVESE: La operación de sustitucion   "/. mporM->m M" se ha introducido "dentro" de un  miembro la condición   == para que se ejecute antes que Solve[ ].

Otra manera de agrupar variables es escribir sobre el grupo una barra (con ayuda del icono correspondiente en la paleta "BasicInput"

\(Solve[F == G \( m\ M\)\&_\/R\^2, \(m\ M\)\&_]\)

Se escribe ahora la ecuacion sin agrupar las variables (sin usar la barra superior)

Solve[m M == ((F (R^2))/G), M ]

Los procedimientos que se acaban de describir no siempre son fáciles o cómodos de aplicar. Si, en el ejemplo que estamos usando,  nos interesa especialmente el cociente M/R, probablemente sea mejor definir una variable var=M/R  y escribir desde el principio las expresiones físicas con las variables m, var y R en vez de m, M y R.

Otras ecuaciones

Solve permite intentar encontar algunas de las soluciones de ecuaciones trascendentes, no puramente algebraicas.

Solve[Sin[4  x] == Pi, x]

Solve[y Log[(Sqrt[x ])] == 5, x]

El comando Reduce[   ] puede usarse en lugar de Solve en estos casos, pero la respuesta obtenida puede ser muy complicada porque considera todas las ramificaciones posibles de la solución

Reduce[Sin[4  x] == Pi, x]

Se obtiene como "output":

C[1] ∈ 
        Integers && (x == 
            (1/4) (π - ArcSin[π] + 2 π C[1]) || 
          x == (1/4) (ArcSin[π] + 2 π C[1]))

El output anterior se lee: "La constante C[1] es entera y  x equivale a  (1/4) (π - ArcSin[π] + 2 π C[1] ) o bien equivale a (1/4) (ArcSin[π] + 2 π C[1])", todo lo cual indica que hay varias soluciones a la ecuación planteada.

Sistemas de ecuaciones

El comando Solve[ ] también puede resuelve sistemas de ecuaciones.

Solve[{3  x + 2  y == -1, 2  x + 5  y == 3}, {x, 
        y}]

En el ejemplo que sigue puede verse la diferencia de respuesta entre las soluciones exactas y las soluciones aproximadas que se obtienen con   //N

Solve[{3  (x^2) + 2  y == -1, 
        2  x + 5  y == -3}, {x, y}]

Solve[{3  (x^2) + 2  y == -1, 
          2  x + 5  y == -3}, {x, y}] // N

Eliminate[ ]

Al igual que sucede en el método de resolución de sistemas de ecuaciones por eliminación, el comando Eliminate[ecuaciones, var] permite eliminar la variable var entre las ecuaciones dadas:

Eliminate[{x + y == a, x y == b}, y]

Solución numérica de ecuaciones

En ocasiones, sobre todo al resolver problemas con datos físicos, químicos, etc., se necesita obtener los valores numéricos de las soluciones de una ecuación. Mathematica usa para buscar numéricamente las raices una variante del método de Newton-Raphson implementada en el comando FindRoot[  ] .

Es necesario dar siempre un valor inicial a la variable (este hecho es común a todos los métodos numéricos de solución).

g[x_] = 3  (x^2) - (Sqrt[x + 2])

FindRoot[g[x] == 0, {x, -1}]
FindRoot[g[x] == 0, {x, 2. }]

Los valores -1 y 2. indican valores iniciales. Obsérvese que valores iniciales diferentes pueden conducir a encontrar raices diferentes .

En ocasiones es necesario aumentar la precisión con que trabaja Mathematica para obtener las raices. Esto se puede conseguir añadiendo opciones al comando FindRoot[  ]. Las opciones se añaden dentro de los corchetes y tienen la forma de "reglas de reemplazamiento" o asignaciones temporales:  Opcion -> valor

Las opciones requeridas en este caso son AccuracyGoal y WorkingPrecision.

Clear[g, x]
g[x_] = Sin[8  x] + x
FindRoot[g[x], {x, 0.7}, AccuracyGoal -> 30, 
      WorkingPrecision -> 35]

Representación y ajuste de curvas

Representación de listas de puntos

Una lista de puntos (x,y) se representan mediante la funcion ListPlot[  ].
Conviene crear una lista de pares de valores {x,y} y darle nombre.

datos1 = {{2, 4.1}, {4, 6.5}, {7, 10.2}, {8, 12.9}, {10,  
          15.0}}

ListPlot[datos1]

Las opciones siguientes...              		 permiten...
PlotRange -> {{xmin,xmax},{ymin,ymax}}	: seleccionar el intervalo de las x y las y que se quiere representar.
PlotJoined->True				: unir los puntos representados con lineas rectas
Prolog->AbsolutePointSize[n]			: Representar puntos de tamaño controlado por n  
PlotStyle ->RGBColor[a,b,c]			: Elegir el color de los puntos. Para  introducir el color, puede usar el menu input:Color Selector

ListPlot[datos1, PlotRange -> {{0, 12}, {-1, 20}}, 
      Prolog -> AbsolutePointSize[5],  
      PlotStyle -> RGBColor[1,  0.489998,  0.149996]]

ListPlot[datos1, PlotRange -> {{0, 12}, {-1, 20}}, 
      PlotJoined -> True]

Representación de funciones: Plot[  ]

Para representar una o más funciones sobre un intervalo común de valores de la abscisa se usa la función Plot[ ]. Esta función admite muchas opciones para cambiar diferentes aspectos del gráfico que se genera con las opciones "por defecto" o predefinidas en Mathematica.  Se recomienda consultar el capítulo "Graphics Directives and Options" del "Help Browser" de Mathematica 4.0 (sección 2.10.3 del Mathematica Book ("Help Browser" de Mathematica 5.0)  para obtener una descripción detallada de los mismos. La sección 1.9.2 también es de interés.

Son de uso relativamente frecuente, aparte de 
PlotRange -> {{xmin,xmax},{ymin,ymax}}
las opciones 
PlotStyle -> {Thickness[n]}  y   PlotStyle -> {RGBColor[r,g,b]} para controlar el grosor y color de las lineas.
PlotStyle -> {Dashing[{n , m ...}]}   controla el trazado como líneas discontinuas, con trazos de longitud n, m ... alternados

Plot[Exp[-x], {x, -1, 6}]

Plot[Exp[-x], {x, -1, 6},  
      PlotStyle -> {Thickness[0.005], Dashing[{0.01, 0.01}]}]

Plot[{Exp[-x], Exp[-0.5 x], Exp[-0.1 x]}, {x, -1, 
        6}]

Para superponer en una misma gráfica varias funciones, con diferentes opciones de representación (colores, trazo...) se pueden usar listas de funciones y listas de opciones, como en el ejemplo siguiente:

Plot[{Exp[-x], Exp[-0.5 x], Exp[-0.1 x]}, {x, -1, 6}, 
      PlotStyle -> {RGBColor[1,  0,  0], RGBColor[0,  1,  0], 
          RGBColor[0,  0,  1]}]

Otra forma de superponer gráficas es usar el comando Show[ ]

graf1 = 
      Plot[Exp[-x], {x, -1, 6}, 
        PlotStyle -> {RGBColor[1,  0,  0]}]
graf2 = 
      Plot[Exp[-0.5 x], {x, -1, 6}, 
        PlotStyle -> {RGBColor[0,  1,  0]}]
graf3 = 
      Plot[Exp[-0.1 x], {x, -1, 6}, 
        PlotStyle -> {RGBColor[0, 0, 1]}]
Show[graf1, graf2, graf3]

Obsérvese que Mathematica puede representar situaciones de discontinuidad:

Plot[Tan[x Degree], {x, 0, 360}]

Para representar funciones de más de una variable, se usa el comando Plot3D[ ]

Clear[z]
z[x_, y_] = x y Sin[2  x y]
Plot3D[z[x, y], {x, 0, 20}, {y, -5, 5},  
      PlotPoints -> 40]
 (* PlotPoints no debe ser muy grande porque se calculan,  
      al menos,  
      (PlotPoints^2) valores de la función.  *)

Ajuste de listas de puntos: Fit[  ] y Regress[ ]

Fit[ ]

Si se quiere obtener una curva contínua que represente el comportamiento funcional de un conjunto de puntos discretos conocidos (x,y),  puede obtenerse una función proporcionada por un  ajuste lineal por mínimos cuadrados . Para ello se usa la función Fit[ ] .

\(\(\( (*\ 
      Volvemos\ a\ definir\ la\ lista\ "datos1"\ *) \)\(
\)\(Clear[datos1]

    datos1 = {{2, 4.1}, {4, 6.5}, {7, 10.2}, {8, 12.9}, {10, \ 
          15.0}}

    ajuste = Fit[datos1, \ {1, x}, x]\)\)\)

NOTAS:
1.- Al resultado se le ha dado el nombre "ajuste". Observese que equivale a una expresión que depende de la variable x indicada en el tercer argumento de Fit[..., ..., x]
2.-El segundo argumento de Fit es una lista de funciones: {1,x}. En este caso el resultado será una recta que NO pasa por el origen.
	Otros ejemplos serian:  {x}  		: Recta que pasa por el origen
				{1,x,(x^2)}	: Polinomial  cuadrática (parábola)
				{1,x,(x^2),(x^3)}	: Polinomial cúbica
				 {1,(x^2),(x^3)}	: Polinomial cúbica sin término lineal.

Se puede representar la función ajuste mediante la función Plot[ ]

grafAjuste = 
      Plot[ajuste,  {x, -3, 15}, 
        PlotRange -> {{0, 12}, {-1, 20}}]

OBSERVESE: podría haberse definido la función "ajuste" de esta manera

Clear[ajuste]
ajuste[x_] = Fit[datos1,  {1, x}, x]

Ahora puede obtenerse el valor "ajustado" para cualquier valor arbitrario de x, incluidos los valores usados en la lista datos1

ajuste[5. ]
ajuste[8. ]
ajuste[16. ]

El valor para x = 5. es un valor INTERPOLADO (corresponde a un valor de x comprendido entre aquellos usados en datos1)
El valor para x=8. nos permite comparar el valor de y "ajustado"  con el valor de y "usado como dato" en datos1
El valor para x=12. es un valor EXTRAPOLADO (corresponde a un valor de x no comprendido entre aquellos usados en datos1)

Para representar juntos los datos y el ajuste, se usa la función de superponer gráficos: show[ ].
Para ello, es útil repetir el ListPlot[ ] que se hizo antes asignándolo a un nombre

grafDatos = 
      ListPlot[datos1, PlotRange -> {{0, 12}, {-1, 20}}, 
        Prolog -> AbsolutePointSize[5]]

Show [grafAjuste, grafDatos]

Regress[ ]

La función Fit[ ] da como respuesta una función de ajuste pero no da datos estadísticos adicionales sobre la calidad del ajuste. Si se necesita más información sobre la calidad del ajuste debe usarse la función Regress[ ], que tiene la misma sintaxis que Fit[ ] . 
ATENCIÓN: Antes de usar la función Regress[ ] hay que ampliar las capacidades estándar de Mathematica añadiendo el "paquete de programas" de regresión. Esto se hace con el comando   <<Statistics`LinearRegression`  , tal como se muestra a continuación. 
 (La información sobre los "paquetes de programas" que permiten ampliar las capacidades de Mathematica se encuentra en la ayuda en línea ("Help browser") bajo la denominación inglesa de "Add-ons")

<< Statistics`LinearRegression`

Fit[datos1,  {1, x}, x]    
Regress[datos1,  {1, x}, x]

Algunos resultados de Regress[ ] son: 
  "Estimate" da los coeficientes de cada término (compárense con los resultados de Fit [ ]).
SE ("Standard error" de la muestra) puede usarse como error absoluto asociado a cada coeficiente
RSquared es el "coeficiente de regresión" al cuadrado. El ajuste es mejor cuantos más "nueves" tiene.

Derivación e Integración

Derivadas parciales y totales

Es necesario recordar que sólo se puede derivar una función respecto de sus variables independientes. En funciones de una variable, sólo se puede derivar respecto a dicha variable.

Mathematica no sabe "a priori" qué objetos de una expresión son variables independientes, constantes físicas o numéricas, parámetros definidos para un problema particular, etc. Por ello, Mathematica contempla dos operadores para derivar: la derivada parcial: D[expr, var ] y la derivada total: Dt[expr]. La derivada parcial también puede representarse como (∂_var) expr (es decir, derivada de la expresión expr considerada como una función de la variable var)

D[Exp[-k x], x]

D[Exp[-k x], k]

D[k (x^2), x]

D[(a/((b^2) + x)), x]

En el ejemplo siguiente derivamos respecto a diferentes "variables". Mathematica necesita que le indiquemos respecto a qué variable queremos derivar. El resto de expresiones, salvo que estén predefinidas para Mathematica, son consideradas como constantes a efectos de la operación de derivar.

Clear[f, x, y, b]
f = x y + b (x^2)

D[f, x]
D[f, y]

Veamos ahora el efecto de una derivación total en una función

Clear[z, x, y]
z = x y     
Dt[z]

ATENCION: Observese que lo que se ha obtenido con Dt[z] es lo que se denomina "diferencial de la función z". Si tenemos una función z=f(x,y), el diferencial de z , dz, es igual a dz=(∂ (z/∂)x) dx + (∂ (z/∂) y) dy.   Mathematica usa el símbolo Dt[var] para indicar el diferencial de la variable  "var" dependiente o independiente. No siempre es fácil obtener  una expresión de dz como la anterior. El comando Collect[ ] visto en una sección anterior puede ser útil para ello. Vease este ejemplo

Clear[f, x, y]
f = (x^3) + Sin[x y]

Dt[f]

Collect[Dt[f], {Dt[x], Dt[y]}]

D[f, x]

D[f, y]

Derivadas implícitas

En ocasiones se necesita calcular la derivada de y respecto de x existiendo una relación entre x e y que no está (o no puede ponerse) en la forma y=f(x). Por ejemplo, sea    (x^2)+x y +(y^2)=4  y queremos obtener ((d y)/(d x)). En este caso, se le indica a Mathematica que y depende de x escribiendo " y[x]"  en la expresión a derivar. Vease el ejemplo siguiente

D[(x^2) + x y[x] + (((y[x]))^2), x]

En el "output" que nos da Mathematica aparece la expresión y'[x] que representa  la solución buscada (véase la NOTA más abajo). Para despejarla,  resolvemos la ecuación igualando a cero usando y'[x] como incógnita. (Podemos igualar a cero porque el miembro de la derecha en la expresión que queremos derivar, (x^2)+x y +(y^2) = 4 ,   es una constante que vale 4 y su derivada respecto a cualquier variable es cero)

Solve[2 x+y[x]+x y'[x]+2 y[x] y'[x]==0,y'[x]]

Obsérvese que podríamos haber derivado la ecuación  (x^2)+x y +(y^2) = 4  (recuérdese que en el input debe ponerse == en vez de =)

D[(x^2) + x y[x] + (((y[x]))^2) == 4, 
      x]
Solve[%,  y'[x]]

NOTA: Cuando sólo hay una variable, Mathematica reconoce la notación tradicional f'(x) para referirse a la derivada de f(x) respecto de x.

Integrales

Integral indefinida

Mathematica es capaz de calcular un gran número de integrales. La integración indefinida tiene lugar de forma simbólica

Clear[x]
fun = a (x^2) + b (Sqrt[x]) + 1/x

Integrate[fun, x]

ATENCIÓN: Mathematica no añade por su cuenta la constante indeterminada de integración que forma parte de la solución de toda integral indefinida. Recuérdese que en la forma de trabajar que usa Mathematica se suele manejar sólo una expresión cada vez sin tener en cuenta a qué pueda ser igualada o para qué pueda ser utilizada esa expresión por el usuario. Muchas veces Mathematica proporciona "sólo" una o alguna de las respuestas posibles. Las respuestas siempre son correctas, pero pueden no ser las únicas. Este es uno de los casos en que ocurre ésto.

Integral definida

La integral definida requiere límites de integración para la variable. Cuando los valores no son numéricos, el "output" de la integración puede ser  muy complicado a causa de las numerosas ramificaciones que puede ofrecer el análisis de los casos posibles.

Clear[fun, x]
fun = 1/x

(∫_2^7) 
        fun \[DifferentialD]x 
% // N

Integrate[fun,  {x, a, b}]

El cálculo anterior puede dar lugar a una respuesta complicada. La opción "Assumptions" ayuda a simplificar el resultado
NOTA: En ocasiones, el procesado de los casos posibles puede requerir bastante tiempo

Integrate[fun,  {x, a, b},  
      Assumptions  -> {a  ∈  Reals, b  ∈  Reals, 
          x  ∈  Reals}]

Integrate[(fun^2),  {x, a, b}]

Integración numérica

En ocasiones puede interesar llevar a cabo una integración definida de forma numérica. El comando NIntegrate[  ] realiza la integración definida de forma numérica.

NIntegrate[fun,  {x, 2, 7}]

Ecuaciones diferenciales

El comando para resolver ecuaciones diferenciales (aquellas en cuyos términos aparecen derivadas) es DSolve[ ].
Consideraremos aquí ecuaciones de una sola variable. 
El orden de una ecuación diferencial es el índice de la derivada de mayor índice que figura en ella. Así  y' = x + 2y  es una ecuación diferencial de primer orden, y'' + 2y' +3 y = 0, de segundo orden, etc.  La solución general de una ecuación diferencial de orden "n" contiene "n" constantes indeterminadas, que Mathematica denota como C[1], C[2], etc. 
El comando DSolve admite la notación estándar y, y' , y'' ... pero en la forma y[x], y'[x], y''[x]...
En las ecuaciones diferenciales debe usarse el doble igual, ==, tal como se hace en Solve[ ] para las ecuaciones ordinarias.
Así, la ecuación diferencial  y' = x + 2y se resuelve, usando DSolve,  de la siguiente manera. Obsérvese atentamente la notación de los tres argumentos de DSolve[ miembro_izq == miembro_der, y[var], var]

DSolve[y''[x] == x + 2  y'[x], y[x], x]

Las constantes pueden determinarse pidiendo valores concretos de la función solución

DSolve[{y''[x] == x + 2  y'[x], y[0] == 1}, 
      y[x], x]

DSolve[{y''[x] == x + 2  y'[x], y[0] == 1, 
        y[2] == -5}, y[x], 
      x]

DSolve[y''[x] == -a y[x], y[x], 
      x]
DSolve[{y''[x] == -a y[x], y[0] ==  0}, y[x], 
      x]

Una ecuación diferencial muy sencilla y muy importante en ciencia es la siguiente, que corresponde a procesos cinéticos de primer orden (la velocidad a la que decrece una población "p" es proporcional a su valor. "p" puede ser una concentración molar, una población de núcleos radiactivos, una densidad de población de insectos, etc.) El valor de "p" en t=0 es (Subscript[𝓅, 0])

DSolve[{p'[t] == -k p[t], 
        p[0] == (Subscript[𝓅, 0])}, p[t],  t]