Informática de Sistemas
Cálculo Numérico con Mathematica

Introducción a Mathematica

1. Introducción

Mathematica es un producto de Wolfrang Research Inc. pensado principalmente para realizar de forma sencilla una gran cantidad de cálculos complejos, tanto numéricos como simbólicos. Por tanto, como primera aproximación, podemos pensar que Mathematica es una calculadora extremadamente potente en donde, como en todas las calculadoras, el usuario puede introducir diferentes expresiones matemáticas y solicitar el valor de las mismas.
Sin embargo, Mathematica también dispone de suficientes recursos para implementar algoritmos por lo que puede considerarse como un pequeño compilador. Para aquellos usuarios acostumbrados a la programación encontrarán que la sintaxis utilizada es muy cercana a la familia del lenguaje C.
Finalmente, ciertas capacidades de Mathematica facilitan la creación y edición de textos científicos, por lo que también se puede decir que es un pequeño procesador de textos, un procesador que permite bastante interacción con el usuario y que lo hacen ideal para el desarrollo de prácticas de enseñanza.
El objetivo de este "notebook" o documento de Mathematica es explicar sucintamente los comandos y posibilidades más habituales de Mathematica, especialmente aquellos necesarios para desarrollar las prácticas de la asignatura de Cálculo Numérico. Como la intención de este documento es la de servir de guía rápida, las explicaciones serán necesariamente muy sucintas aunque con cierta cantidad de ejemplos. Para mayor nivel de detalle se recomienda dirigirse a la Ayuda de Mathematica (pulsar tecla [F1]) o al Manual del Usuario del programa.

2. Órdenes, Kernel y FrontEnd

El trabajo en Mathematica asume la forma de un diálogo en el que el usuario transmite órdenes a través de las celdas tipo Input, que se etiquetan con In[...], y Mathematica da respuestas etiquetadas con Out[...] en las celdas tipo Output, como se muestra a continuación.
Las órdenes se transmiten presionando la tecla [Intro] o bien, simultáneamente, las teclas [Shift][Enter].

Por ejemplo, calculamos a continuación (2^8) y la solución de la ecuación a (x^2) + b x  +  c  =  0.

(2^8)

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

Si se quiere introducir explicaciones dentro de una celda Input puede hacerse utilizando (* texto *):

(2^8)

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

En el trabajo con Mathematica se deben distinguir dos programas:
A) El FrontEnd que provee las ventanas y  áreas en la pantalla del monitor para escribir, editar y transmitir las órdenes o comandos, y mostrar las respuestas que produce Mathematica. Agrega también una serie de recursos, como paletas y menús, que facilitan el manejo del lenguaje. Es el encargado de administrar la comunicación entre el usuario y Mathematica.
B) El Kernel que es el programa encargado de reconocer y efectuar las tareas involucradas por las órdenes. Es el verdadero motor de trabajo de Mathematica.
Cuando se abre Mathematica solo se carga el FrontEnd; el Kernel no se carga hasta que se transmite la primera orden, de ahí que la primera respuesta tarda un poco más en llegar que las siguientes, aún cuando sea la respuesta a una instrucción muy simple. 
Cuando el Kernel entra en un bucle o se prolonga demasiado en sus cálculos, estos se pueden interrumpir utilizando el menú Evaluation_Abort Evaluation (teclas [Alt + .]). Si aun así tarde en detenerse se puede cerrar el Kernel mediante Evaluation_Quit Kernel. En este caso se pierden todas las asignaciones a variables o funciones.

3. Algunas cuestiones básicas del lenguaje Mathematica

Variables y valores

Una variable puede tomar el valor de una letra o grupos de letras y números (excepto los que Mathematica utiliza para representar ciertas constantes y funciones). 
La asignación de valores a una variable puede hacerse con el símbolo " = ". 
Por supuesto, hay variables a las que en principio no se les asignará ningún valor.
Por ejemplo, en las siguientes intrucciones a las variables a, y, rt e y2 les asignamos los valores 2, 3, 4 y 5.

a = 2
y = 3
rt = 4
y2 = 5

En la siguientes expresiones, a las variables x y z no se les ha asignado ningún valor:

a^3 + z
x + (y^5)

Observe que en las intrucciones anteriores se ha expresado la potenciación de dos formas distintas. Mathematica suele ofrecer distintas posibilidades de representar los objetos matemáticos.

El símbolo ";"

