Documentos de Académico
Documentos de Profesional
Documentos de Cultura
(en construccin...)
Alberto Ruiz <aruiz@um.es>
Departamento de Informtica y Sistemas
Universidad de Murcia, Spain
Preliminares
Mathematica es un entorno de clculo simblico, compuesto por un lenguaje de programacin de alto nivel, una
coleccin extensa de funciones matemticas y de propsito general, y un sistema para editar interactivamente
documentos como ste que contienen texto normal, rdenes sencillas, programas ms complejos, grficos, etc.
Los documentos estn organizados por "celdas" indicadas en azul a la derecha. Hay varios tipos de celdas: las ms
importantes son las de texto normal, y las de entrada (input) y salida de informacin (output), como las siguientes:
In[1]:= 2 + 2
Out[1]= 4
El lenguaje de Mathematica es interpretado: no hace falta compilacin. Est basado en reglas de transformacin de
expresiones y aprovecha muchas construcciones de programacin funcional.
Para ejecutar una orden o evaluar una expresin se edita en una celda tipo "input" y cuando est terminada se pulsa
ShiftEnter(tecla de maysculas + tecla de nueva lnea). A continuacin aparecer una celda con el resultado.
Mathematica se puede usar directamente como una calculadora:
In[2]:= 1.5 + 2.5
Out[2]= 4.
El espacio en blanco significa multiplicacin (tambin se puede usar *):
In[3]:= 2 (5 + 5)
Out[3]= 20
La aritmtica es exacta:
In[4]:= 1000/350
Out[4]=
20
-------
7
y sin lmite en el tamao de los nmeros:
In[5]:= 2^100
Out[5]= 1267650600228229401496703205376
In[6]:= 100!
Out[6]= 93326215443944152681699238856266700490715968264381621468592963895217599993229
9156089414639761565182862536979208272237582511852109168640000000000000000000
00000
intromat.nb 1
Pero si en las operaciones aparecen nmeros aproximados, el resultado tambin lo ser:
In[7]:= 1000.0/350
Out[7]= 2.85714
Siempre se puede convertir un valor exacto en un valor aproximado usando la funcin N (convertir en un nmero).
En Mathematica los argumentos se encierran entre corchetes:
In[8]:= N[1000/350]
Out[8]= 2.85714
In[9]:=
Out[9]=
In[10]:= N[]
Out[10]= 3.14159
Como argumento opcional se puede especificar la precisin del nmero:
In[11]:= N[, 100]
Out[11]= 3.14159265358979323846264338327950288419716939937510582097494459230781640628
6208998628034825342117068
Disponemos de todas las funciones matemticas usuales :
In[12]:= Exp[3.8]
Out[12]= 44.7012
In[13]:= Cos[0.12]
Out[13]= 0.992809
In[14]:= Sin[30 Degree]
Out[14]=
1
----
2
Existen bibliotecas con constantes y unidades fsicas.
Principio Fundamental de Mathematica
Todo son expresiones que se evalan mediante la aplicacin de reglas de transformacin estructural.
Expresiones
Una expresin es o bien un tomo (nmero o smbolo) o bien una "cabeza" y "argumentos", que, a su vez, son
expresiones. Este tipo de estructura recursiva permite representar cualquier cosa: frmulas matemticas, progra-
mas, dibujos, etc. Este mismo documento es en realidad una expresin de ese tipo.
Las expresiones tienen una representacin externa, visualmente conveniente, pero en realidad estn constituidas
por este tipo de estructuras anidadas. Por ejemplo:
intromat.nb 2
a + b
es en realidad
Plus[a, b]
(Los componentes de una expresin (o argumentos de una funcin) se escriben con corchetes.) Otro ejemplo:
a Sin[3 + b x]
se representa internamente mediante
Times[a, Sin[Plus[3, Times[b, x]]]]
La forma interna de cualquier expresin se obtiene mediante la orden FullForm:
In[15]:= FullForm]a Sin]
b x + 3
-------- --------
_------
Out[15]//FullForm=
Times[a, Sin[Times[Power[Power[Pi, m], Rational[-1, 2]], Plus[3, Times[b, x]]]]]
Los "arrays" se representan mediante la estructura ms general de lista, que es una coleccin de expresiones
encerradas entre llaves:
{4, a + b, 17, {1, 2, 3}, 5}
aunque, por supuesto, internamente son expresiones con cabeza "Lista":
List[4, Plus[a, b], 17, List[1, 2, 3], 5]
Evaluacin
El funcionamiento de Mathematica consiste en leer una expresin (y pasarla a la forma interna), evaluarla, y
mostrar el resultado (en forma externa).
La evaluacin consiste en la aplicacin de ciertas "reglas" que modifican la estructura de la expresin. Estas reglas
son de varios tipos: a) reglas que se aplican automticamente (manipulacin matemtica usual) b) transformaciones
y algoritmos de distinto tipo ya preprogramados, y c) algoritmos definidos por nosotros para manipular las expre-
siones de acuerdo con nuestros intereses.
En primer lugar veremos algunos ejemplos de transformaciones automticas y de instrucciones que realizan
transformaciones tiles:
Simplificacin:
In[16]:= 2 + 3 + 5 x + y + 10 x - 5
Out[16]= 15 x + y
Expansin de potencias:
intromat.nb 3
In[17]:= Expand[(1 + x)
10
(1 - y)
5
]
Out[17]= 1 + 10 x + 45 x
2
+ 120 x
3
+ 210 x
4
+ 252 x
5
+ 210 x
6
+ 120 x
7
+ 45 x
8
+ 10 x
9
+ x
10
- 5 y -
50 x y - 225 x
2
y - 600 x
3
y - 1050 x
4
y - 1260 x
5
y - 1050 x
6
y - 600 x
7
y - 225 x
8
y -
50 x
9
y - 5 x
10
y + 10 y
2
+ 100 x y
2
+ 450 x
2
y
2
+ 1200 x
3
y
2
+ 2100 x
4
y
2
+ 2520 x
5
y
2
+
2100 x
6
y
2
+ 1200 x
7
y
2
+ 450 x
8
y
2
+ 100 x
9
y
2
+ 10 x
10
y
2
- 10 y
3
- 100 x y
3
-
450 x
2
y
3
- 1200 x
3
y
3
- 2100 x
4
y
3
- 2520 x
5
y
3
- 2100 x
6
y
3
- 1200 x
7
y
3
- 450 x
8
y
3
-
100 x
9
y
3
- 10 x
10
y
3
+ 5 y
4
+ 50 x y
4
+ 225 x
2
y
4
+ 600 x
3
y
4
+ 1050 x
4
y
4
+ 1260 x
5
y
4
+
1050 x
6
y
4
+ 600 x
7
y
4
+ 225 x
8
y
4
+ 50 x
9
y
4
+ 5 x
10
y
4
- y
5
- 10 x y
5
- 45 x
2
y
5
-
120 x
3
y
5
- 210 x
4
y
5
- 252 x
5
y
5
- 210 x
6
y
5
- 120 x
7
y
5
- 45 x
8
y
5
- 10 x
9
y
5
- x
10
y
5
Solucin simblica de sistemas de ecuaciones:
In[18]:= Solve[5 x - 8 a = 4, x]
Out[18]= x -
4
----
5
(1 + 2 a)
Derivadas simblicas:
In[19]:= D[Sin[Exp[Cos[x]]], x]
Out[19]= -c
Cos[x]
Cos[c
Cos[x]
] Sin[x]
Integrales simblicas:
In[20]:=
_
Sin[x]
2
dx
Out[20]=
x
----
2
-
1
----
4
Sin[2 x]
Desarrollos en serie:
In[21]:= Series[Exp[x], {x, 0, 5}]
Out[21]= 1 + x +
x
2
-------
2
+
x
3
-------
6
+
x
4
-------
24
+
x
5
----------
120
+ O[x]
6
Lmites:
In[22]:= Limit]
1
\
.
.1 +
1
--------
2 x
)
!
.
.
5 x
, x -
Out[22]= c
5/2
Representaciones grficas 2D:
In[23]:= Plot[Sin[x] + Sin[10 x], {x, 0, 2 }];
1 2 3 4 5 6
-2
-1
1
2
intromat.nb 4
Y 3D:
In[24]:= Plot3D[Exp[-.5 (x x + y y)], {x, -3, 3}, {y, -3, 3}, Mesh - False, PlotPoints - 50] ;
-2
0
2
-2
0
2
0
0.25
0.5
0.75
1
-2
0
2
La aritmtica es exacta:
In[25]:= Solve[5 x
2
- 8 + 5 x
3
= 4, x]
Out[25]= x - -
1
----
3
+
1
-------
15
3925 - 900
_
19
1/3
+
1
----
3
1
----
5
157 + 36
_
19
1/3
,
x - -
1
----
3
-
1
-------
30
1 + f
_
3 3925 - 900
_
19
1/3
-
1
----
6
1 - f
_
3
1
----
5
157 + 36
_
19
1/3
,
x - -
1
----
3
-
1
-------
30
1 - f
_
3 3925 - 900
_
19
1/3
-
1
----
6
1 + f
_
3
1
----
5
157 + 36
_
19
1/3
1
-------
n
2
Out[32]=
1
----
6
(-6 +
2
)
otro ejemplo:
In[33]:= _
n=2
1
-------- -------
n
2
+ 5
Out[33]= --2 f +
_
5 2 f +
_
5 Csch
_
5 -15 Cosh
_
5 + 8
_
5 Sinh
_
5
45
_
5 -f +
_
5 f +
_
5
Aunque no siempre convergen:
In[34]:= _
n=2
1
----
n
Sum::div : Sum does not converge.
Out[34]= _
n=2
1
----
n
Las derivadas se pueden expresar explcitamente:
In[35]:= D[Sin[Exp[Cos[a x]]], x]
Out[35]= -a c
Cos[a x]
Cos[c
Cos[a x]
] Sin[a x]
O con la notacin abreviada:
In[36]:= Sin[x]
Out[36]= Cos[x]
In[37]:= Tan[x]
Out[37]= 2 Sec[x]
2
Tan[x]
intromat.nb 6
Las integrales definidas se calculan simblicamente, no numricamente sumando reas:
In[38]:=
_
0
1
4
-------- ----
1 + x
dx
Out[38]= 4 Log[2]
In[39]:=
_
0
1
4
-------- -------
1 + x
2
dx
Out[39]=
Lo que nos permite que los extremos sean smbolos:
In[40]:=
_
1
t
1
-------- ----
1 + x
dx
Out[40]= -Log[2] + Log[1 + t]
In[41]:= % // Simplify
Out[41]= Log
1 + t
-------- ----
2
(El smbolo % representa el resultado anterior)
Si deseamos integrales numricas hacemos lo siguiente:
In[42]:=
_
0
1
4
-------- ----
1 + x
dx // N
Out[42]= 2.77259
In[43]:= Integrate]
4
-------- ----
1 + x
, {x, 0, v}
Out[43]= 4 Log[1 + v]
Se pueden aplicar transformaciones trigonomtricas:
In[44]:= Sin[34 x]
Out[44]= Sin[34 x]
In[45]:= % // TrigExpand
Out[45]= 34 Cos[x]
33
Sin[x] - 5984 Cos[x]
31
Sin[x]
3
+ 278256 Cos[x]
29
Sin[x]
5
-
5379616 Cos[x]
27
Sin[x]
7
+ 52451256 Cos[x]
25
Sin[x]
9
-
286097760 Cos[x]
23
Sin[x]
11
+ 927983760 Cos[x]
21
Sin[x]
13
-
1855967520 Cos[x]
19
Sin[x]
15
+ 2333606220 Cos[x]
17
Sin[x]
17
-
1855967520 Cos[x]
15
Sin[x]
19
+ 927983760 Cos[x]
13
Sin[x]
21
-
286097760 Cos[x]
11
Sin[x]
23
+ 52451256 Cos[x]
9
Sin[x]
25
- 5379616 Cos[x]
7
Sin[x]
27
+
278256 Cos[x]
5
Sin[x]
29
- 5984 Cos[x]
3
Sin[x]
31
+ 34 Cos[x] Sin[x]
33
Las reglas de simplificacin son muy potentes. Por ejemplo, pueden deshacer la anterior expansin:
In[46]:= % // Simplify
Out[46]= Sin[34 x]
La integracin simblica permite abordar la solucin de ecuaciones diferenciales:
intromat.nb 7
In[47]:= DSolve[f[x] = k, f[x], x]
Out[47]= {{f[x] - k x + C[1]]]
In[48]:= DSolve[{f[x] = w
2
f[x], f[0] = 1}, f[x], x]
Out[48]= {{f[x] - c
-w x
(1 - C[2] + c
2 w x
C[2])]]
Mathematica dispone de todas las funciones necesarias para efectuar eficientemente clculo matricial. Por ejemplo,
el producto matricial y matriz vector se representa mediante "." (Dot):
In[49]:= m1 = Table[i + j, {i, 3}, {j, 4}]
Out[49]= {{2, 3, 4, 5], {3, 4, 5, 6], {4, 5, 6, 7]]
In[50]:= m1 // MatrixForm
Out[50]//MatrixForm=
2 3 4 5
3 4 5 6
4 5 6 7
|
2 5
3 6
4 7
5 8
|
Out[52]//MatrixForm=
54 96
68 122
82 148
|
Es posible automatizar que las matrices se muestren como tales y no como listas de listas...
In[53]:= MakeBoxes[x_?MatrixQ, StandardForm] := ToBoxesMatrixFormx
Off[MatrixQ::argt]
In[55]:= m1
Out[55]=
2 3 4 5
3 4 5 6
4 5 6 7
|
Al ser un entorno de clculo simblico, tiene la ventaja de que los elementos de las matrices pueden ser smbolos:
In[56]:= m = ]
1 a
c 7
Out[56]=
1 a
c 7
In[57]:= Transpose[m]
Out[57]=
1 c
a 7
In[58]:= Inverse[m]
Out[58]=
7
-------- ---
7-a c
-
a
-------- ---
7-a c
-
c
-------- ---
7-a c
1
-------- ---
7-a c
|
intromat.nb 8
No confundamos el producto elemento a elemento (*):
In[59]:= m +Inverse[m]
Out[59]=
7
-------- ---
7-a c
-
a
2
-------- ---
7-a c
-
c
2
-------- ---
7-a c
7
-------- ---
7-a c
|
7
-------- ---
7-a c
-
a c
-------- ---
7-a c
0
0
7
-------- ---
7-a c
-
a c
-------- ---
7-a c
|
In[61]:= % // Simplify
Out[61]=
1 0
0 1
1 1 1 1
2 4 8 16
3 9 27 81
|
4 30 120
30 340 1554
120 1554 7380
|
intromat.nb 22
In[183]:= Inverse[m3]
Out[183]=
27
------
8
-
5
----
4
5
------
24
-
5
----
4
105
--------
194
-
109
----------
1164
5
------
24
-
109
----------
1164
115
----------
6984
|
In[184]:= Inverse[m3] // N
Out[184]=
Out[185]=
b
----------
-2+b
-
2
----------
-2+b
-
1
----------
-2+b
1
----------
-2+b
|
a a
b b
c c
|
Esta funcin tiene la misma definicin, pero al no tener el atributo listable no se distribuye dentro los argumentos de tipo lista:
In[190]:= h[x_] := {x, x}
In[191]:= h[4]
Out[191]= {4, 4]
In[192]:= h[{a, b, c}]
Out[192]=
a b c
a b c
Si lo deseamos, podemos trabajar con vectores fila y columna explcitos, usando matrices de una sola fila o
columna:
In[193]:= col = List / {a, b, c}
Out[193]=
a
b
c
|
a x a y a z
b x b y b z
c x c y c z
|
Mejor Outer:
In[197]:= Outer[Times, {a, b, c}, {x, y, z}]
Out[197]=
a x a y a z
b x b y b z
c x c y c z
|
0.996618 1
0.318965 2
0.697993 3
0.0535312 4
0.983696 5
0.264338 6
0.268539 7
0.561153 8
0.135592 9
0.765438 10
|
intromat.nb 24
In[204]:= Sort[%]
Out[204]=
0.0535312 4
0.135592 9
0.264338 6
0.268539 7
0.318965 2
0.561153 8
0.697993 3
0.765438 10
0.983696 5
0.996618 1
|
In[205]:= Last / %
Out[205]= {4, 9, 6, 7, 2, 8, 3, 10, 5, 1]
(Por supuesto, en una biblioteca tenemos RandomPermutation)
Tenemos operaciones matriciales tpicas de clculo cientfico: valores y vectores propios, valores singulares, etc.
Borramos:
In[206]:= Remove["Global+"]
Ajuste de mnimo error cuadrtico
En Mathematica podemos resolver cmodamente ajustes de mnimos cuadrados.
In[207]:= datos = Table[{x, x
2
+ Random[Real, {-2, 2}]}, {x, 0, 5, .1}];
Mostramos los primeros:
In[208]:= Take[datos, 5]
Out[208]=
0 -1.96865
0.1 -1.85859
0.2 0.206314
0.3 -1.61708
0.4 0.575433
|
In[209]:= g1 = ListPlot[datos]
1 2 3 4 5
5
10
15
20
25
Out[209]= ~ Graphics ~
In[210]:= sol = Fit[datos, {1, x}, {x}]
Out[210]= -4.63811 + 5.09923 x
intromat.nb 25
In[211]:= g2 = Plot[sol, {x, -2, 7}]
-2 2 4 6
-10
10
20
30
Out[211]= ~ Graphics ~
Es muy cmodo unir los dos grficos de manera consistente:
In[212]:= Show[g1, g2]
-2 2 4 6
-10
10
20
30
Out[212]= ~ Graphics ~
El ajuste lineal es inadecuado. Vamos a probar con un polinomio de orden mayor:
In[213]:= sol2 = Fit[datos, {1, x, x
2
, x
3
, x
4
}, {x}]
Out[213]= -1.49295 + 3.65777 x - 2.03306 x
2
+ 0.905784 x
3
- 0.0877753 x
4
In[214]:= g3 = Plot[sol2, {x, -2, 7}]
-2 2 4 6
-20
-10
10
20
30
Out[214]= ~ Graphics ~
intromat.nb 26
In[215]:= Show[g1, g3]
-2 2 4 6
-20
-10
10
20
30
Out[215]= ~ Graphics ~
Por supuesto, en este caso el polinomio adecuado es de orden 2, pero esto puede no saberse en situaciones reales.
Podemos comparar las dos soluciones:
In[216]:= Show[g1, g2, g3]
-2 2 4 6
-20
-10
10
20
30
Out[216]= ~ Graphics ~
El problema tambin puede resolverse fcilmente programando la solucin en el lenguaje de Mathematica. Pero en este caso resulta mucho ms
conveniente utilizar la funcin incorporada Fit.
Borramos:
In[217]:= Remove["Global+"]
Grficos
Son expresiones como las dems, pero hay funciones que, como efecto colateral, las muestran.
Las expresiones grficas combinan en listas anidadas primitivas grficas (puntos, lneas, etc.) y directivas grficas
(tamaos, colores, ancho, etc.):
In[218]:= dibu = {
{RGBColor[1, 0.5, 0], PointSize[0.05], Point[{1, 4}], Point[{-2, 2}]},
{RGBColor[1, 0, 1], AbsoluteThickness[2],
Line[{{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}]}
};
intromat.nb 27
In[219]:= Graphics[dibu] // Show[#, AspectRatio - Automatic, Frame - True] &;
-2 -1.5 -1 -0.5 0 0.5 1
0
1
2
3
4
Tambin hay primitivas 3D. (Y visores OpenGL gratuitos.)
Se pueden exportar los objetos grficos a cualquier formato (jpeg, eps, etc.).
Otras cosas
Se puede invocar una funcin de varias maneras:
In[220]:= Sqrt[4]
Out[220]= 2
In[221]:= Sqrt4
Out[221]= 2
In[222]:= 4 // Sqrt
Out[222]= 2
Los corchetes son los ms seguros porque no hay problema de ambigedad. Las dos barras sirven para tomar toda la expresin de la izquierda y
aplicar finalmente una funcin.
En una celda podemos poner varias expresiones que se evaluarn una detrs de otra. Si no deseamos mostrar el resultado de una expresin
ponemos punto y coma detrs.
In[223]:= 2 + 2
3 + 3;
4 + 4
Out[223]= 4
Out[225]= 8
Cuando estamos corrigiendo la definicin de un smbolo que tenga varias reglas asociadas, conviene poner Clear al principio para que cada vez que
se evale el juego de definiciones, las reglas anteriores, errneas, se borren. Si no se hace as puede ser que en las pruebas se obtengan
resultados incorrectos.
In[226]:= f[x_Integer] := 3 x
intromat.nb 28
In[227]:= f[3]
Out[227]= 9
Si ahora cambiamos la definicin
In[228]:= f[x_] := 2 x
El resultado no cambia porque toma la regla anterior que es ms especfica:
In[229]:= f[3]
Out[229]= 9
Las dos reglas coexisten:
In[230]:= f[3.0]
Out[230]= 6.
En estos casos conviene borrar al principio las definiciones del smbolo para que se quede slo con las definiciones explcitamente evaluadas
despus.
In[231]:= Clear[f]
f[x_] := 2 x
In[233]:= f[3]
Out[233]= 6
Por supuesto, en programas grandes conviene organizar un documento con secciones de definicin, de ejemplos de uso, etc.
Borramos:
In[234]:= Remove["Global+"]
intromat.nb 29