Mathematica como lenguaje de programación

(1)

Chapter 1 Mathematica como lenguaje de

programaci´

on

1.1 Fundamentos del Lenguaje

Expresiones:

En Mathematica todo es una expresi´on. Hay dos tipos de expresiones:

• Expresiones Normales, las cuales son de la forma:

head[part1,par2,...]

donde head, part1, part2,... son expresiones.

• ´Atomos: los cuales son s´ımbolos, n´umeros y strings, por ejemplo: Sin[Log[2.5,7]]

Esto es es una funci´on donde Sin y Log son s´ımbolos. RGBColor[1,0,0]

que NO es una funci´on.

Observación: En Mathematica toda expresión puede ser construida usando átomos, paréntesis cuadrados y comas.

Ejemplo:

In[1]:= a*a + D[a^3,a] Out[1]= 4a^2

(2)

Cuya f´ormula completa es:

In[3]:= FullForm[a*a + D[a^3,a]] Out[3]= Times[4,Power[a,2]]

Nota: +, -, *, /, entre otros, son llamados “S´ımbolos especiales de entrada”, pues por ejemplo cuando se ejecuta 2+3 realmente Mathematica ejecuta Plus[2,3].

Obs: [ ] FullForm[4a^2] (retorna) [ ] Times[4,Power[a,2]]

1.1.1 Atomos

´

Un átomo es, en Mathematica, una expresión que no puede ser quebrada o dividida en expresiones más pequeñas de Mathematica. Hay tres tipos:

S´ımbolos: Un s´ımbolo es una secuencia de letras, d´ıgitos y el caracter $. Ejemplo:

[In1] a+b-2a [Out2] -a+b

N´umeros: Hay cuatro tipos:

Enteros dddd Reales ddd.ddd Racionales integer1/integer2 Complejos a+bI ( FullForm[a+bI] Complex[a,b]

Strings: Un string es una secuencia de caracteres encerrados por “...” Ejemplo:

"Hola"

1.1.2 Evaluaci´

on de expresiones

In[1]:=Trace[Sin[Log[2.5,7]]]

{{Log[2.5,7], _Log[2.5]Log[7] ,

{{Log[2.5],0.916}, 1

0.916,1.091},

{Log[7], 1.945},1.091,1.945,2.123},

(3)

1.2 Formas especiales de entrada

1.2.1 Operadores Aritm´

eticos:

S´ımbolos aritm´eticos Ejemplo:

3*2^4 -> Times[3,Power[2,4]]

1.2.2 Operadores Relacionales y Booleanos:

Esto son:

< , <=, > , >=, ==, !=, && (AND), || (OR)

Ejemplos:

7 > 4 && 2 != 3 True

5 > 4 > 3 True

Observaci´on: %n es equivalente a Out[n].

1.2.3 Operadores de Asignaci´

on:

Operador Ejemplo = x=y+z := x:=y+z += x+=y ⇔ x=x+y -= x-=y ⇔ x=x-y *= x*=y ⇔ x=x*y /= x/=y ⇔ x=x/y

(4)

1.3 Llamado a funciones

La sintaxis para invocar una funci´on es: f[x] (NO f(x))

Otras formas de invocar funciones son:

Notación Prefija: f @ x ⇔ f[x] f @ g @ h @ x ⇔ f[g[h[x]]] Notación Postfija: x // f ⇔ f[x] Sqrt[3] // N ⇔ N[Sqrt[3]] x // f // g ⇔ g[f[x]] a+b // f ⇔ f[a+b] Notación infija: x ~ f ~ y ⇔ f[x,y]

1.4 Definici´

on de funciones

En Mathematica se defienen las funciones como sigue: Z[x_,y_] := x+y

La parte Z[x_,y_] se conoce como declaracion y la parte x+y es conocida como cuerpo. El “underscore” en x_ y y_ son importantes pues indican que x y y son par´ametros formales. Estos “underscore” se conocen como blancos.

Invocaci´on: x := 1 y := Log[2] Z[Sqrt[3],2 Pi] Sqrt[3]+2 Pi

La definci´on de Z se pudo hacer de la siguiente manera: Z[x_,y_] = x + y

x + y

Nota: El valor de retorno de la función es el cálculo que se haga en la última l´ınea la cual no lleva ;.

(5)

1.5 Listas

Las listas son la estructura de datos b´asica y fundamental en Mathematica. Ejemplos:

{1, x, i+j} (Lista de tres elementos) FullForm[%]

List[1, x, Plus[i,j]]

En la mayor´ıa de los contextos de Mathematica se requieren listas, por ejemplo: Plot3D[Sin[xy],{x, 0, Pi},{x, 0, Pi}]

Ejemplos: In[21]:=S={{a, b}, {c, d}, {e, f }} Out[21]={{a,b},{c,d},{e,f}} In[22]:=S[[1]] Out[22]={a,b} In[23]:=%[[2]] Out[23]= b In[24]:=S[[1,2]] Out[24]=b

(6)

1.6 Reglas

Una entrada de la forma “a → b” se conoce como regla. Ejemplo:

ReplaceAll[x+x^2, x -> w] w + w^2

que es equivalente a: x+ x^2 /. x->w

Ejemplo: (La sustituci´on es no algebraica) ReplaceAll[x^2+ x^4, x^2-> w+1] 1 + w + x^4

1.7 Tipos

El lenguaje de programación de Mathematica, a diferencia de otros lenguajes, es muy débilmente tipificado. En general en las funciones NO se especifican los tipos de los parámetros. Sin embargo el tipos puede ser especificado como sigue:

fact[n_Integer]:= Product[i,{i,1,n}]

cuadrado[n_Integer | n_Real | n_Rational | n_Complex] := n^2 funcion[s_List] := ...

1.8 Variables Locales

Para evitar efectos colaterales en los programas, se deben usar variables locales, medi-anteM´odulos:

(7)

1.9 Algoritmo ´

optimo para calcular series

Entrada: x, n, f Calcula: Pn_k=0f (x, k) Paso 1: k ← a Paso 2: s ← 0 Paso 3: T ← f(a) Paso 4: Repita s ← s + T T ← T ∗³f (x,k+1)_{f (x,k)} ´ k ← k+1 Hasta k = n Ejemplo: Calcular cos(x) ≈ n X k=0 (−1)k_{∗ x}(2k) (2k)! ; x ∈ IR f (x, k + 1) f (x, k) = (−1)(k+1)_x(2k+2) (2k+2)! (−1)(k)_x(2k) (2k)! = (−1)x 2 (2k + 1)(2k + 2)

1.10 Programaci´

on Funcional

No se usa asignaci´on ni se usan ciclos. En lugar de esto se usan:

• Los datos se mueven a trav´es de funciones, mediante el paso de par´ametros. • Se usa recursividad, Apply y Map.

• Las funciones tienen como argumento a funciones y retornan funciones.

Map y Apply:

Map[f,a,b,c] =⇒ f[a], f[b], f[c] Apply[f,a,b,c] =⇒ f[a,b,c] Ejemplo: Promedio[s_list]:=Apply[Plus,s]/Length[s] Promedio[{2,4,9,4,3}] 22/5"

(8)

Lo anterior se pudo hacer con ciclos, pero es mecho mejor de esta forma.

Through:

Aplica una lista de funciones a un argumento. Ejemplo:

Through[{Sin, Cos, Tan][a]] =⇒ {Sin[a], Cos[a], Tan[a]}

1.10.1 Funciones An´

onimas (Funciones λ)

En muchas situaciones se requiere evaluar una funci´on, pero sin necesidad de darle un nombre, para no llenar la memoria (kernel) de nombres.

la sintaxis es: Function[{x}, Cuerpo] Ejemplos: Function[{x},x^2][5] =⇒ 25 Function[{x},x^2+y][3,2] =⇒ 11 Ejemplo:

Si se tienen definidas 2 funciones F[x] y G[x] y se desea aplicar la suma de F y G a una lista, la mejor forma de hacerlo es:

Map[Function[{x},F[x]+G[x]],a,b,c] =⇒ {F[a]+G[a],F[b]+G[b], F[c]+ G[c]}

Paradigma de la programaci´

on funcional.

Trate las estructuras matem´aticas como un todo, nunca las descomponga para reconstruirlas luego.