El símbolo punto y coma ";" permite concatenar comandos para formar secuencias de operaciones. El resultado de una secuencia de operaciones es el resultado de la última expresión evaluada, siempre que esta no finalice con ";".

a = 2;  u = z + a^3
y =  3; v = x + (y^5)

Si se usa el símbolo ";" para terminar la secuencia se evita mostrar la respuesta...

a = 2;  y =  3; u = z + a^3;  v = x + (y^5);

que en cualquier otro momento se puede reclamar. Por ejemplo:

a
y
u
v

El comando Clear

Los valores de las variables quedan guardados en el núcleo del programa, independientemente del notebook en el que se hayan introducido. En cuanto cerremos Mathematica todas esas variables y funciones pierden los valores o definiciones asignadas. Otro modo de conseguir esto sin necesidad de cerrar el programa es utilizando el comando Clear:

u
Clear[u]; u

a + v
Clear[a]; a + v

También se puede vaciar el contenido de una variable como se muestra a continuación:

a = 2; y =  3; y + a^3

y =. 
y + a^3

Es decir,  y=.  hace el mismo efecto que  Clear[y]

Algunos símbolos matemáticos

Pueden encontrarse en algunas paletas de símbolos: véase el menú Palettes_BasicMathInput y Palettes_BasicTypesetting. Algunos de esos símbolos pueden representarse de formas diferentes, como por ejemplo los cuatro siguientes:

Pi
E
I
Infinity

El símbolo %

Mathematica utiliza el símbolo % para hacer referencia a resultados anteriores:
    %      Es el último resultado obtenido (aunque no se sitúe inmediatamente después del resultado anterior; podría estar incluso en otro notebook diferente).
    %%   Es el penúltimo resultado, y así sucesivamente.
    %n    Es el resultado Out[n].

((((1/2)))^10)

\(%\^\(1/10\)\)

1024  %%

177  %%%

%27

Simplificación o desarrollo de expresiones algebraicas

Mathematica dispone a este fin de diversos comandos, con usos diversos: vea los comandos de la paleta AlgebraicManipulations y lo que la ayuda del programa dice de cada uno de ellos. A continuación, mostramos cómo actúan algunos de ellos:

Expand[expr]desarrolla los productos y potencias naturales de expr.

Expand[(((x - y))^2) + 2  x (y - x - 1) + 1]

Factor[poly] factoriza un polinomio como producto de polinomios de coeficientes enteros.

Factor[(x^10) - (y^10)]

Expand[(x - y) (x + y) ((x^4) - (x^3) y + (x^2) (y^2) - 
            x (y^3) + (y^4)) ((x^4) + (x^3) y + (x^2) (y^2) + x (y^3) + 
            (y^4))]

El siguiente, aunque es muy fácil de factorizar ((x^2) - 2 = (x - (Sqrt[2])) (x + (Sqrt[2]))) , no lo hace por que la factorización incluye números no enteros:

Factor[(x^2) - 2]

Otros ejemplos:

Factor[(x^2) - 1/4]
Factor[(x^4) - 5  (x^2) + 6]

Together[expr] suma fracciones algebraicas y simplica la suma, si es posible.

Together[
      ((x^2)/((x^2) - 1)) + (x/((x^2) - 1))]
Together[((x^2)/((x^2) - 1)) + (1/((x^2) - 1))]

Apart[expr] hace lo contrario: descompone una fracción algebraica como suma de fracciones con denominadores del grado menor posible:

Apart[(x/(-1 + x))]
Apart[((1 + (x^2))/(-1 + (x^2)))]
Apart[(((x^4) - x + 1)/((x^3) - x))]

Aplicando de nuevo Together se llega a la expresión de partida (pero con los polinomios del denominador factorizados):

Together[1 + (1/(-1 + x))]
Together[
      1 + (1/(-1 + x)) - (1/(1 + x))]
Together[
      (1/(2 (-1 + x))) - (1/x) + x + 
        (3/(2 (1 + x)))]

Simplify[expr] realiza una serie de transformaciones, principalmente algebraicas, sobre expr, y muestra la más simple que encuentra:

Simplify[
      (1/(2 (-1 + x))) - (1/x) + x + 
        (3/(2 (1 + x)))]

FullSimplify[expr] prueba con un rango más amplio de transformaciones de expr, incluyendo transformaciones de funciones elementales y especiales, functions, y muestra la más simple que encuentra:

FullSimplify[
      (1/(2 (-1 + x))) - (1/x) + x + 
        (3/(2 (1 + x)))]

El siguiente ejemplo muestra que FullSimplify tiene más capacidad de simplificación que Simplify:

Simplify[(Sqrt[2]) + (Sqrt[3]) - (Sqrt[5 + 2 (Sqrt[6])])]
FullSimplify[(Sqrt[2]) + (Sqrt[3]) - (Sqrt[5 + 2 (Sqrt[6])])]

Esto no significa que Simplify sea una instrucción inútil: suele ocurrir que Simplify y FullSimplify proporciones dos simplificaciones distintas de una misma expresión, y que nos interese más la que proporciona la orden Simplify.

4. Algunas cuestiones de formato de los notebook

Formato de los comandos o intrucciones de Mathematica

Al igual que con el comando Clear, todas las instrucciones propias de Mathematica comienzan con mayúscula y se aplican a expresiones entre corchetes. Cuando están formados por palabras compuestas, cada palabra empieza por mayúscula (por ejemplo, véanse más abajo las intrucciones ArcTan, MatrixForm, TableForm, InputForm...)

Formato de celdas de texto, etc.

a) Ver el menú Window_Show Toolbar.
b) Ver el menú Format_Stylesheet.
c) Ver el menú Format Style: celdas de texto (Alt 1 a 8) y otras. Se pueden agrupar secciones, subsecciones y subsubsecciones con doble click.
d) Al escribir en un notebook la celda por defecto es una celda Input.
e) Se inicia una fórmula dentro de una celda de texto con las teclas [Control + 9], y se cierra la fórmula con [Control + 0]. Si se copian esas fórmulas y se pegan en una celda Input, se producen errores: Mathematica no entiende esa notación, que suele ser la habitual al escribir.

5. Funciones y su representación

Funciones predefinidas

Mathematica cuenta con muchas funciones predefinidas. 
Como otros comandos, su definición comienza con una letra mayúscula; y se aplican a distintos valores mediante corchetes.
A continuación mostramos algunos ejemplos de funciones predefinidas en Mathematica y de cálculo de valores concretos de algunas de esas funciones:

{Sin[(π/4)], Cos[(π/4)], 
      Tan[(π/4)]}
{ArcSin[1/2], ArcCos[1/2], ArcTan[(Sqrt[3])]}
Log[(E^17)]
Abs[15 - 22]

Como se ve, las llaves y las comas sirven para obtener distintos resultados en una sola celda Output. 
La función Abs también proporciona el módulo de un número complejo:

Abs[2 - 3  I]

El símbolo de multiplicación en funciones y en general

El operador de multiplicación entre números, variables y funciones es el asterisco "*" o un espacio en blanco (para el producto de matrices veremos más adelante que es diferente), los cuales pueden omitirse cuando se multiplican dos funciones entre sí o por un número. Observe lo que ocurre en los siguientes ejemplos:

{2*Cos[π/3], 2   Cos[π/3], 2  Cos[π/3], 
      Sin[π/3] Cos[π/3]}
{(Sqrt[3])*(Sqrt[2]), (Sqrt[3]) (Sqrt[2]), (Sqrt[3]) (Sqrt[2])}
{3*2, 3 2, 3\[Cross]2}

Como se ve, 3×2 no produce ni significa el producto de los números 3 y 2:

Simplify[3\[Cross]2]

Observe que en la siguiente expresión Mathematica ha entendido "xy" e "yCos[x]" como una nueva variable, y no como el producto de las variables x e y:

y = 1; xy + yCos[x]

Sin embargo, con el espacio en blanco o el asterisco sí entiende bien:

y = 1; {x y + y Cos[x], x*y + y*Cos[x]}

Definición de funciones

La definición de otras funciones en Mathematica emplea los símbolos especiales "_"  y  ":=" , como se muestra a continuación:

Clear[x, t]; f[x_] :=  x (E^(-((x^2)/2)))

{f[2], f[2  t + 1], f[x], f[x - 1]}

Las funciones definidas a trozos se pueden introducir de la siguiente forma:

g[x_] := (Sqrt[-3 - x]) /; x ≤ -3
g[x_] := (((x + 2))^3) + 1 /; -3 < x ≤ -1
g[x_] := 1 + (x^2) /; -1 < x ≤ 1
g[x_] := 1 - (((x - 2))^3) /; 1 < x ≤ 3
g[x_] := (Sqrt[-3 + x]) /; x > 3

{g[3], g[-2]}

o también así:

h[x_]  := 
      Piecewise[{{ (Sqrt[-3 - x]),  
            x  ≤  -3},  {(((x + 2))^3) + 1, -3 < 
              x ≤ -1}, {1 + (x^2), -1 < x ≤ 
              1}, {1 - (((x - 2))^3), 
            1 < x ≤ 3}, {(Sqrt[-3 + x]), x > 3}}]

{h[3], h[-2]}

Para funciones de varias variables todo es semejante:

Clear[x, y, z]; 
    f1[x_, y_] :=  
      y (E^(-((x^2)/2)))
{f1[x, y], f1[2, 3]}

f2[x_, y_, z_] :=  
      z + y (E^(-((x^2)/2))) + 3
{f2[x, y, z], f2[2, 3, -5]}

Uso de los paréntesis

En dos de los resultados anteriores han aparecido paréntesis. Su uso es el mismo al del lenguaje matemático escrito. Pero en el lenguaje de Mathematica solo los paréntesis (nunca las llaves y corchetes) se pueden usar con esa función. Así escribiremos:

h[x_] := (x + 1) (((((x - 1) (x^(1/3)) + 1))^3) + 
            x (Sqrt[x - 1])); h[2]

Es incorrecto escribir:

h[x_] := (x + 1) {(([(x - 1) (x^(1/3)) + 1])^3) + 
            x (Sqrt[x - 1])}; h[2]

Uso del comando Clear para funciones

Para eliminar la definición de una función introducida mediante los símbolos "_"  y  ":=", se puede usar el comando Clear (pero aquí no sirve escribir "f =.", instrucción válida únicamente para variables):

f[x]

Clear[f]; f[x]

Si se quiere borrar todas las asignaciones de variables y funciones sin necesidad de cerrar el programa se utilizan el comando Clear["Global`*"]:

f[x_] :=  x (E^(-((x^2)/2))); {f[x], a, y2, 
      rt}

Clear["Global`*"]

{f[x], a, y2, rt}

Derivación de funciones

Para calcular derivadas de una función hay varias formas. La más sencilla es la siguiente:

f[x_] :=  
      x (E^(-((x^2)/2)))
{f'[x], f'[3], f''[x], f'''''[x]}

Simplify[%]

Integración de funciones

Para calcular primitivas e integrales definidas de una función tenemos las siguientes instrucciones:

Integrate[Cos[x], x]
Integrate[y Cos[x], y]

Integrate[Cos[x], {x, 1, 2}]
Integrate[y Cos[x], {x, 1, 2}, {y, 0, 3}]

En las dos intrucciones anteriores las llaves { } sirven para indicar el intervalo donde toma valores una variable.
También se pueden calcular las integrales anteriores utilizando las expresiones que aparecen en la paleta BasicMathInput (también aparecen en otras paletas más amplias).

{∫Cos[x] \[DifferentialD]x, ∫y Cos[
            x] \[DifferentialD]y, (∫_1^2) Cos[
            x] \[DifferentialD]x, (∫_1^2)(∫_0^3) 
            y Cos[x] \[DifferentialD]y \[DifferentialD]x}

Representación de funciones

Plot es el comando básico de Mathematica para construir gráficos de funciones de una variable. Requiere como mínimo dos parámetros: la función a representar y el intervalo donde se define (de nuevo se utilizarán las llaves { } para indicar el intervalo donde toma valores la variable independiente), todo esto de la siguiente forma:

f[x_] := x (E^(-((x^2)/2))); 
    Plot[f[x], {x, -2, 3}]

A continuación se representa la composición de f con la función g(t) = (t^2):

Plot[f[(t^2)], {t, -2, 3}]

Otro ejemplo:

Plot[
      Piecewise[{{ (Sqrt[-3 - x]),  
            x  ≤  -3},  {(((x + 2))^3) + 1, -3 < 
              x ≤ -1}, {1 + (x^2), -1 < x ≤ 
              1}, {1 - (((x - 2))^3), 
            1 < x ≤ 3}, {(Sqrt[-3 + x]), x > 3}}], {x, -5, 
        5}]

Se puede representar la gráfica de varias funciones sobre los mismos ejes, expresando esas funciones entre llaves y separadas por comas. Por ejemplo:

Plot[{x Cos[x], x Sin[x], x (Sqrt[x])}, {x, 0, 2 π}]

Muchas características del gráfico, como los ejes y sus marcas, están determinadas por ciertos valores por omisión que pueden ser cambiados mediante parámetros opcionales. La lista completa de estos parámetros y sus valores por omisión se obtiene con el comando Options (que es aplicable al comando Plot y también a otros que veremos más adelante: Plot3D, ListPlot, MatrixForm, TableForm...):

Options[Plot]

Por ejemplo, la opción PlotRange->{c,d} permite especificar que el intervalo para el eje Y que muestra el gráfico sea [c, d]. Esto puede ser interesante en distintas circunstancias. Por ejemplo, si representamos las tres siguientes funciones, hay dos de ellas que apenas se ven en la gráfica:

Plot[{x Cos[x], x Sin[x], 100  x (Sqrt[x])}, {x, 0, 2 π}]

Se pueden visualizar las que apenas se aprecian utilizando adecuadamente la opción PlotRange:

Plot[{x Cos[x], x Sin[x], 100  x (Sqrt[x])}, {x, 0, 2 π}, 
      PlotRange -> {-5, 8}]

A continuación se representa cada función con un color distinto al utilizado por defecto, usando la opción PlotStyle:

Plot[{x Cos[x], x Sin[x], 100  x (Sqrt[x])}, {x, 0, 2 π}, 
      PlotRange -> {-5, 
          8}, 
PlotStyle -> {RGBColor[1, 0, 0], 
          RGBColor[0, 1, 0], RGBColor[0, 0, 1]}]

En el siguiente ejemplo se modifica el tamaño de fuente de los números (y etiquetas, si las hubiera), usando la opción BaseStyle:

Plot[{x Cos[x], x Sin[x], x (Sqrt[x])}, {x, 0, 2 π}, 
      BaseStyle -> {FontSize -> 7}]

En el siguiente ejemplo se modifican también los valores que se representan sobre los ejes x e y, usando la opción Ticks:

Plot[{x Cos[x], x Sin[x], x (Sqrt[x])}, {x, 0, 2 π}, 
      PlotRange -> {-5, 
          2 π (Sqrt[2 π])}, 

BaseStyle -> {FontSize -> 
            7}, 
Ticks -> {{(π/4), (π/2), ((3 π)/4), π, ((5 π)/4), ((3 π)/2), ((7 π)/4), 
            2 π}, {-4, -2, 0, 2, 4, 6, 8, 10, 12, 
            14}}]

Plot3D es el comando de Mathematica para construir gráficos de funciones de dos variables.

h[x_, y_] := Sin[x + Sin[y]]

Plot3D[
      h[x, y], {x, -π, π}, {y, -π, π}]

También en este caso ocurre que muchas características del gráfico están determinadas por ciertos valores por omisión que pueden ser cambiados mediante parámetros opcionales. La lista completa de estos parámetros y sus valores por omisión se obtiene de nuevo con el comando Options (pero no nos detenemos en mostrar cómo actúan esas opciones).

Options[Plot3D]

6. La aritmética de Mathematica

La aritmética de Mathematica es exacta siempre que se trabaje con cualquier número en el que no aparezca el punto decimal (incluidos los números e, π e i) y con funciones que se evalúan en esos números. Todos los cálculos realizados hasta ahora en esta práctica son exactos. 
Al realizar operaciones con números exactos, Mathematica simplifica los resultados cuando es posible, como ocurre en los dos ejemplos siguientes:

(1/3) + (4/7)
(Sqrt[8]) (16^(1/4))

Otros ejemplos de cálculos exactos:

(Sqrt[(3/7)])
(3^100)
{Sin[3], Cos[(π/12)], ArcTan[((Sqrt[3])/3)], 
      Log[2]}
Solve[(x^2) - 3 == 0, x]

Sin embargo, cuando se introduce el punto decimal en uno solo de los números de la expresión, la aritmética deja de ser exacta (o simbólica): las operaciones son numéricas (se realizan con números máquina) y sus resultados son números máquina; entran en juego los redondeos.
Para pasar de la expresión exacta a una numérica puede utilizarse la orden N.

{(3. ^100), N[(3^100)]}
{(Sqrt[8.])  (16^(1/4)), N[(Sqrt[8]) (16^(1/4))]}

Por defecto, cuando trabaja numéricamente, Mathematica muestra 6 de dígitos de cada resultado que obtiene (6 contando desde el primer dígito no nulo), como se ha visto en los dos ejemplos anteriores.

Pero Mathematica retiene más dígitos de los 6 mostrados, dígitos que se pueden visualizar utilizando la instrucción InputForm o bien seleccionando la celda Output correspondiente y pulsando la tecla [Enter]. Haga esto último sobre el resultado anterior.

Antes obtuvimos:

{(3. ^100), (Sqrt[8.])  (16^(1/4))}

Usando InputForm:

{InputForm[(3. ^100)], InputForm[(Sqrt[8.])  (16^(1/4))]}

En la siguiente práctica veremos cómo Mathematica puede también trabajar con más precisión numérica.
Una cuestión final que el alumno puede plantearse a estas alturas es que, si Mathematica puede trabajar con números exactos, ¿por qué hacerlo de manera numérica, que implica redondeos? La respuesta está en que los ordenadores y, en particular, Mathematica pueden trabajar con números exactos cuando las operaciones son pocas o sencillas. Cuando son muchas y complicadas se "atascan" y son incapaces de dar un resultado. Para comprobarlo, bastará que en los algoritmos de las prácticas de los temas 2 a 5 introduzcamos números exactos en vez de números con punto decimal.

7. Listas, vectores y matrices

Instrucciones básicas

Un vector se escribe entre llaves. Una componente de este vector se indica con el nombre del vector y la posición que ocupa indicada entre dos pares de corchetes. En el siguiente ejemplo, v es un vector de (ℝ^5):

v = {1, -1, 2, 4, 5}; 
v[[3]]

En realidad la representación entre llaves se usa no solo para vectores, sino para establecer en general una lista de cosas (por ejemplo, ya se usaron listas de funciones para representarlas sobre el mismo gráfico; y muchas veces hemos hecho listas de operaciones).
El número de componentes de un vector se mide con el siguiente comando:

Length[v]

Para introducir la matriz  A = (({{2, 3, 1}, {-1, 2, 0}, {1, -4, 5}}))  se considera como una lista de filas, cada una de las cuales es a su vez una lista. Así, una matriz es una lista de listas, por lo que se representa con doble llave.

A = {{2, 3, 1}, {-1, 2, 0}}

El comando MatrixForm permite visualizar la matriz tal y como estamos acostumbrados. Si queremos referirnos a un elemento concreto, basta con indicar la posición entre dobles corchetes.

MatrixForm[A]
A[[2, 1]]

El comando TableForm permite visualizar la matriz como una tabla (sin paréntesis):

TableForm[A]

Como una matriz es una lista, la instrucción Length nos proporciona el número de sus filas:

Length[A]

Para obtener sus filas y columnas tenemos la instrucción:

Dimensions[A]

Para añadir un elemento al final de una lista, manteniendo el nombre de la lista se utiliza el comando AppendTo; para añadirlo al principio, PrependTo:

v = {1, -1, 2, 4, 5}; AppendTo[v, 7]; v

PrependTo[v, 8]; v

AppendTo[A, {8, 9, 7}]; MatrixForm[A]

PrependTo[A, {0, -2, 4}]; TableForm[A]

Operaciones con matrices

A = {{2, 3, 1}, {-1, 2, 0}, {1, -4, 5}}; 
    MatrixForm[A]
B = {{-2, 0, -1}, {1, 2, 5}, {1, 8, -2}}; 
    MatrixForm[B]

Algunas comandos para cálculo con matrices son los siguientes:

A + B;        
MatrixForm[A + B]

2  B ;        
MatrixForm[2  B]

También es válida la expresion:

MatrixForm[2*B]

A . B ;        
MatrixForm[A . B]
F = {{-2, 0}, {1, 2}, {1, 8}}; MatrixForm[A . F]

Otras expresiones no son válidas para obtener el producto de dos matrices, como por ejemplo las tres siguientes:

MatrixForm[A·B]
MatrixForm[A B]
MatrixForm[A*B]
MatrixForm[A F]
MatrixForm[A*F]

Otros conceptos:

Transpose[A];        
MatrixForm[
      A]

Det[A]

Inverse[B];         
MatrixForm[Inverse[B]]

Si la matriz no es inversible, dicho comando nos informa de que no lo es:

B = {{1, 2}, {2, 4}}; Inverse[B]

8. El comando "Table"

La orden Table genera una lista de elementos. Observe su estructura en los siguientes ejemplos, que tienen un único contador de la lista (la variación del contador se expresa también entre llaves: aquí tenemos un nuevo uso de las llaves en Mathematica):

Table[i +  .3, {i, 1, 5}]

Esta notación significa que i toma los valores 1, 1+1, 1+1+1... sin superar el número 5. Si no se indica el valor de partida, se supone que es igual a 1:

Table[i +  .3, {i, 5}]

En estos casos el salto entre cada valor de i y su siguiente es 1. Si se desea que el salto tenga otro valor, se añade un tercer número que indica el valor del salto. Por ejemplo:

Table[(c^k), {k, 4, 10, 2}]
Table[(c^k), {k, 4, 10,  .2}]

Con dos o más contadores se forman matrices de dimensión 2 o superior:

a = Table[i j, {i, -1, 2}, {j, 2}]
TableForm[a]

b = Table[i + j, {i, 3}, {j, 2, 30, 2}]; 
    TableForm[b]
TableForm[Transpose[b]]

c = 
      Table[i j + k, {i, -1, 2}, {j, 2}, {k, 2, 8, 
          3}]
TableForm[Transpose[c]]

9.  Programación con Mathematica

Una vez escrito un algoritmo para resolver un problema es posible escribir el programa correspondiente en algún lenguaje. Mathematica lleva incorporado un lenguaje de programación propio que permite incorporar funciones para realizar tareas específicas al mismo nivel que las funciones predefinidas. Al ser un intérprete, el modo de trabajo puede ser totalmente interactivo.

Comando "Print"

Para dar una salida en pantalla, se utiliza el comando Print:

b = 6.7756; 
Print["El valor de la variable b es ",  b]

Estructura de repetición: "For[comienzo, test, incremento, sentencias]"

Se evalúa comienzo y se ejecutan sentencias e incremento hasta que test falla. El incremento  i++ es equivalente a i  =  i + 1.

For[i = 1, i < 10, i++, Print[i]]

Si el incremento no es 1 debe especificarse, como en el siguiente ejemplo:

For[i = 1, i < 10, i = i +  .5, Print[i]]

Estructura condicional: "If[condición, sentencia1,sentencia2]"

Si la condición es cierta se ejecuta sentencia1. En caso negativo se ejecuta sentencia2.

If[2 < 1, Print["Es cierto"], Print["Es falso"]]

A veces la estructura condicional es más simple: "If[condición, sentencia]". En este caso, si la condición es cierta se ejecuta sentencia. En caso negativo no produce ningún resultado.

If[2 < 3, Print["Es cierto"]]

If[2 < 1, Print["Es cierto"]]

Instrucción "Break[  ]"

Para establecer una condición de parada de una instrucción For se puede usar el comando condicional If junto con la instrucción Break[], que es la que detiene la orden For. Por ejemplo, para escribir la lista de los números naturales cuyo cubo es menor que 777 podemos partir de una lista vacía e ir añadiendo números hasta que ya no se cumpla esta condición:

lista  = {}; 
    For[i = 1, i ≤ 1000, i++,  
      If[(i^3) < 777, AppendTo[lista, i], Break[]]]

lista

(9^3)

Ejemplo 1

Vamos a escribir todos números con una cifra decimal o enteros desde 10 hasta 12 junto con su cuadrado.

For[i = 10, i ≤ 12, i = i +  .1,  
      Print[i, "   " , i^2]];

O bien, creando una lista de esos números:

lis = Table[{i, (i^2)}, {i, 10, 12,  .1}]; TableForm[lis]

Ejemplo 2

Vamos a calcular la suma de los n primeros números naturales siempre que esa suma sea menor que 500, y mostrando cuáles son esos números y la suma correspondiente.

s = 0; 
    For[i = 1, i ≤ 300, i++,  s = s + i; 
      If[s ≥ 500, Break[], Print[i, "  ", s]]]

Se ha partido de una suma inicial s = 0, se le ha sumado los primeros números naturales, mostrando las sumas parciales, dejando de mostrar la primera suma que es superior a 500.
Otra posibilidad de resolver el ejercicio es creando una lista de esos números:

l = {}; s = 0; 
    For[i = 1, i ≤ 300, i++,  s = s + i; 
      If[s ≥ 500, Break[]]; AppendTo[l, {i, s}]]; 
    TableForm[l]

Ejemplo 3

Calculemos el producto de las componentes no nulas del vector v = (1, 0, 1.2, -1, 7):

v = {1, 0, 1.2, -1, 7}; 
n = Length[v]; p = 1; 
For[i = 1, i ≤ n, i++, 
      If[v[[i]] ≠ 0, p = p v[[i]]]]; 
    p

10. Ejercicios (Resueltos)

Ejercicio 1

Obtenga: 
	a) Las cuatro primeras derivadas de la función f(x)=((x - 1)/(ln (x + 1))). 
	b) Otras expresiones más simplificadas de esas derivadas (utilice dos comandos distintos).
	c) Haga una tabla con los valores numéricos de f y de sus cuatro primeras derivadas (bastan 6 dígitos de precisión) en todos los enteros situados entre 3 y 8. 
	d) La representación de f y de sus dos primeras derivadas en el intervalo [3, 8], las tres en el mismo gráfico.

Solución

Apartado a):

f[x_] := ((x - 1)/Log)[x + 1]
{f'[x], f''[x], f'''[x], f''''[x]}

Apartado b):

Simplify[%]

FullSimplify[%%]

Apartado c):

Table[{f[x], f'[x], f''[x], f'''[x], f''''[x]},  {x, 
        3, 8}];  
TableForm[N[%]]

Apartado d):

Plot[{f[x], f'[x], f''[x]},  {x, 3, 8}]

Ejercicio 2

a) Obtenga integral indefinida de f(x) = x cos x. 
b) Obtenga también la integral definida de esta función en el intervalo [π/3, π/2]. Exprese el resultado tanto de manera exacta como decimal.

Solución

Apartado a):

∫x Cos[x] \[DifferentialD]x

Apartado b):

Int = (∫_(π/3)^(π/2))x Cos[
            x] \[DifferentialD]x

N[%]

{Factor[Int], Expand[Int], Apart[Int], Together[Int]}

Ejercicio 3

a) Repita el ejercicio del ejemplo 3 para otros vectores de 6 o más componentes. 
b) Reescriba el programa de dicho ejemplo para que también proporcione la suma de las componentes del vector, indicando con claridad qué representa cada resultado.

Solución

Apartado a)

v = {1, 0, 1.2, -1, 7, 5}; 
n = Length[v]; p = 1; 
For[i = 1, i ≤ n, i++, 
      If[v[[i]] ≠ 0, p = p v[[i]]]]; 
    p

v = {0, -2, 1, 0, 1.2, -1, 7, 5}; 
n = Length[v]; p = 1; 
For[i = 1, i ≤ n, i++, 
      If[v[[i]] ≠ 0, p = p v[[i]]]]; 
    p

Apartado b)

v = {0, -2, 1, 0, 1.2, -1, 7, 
        5}; 
n = Length[v]; p = 1; 
    q = 0; 
For[i = 1, i ≤ n, i++, 
      If[v[[i]] ≠ 0, 
        p = p v[[i]]]]; 
Print["El producto de las componentes no nulas del vector es ", p]
For[i = 1, i ≤ n, i++, 
      q = q + v[[i]]]; 
Print["La suma de las componentes del vector es ", q]

Ejercicio 4

Escriba los 100 primeros números naturales pares así como el valor de su cuadrado y de su raíz cuadrada. Resuelva el ejercicio al menos de dos formas:
	a) Una mediante la utilización de las instrucciones For y Print.
	b) Otra, usando las instrucciones Table y TableForm.

Solución

Apartado a)

For[i = 1, i ≤ 100, i++, 
      Print[2  i, "  ", 4  (i^2), "  ", N[(Sqrt[2  i])]]]

Apartado b)

Table[{2  i, 4  (i^2), N[(Sqrt[2  i])]}, {i, 
        100}]; 
TableForm[%]

Ejercicio 5

Calcule el producto de la raíz cuadrada de los n primeros números naturales pares siempre que ese producto sea menor que 100000. Muestre cuáles son esos números, su raíz cuadrada y el producto correspondiente.

Solución

p = 1; 
    For[i = 1, i ≤ 10000, i++, p = N[(Sqrt[2  i]) p]; 
      If[p < 100000, Print[2  i, "  ", N[(Sqrt[2  i])], "  ", p], 
        Break[]]]

O bien, creando una lista de esos números:

lista = {}; p = 1; 
    For[i = 1, i ≤ 10000, i++,  p = N[(Sqrt[2  i]) p]; 
      If[p < (10^5), AppendTo[lista, {2  i, N[(Sqrt[2  i])], p}], 
        Break[]]]

TableForm[lista]