Modelización en Mathematica

Una guía introductoria

Christian Chase Solán

Sevilla, Junio 2012

- 1 -

Modelización en Mathemática

1. Wolfram Mathematica

Mathematica es un programa informático diseñado para la realización de cálculos

matemáticos, diferenciándose de otros programas, como Excel o Matlab, por ser capaz

de realizar cálculos simbólicos y no sólo numéricos. Técnicamente, este tipo de

programa se conoce como un sistema de computación algebraico (Computer Algebra

System, CAS de ahora en adelante).

A la hora de realizar un cálculo, un CAS trata las expresiones introducidas como

símbolos antes que números, así evitando realizar aproximaciones inexactas. Esto le

permite proceder a operar de forma similar a las personas cuando realizan cálculos

sobre papel y no caer en errores ilógicos. Veamos un ejemplo, para ilustrar esta

diferencia.

Tratemos la expresión √𝑎√𝑏 − √𝑎𝑏. Imaginemos que 𝑎 → 2 y 𝑏 → 3. Si cogemos una

calculadora cualquiera, por ejemplo la del Windows, e introducimos √2√3 − √61, nos

devuelve como resultado el número

6,8804689345196338581568642761386 · 10−38.

Sin embargo, nosotros sabemos que este resultado es incorrecto. Realizando la

diferencia a mano, obtenemos como resultado es cero, exacto. Aunque el error anterior

es muy, muy pequeño es demasiado para una operación tan elemental. Si introducimos

la diferencia, en términos de los parámetros a y b, en Mathematica (o cualquier otro

CAS) y sustituimos los mismos valores que hemos utilizado antes, 2 y 3, sí que nos

devuelve como resultado el número cero exacto.

¿Por qué ocurre esto? Esta diferencia en los resultados se debe al método de cálculo

que emplean la mayoría de sistemas operativos, llamado coma flotante, que sirve de

motor de cálculo de los programas que no son CAS. El cálculo de coma flotante consiste

en la representación de los números reales a través de aproximaciones. La forma más

habitual es la presentada, que representa los números reales como la multiplicación de

un número de dígitos significativos (que normalmente es fijo) por una base que permite

representar números de distinto tamaño. En la calculadora de Windows, el número de

dígitos significativos es 32 y la base es de exponenciales del número diez. Cuando la

calculadora de coma flotante trata algunos números, como pueden ser los irracionales

√2 y √3, sus aproximaciones son muy cercanos a los valores reales pero no son iguales.

De aquí el resultado distinto.

Mientras que no le impongamos la obligación de trabajar con números exactos,

Mathematica trata las expresiones como símbolos con unas determinadas propiedades.

Así, √𝑎2= 𝑎, √𝑎 √𝑏 = √𝑎𝑏, …, y por esto no comete el mismo fallo que los cálculos

con coma flotante.

Algunos de los CAS se han desarrollado como herramientas específicas para

algunos campos científicos y de ingeniería, pero Mathematica además se diferencia

dentro de los CAS por ser un programa de matemáticas generales que dispone de las

1 En el lenguaje de la calculadora de Windows, esta expresión sería 2^.5*3^.5-6^.5

- 2 -

herramientas necesarias para estudiar casi cualquier campo. Por tanto, es el

instrumento adecuado para el estudio que vamos a emprender.

Mathematica se divide en dos partes fundamentales: el kernel (núcleo) y el front-end

(interfaz gráfica de usuario, GUI, por sus siglas en inglés). El kernel es el cerebro de

Mathematica y procesa todas las órdenes que se proponen. Dispone de miles de

procedimientos y funciones pre-programadas que le permite resolver casi cualquier

problema en un tiempo mínimo.

El usuario no se relaciona directamente con el kernel, sino que lo hace a través del

front-end. El usuario ha de introducir sus órdenes en el interfaz, llamado notebook

(cuaderno) en Mathematica, y lo puede hacer de dos formas. La principal es utilizando

el lenguaje en código de Mathematica, que incluye miles de funciones pre-programadas

para realizar casi cualquier cálculo matemático y sigue, salvo algunas diferencias, la

notación matemática a la que estamos acostumbrados. La segunda forma es usando

plantillas preparadas, que son fundamentalmente para los usuarios nuevos que aún no

tienen soltura con el código. En ambos casos, una vez que hayamos introducido nuestro

input, ejecutamos nuestras órdenes pulsando el botón de “Intro” y el kernel comienza a

procesarlos, devolviendo unas salidas, output, con los resultados de sus cálculos. Si

hubiéramos cometido algún error en la especificación de nuestros órdenes, el kernel nos

devolvería un mensaje de error y no realizaría los cálculos.

Entendido esto, deberíamos tener una idea general del funcionamiento de

Mathematica.

2. Elementos básicos

Al iniciar Wolfram Mathematica, nos encontramos con una ventana principal que es

nuestro punto de partida. Desde aquí podemos elegir entre crear un nuevo notebook,

una presentación de transparencias, abrir un archivo usado recientemente o consultar

la gigantesca biblioteca de documentación sobre las funciones de Mathematica. Por

ahora, veamos las pautas principales del input en Mathemática y abramos un cuaderno

nuevo.

Figura 2.1. Pantalla de inicio de Wolfram Mathematica

El formato del input del lenguaje de Mathematica es muy similar al que se emplea al

escribir expresiones matemáticas a mano alzada. Así, si queremos hacer operaciones

básicas con números solo hemos de introducir la expresión que queremos. Por ejemplo,

- 3 -

Para sumar y restar simplemente usamos los signos "+" y "-", para dividir utilizamos

la barra "/" y para denotar un producto nos será suficiente poner un espacio entre los

números, parámetros o variables que queremos multiplicar. Para trabajar con potencias,

utilizamos "a^b", donde b es el exponente y a es la base.

Para algunas otras expresiones, sin embargo, hay diferencias sutiles entre la

notación matemática y el lenguaje de programación de Mathematica. Los ejemplos más

claros, y que realmente son los que más nos afectan a nosotros, se refieren a la

definición de funciones, el planteamiento de ecuaciones y la estructura de matrices y

vectores. Veamos un ejemplo con una función parabólica. A la hora de definir una

función sobre papel solemos escribir f(x)=x2, pero en Mathemática esta notación no nos

valdrá. Una función tendrá que tener la forma f[x1_, x2_, ..., xn_] seguida de la expresión

que caracteriza la función. Así, nuestro ejemplo sería,

Podremos utilizar cualquier combinación de letras como nombre (tag, etiqueta) de la

función mientras no esté protegido por alguna función pre-programada de Mathematica

(hemos utilizado f, pero podríamos haber puesto g, z, o incluso la palabra "función"). Las

variables de la función podrán ser tantas como nos hagan falta pero siempre tendrán

que ir seguido de una barra-baja. Si no incluimos este carácter, el kernel no reconocerá

el input como función sino que lo tratará como una identidad, es decir, cada vez que

aparezca f[x] lo reemplazará por x^2 pero no calculará f[3] ni ningún otro punto del

dominio de f. En el lenguaje de este programa, los corchetes [ ] son caracteres

fundamentales que utilizaremos para cualquier función, definida por nosotros o pre-

programada.

Cuando queramos plantear una ecuación también nos encontramos que la notación

matemática habitual no es válida. Si introducimos la ecuación 𝑥 = 3𝑥 + 6, tal y como lo

vemos, Mathematica no lo tratará como una ecuación sino, de nuevo, como una

identidad. Para que entienda que lo que buscamos es definir una ecuación, tendremos

que utilizar "==" en vez de "=". Entonces, nuestra ecuación en lenguaje Mathematica es

Una vez bien planteada, podremos proceder a resolver la ecuación utilizando la

funcion Solve["ecuación", "variables"],

- 4 -

Obsérvese que la solución aparece entre llaves. Esto es una lista, quizás el elemento

más importante del lenguaje de Mathematica. Las listas se denotan con las llaves "{ }" y

son fundamentales cuando queremos trabajar con más de un elemento a la vez. Por

ejemplo, imagina que hemos de resolver un sistema de ecuaciones que viene dado por

tres ecuaciones. Si introducimos las ecuaciones en la función Solve sin estructurarlo

como una lista, dará un error y no nos devolverá el resultado. Para definir una lista

introducimos {Elemento 1, Elemento 2, ...}, separados por comas. Una vez que

estructuremos las ecuaciones y las variables de esta forma, podremos resolver el

sistema. Imagina ahora que queremos resolver el sistema de ecuaciones 2𝑥 + 𝑦 = 3,

𝑥2 − 3𝑦 = 4. Entonces, el input sería

Hemos empezado nombrando las dos ecuaciones, para poder trabajar con ellos

fácilmente. Seguidamente, hemos definido nuestro sistema como una lista de

elementos, que en este caso son las ecuaciones. Aunque ahora mismo solo estamos

tratando el sistema anterior, cuando estemos programando desarrollos enteros este

procedimiento nos ahorrará mucho tiempo. Introduciendo esta lista en la función Solve

junto a la lista de variables, podemos ejecutar el comando.

Como nuestro sistema incluye una ecuación de segundo grado, tenemos dos

soluciones posibles. Si quisiéramos trabajar con estos valores, sustituyéndolas en otra

función, necesitaríamos poder elegir cuál de las soluciones queremos usar. Para ello

tenemos el comando [[a]], que nos permite extraer un elemento de una lista. Si

quisiéramos trabajar con la segunda solución solo tendríamos que poner este comando

al final de la línea de código. Además, este código podremos utilizarlo también con las

ecuaciones si solo queremos trabajar con uno de los lados de la expresión.

Si solo quisiéramos sustituir el valor de una de las variables de la lista, es decir,

solamente el valor de x de la segunda solución, utilizaríamos [a,b]. Este comando indica

al kernel coger el elemento b de la sublista a. En nuestro ejemplo, tendríamos

Estas listas también nos son fundamentales para definir vectores y matrices. Un

vector, en lenguaje de Mathematica, no es más que una lista de 𝑛 elementos y una

matriz no es más que una lista de listas. Veamos un ejemplo, llamemos matriz a una

matriz cuadrada de dimensión dos, entonces

- 5 -

Nuestra matriz está formada por una lista de dos sublistas y cada una de estas

sublistas corresponde a una fila. De la misma forma que hemos definido esta, podríamos

haber hecho una matriz de mayor dimensión, no cuadrada, etc. Al final de la línea de

código, hemos incluido un comando "//MatrixForm", que ha representado nuestra lista

de listas en su forma matricial. Normalmente, cuando empleemos una función que

comience con "//" al final de una línea de código, nuestro objetivo será cambiar la manera

de la que Mathematica representa las salidas. Así, podremos factorizar ("//Factor"),

descomponer ("//Expand"), simplificar ("//Simplify" o "//FullSimplify"), números exactos

("//N"), etc. Estas funciones son extremadamente útiles y aparecerán frecuentemente

en nuestros cuadernos.

Las listas son la pieza clave en el lenguaje de Mathematica. Cuando estemos

utilizando funciones que tienen muchas opciones posibles, por ejemplo las funciones

gráficas, veremos que las listas se utilizan para elegir cuál de las opciones se quiere, y

cuáles no, incluir en la función.

Si sabemos cómo definir funciones, ecuaciones y como utilizar las listas podremos

empezar a trabajar con Mathemática haciendo cálculos más básicos. Para ir al siguiente

nivel, tendremos que conocer las distintas funciones que incluye el programa. Como son

tantos no nos podemos parar a explicar cada uno sino que dedicaremos explicaciones

a los más relevantes para el estudio de los sistemas dinámicos. Todas estas aparecen

en la documentación de Mathematica, su navegador de funciones y en sus páginas web.

El navegador de funciones es posiblemente la herramienta más útil de Mathematica.

Cuando estemos en duda de cómo se utiliza una función, o simplemente queremos

saber si el programa es capaz de realizar un cierto proceso, no tenemos que hacer más

que entrar en la pestaña de Help > Function Navigator y nos aparecerá un glosario de

las funciones que tiene Mathemática, ordenadas según temática. Este navegador

dispone un buscador muy potente que nos permitirá hallar cualquier función con suma

facilidad. Una vez que hemos encontrado la función que buscábamos, podremos

acceder a un artículo que nos explica que estructura han de tener los elementos de la

función. Además, el artículo de cada función tiene varios ejemplos que funcionan, por lo

que podremos copiar y pegarlo a nuestro cuaderno y simplemente adaptarlo a nuestro

modelo.

- 6 -

Figura 2. El navegador de funciones

Existe además otra forma de resolver las dudas que tengamos acerca de una función,

pero esta requiere que conozcamos el nombre de la función. Si introducimos “?” seguido

del nombre de la función y sin espacio entre medias, nos aparecerá un breve resumen

de los contenidos del artículo del navegador de funciones. Así, para nuestro ejemplo

tendríamos que

Así, aunque nunca hayamos utilizado una función siempre tendremos a nuestra

disposición una información extremadamente completa sobre las características de

cada función y las relaciones entre varias de ellas.

Las funciones de representación gráfica también nos serán de gran utilidad cuando

trabajemos en Mathematica, por lo que es conveniente que tratemos su funcionamiento.

Existe un gran número de tipos de representaciones gráficas, desde representaciones

de funciones simples “plot[expresión, dominio]" a la representación de complejas

superficies en tres dimensiones ("Plot3D[]", "ContourPlot3D[]", etc.). La lista entera de

estas representaciones está disponible en el navegador de funciones. Veamos la

representación de la parábola que hemos definido antes.

- 7 -

El primer argumento es la función que queremos representar, seguido de varios

códigos que modifican el aspecto de la gráfica. Las funciones de formato de las gráficas

podemos encontrarlas en el artículo de la función Plot, o también en él de la función

Graphics, en el apartado de Detailes & Options. Hay una gran variedad de posibilidades,

que nos permiten obtener unas gráficas de muy alta calidad. Sin embargo, hay una

desventaja. Cuando se exportan para incluirlos en archivos Word, PowerPoint, etc.

Mathematica automáticamente reduce la calidad de la imagen, lo cual dificulta su

empleo fuera del Mathematica. Esto tiene solución con el comando export, pero aun así

el gráfico resultante no es de muy alta calidad.

Fundamentalmente utilizaremos dos funciones gráficas en nuestro tratamiento de los

modelos dinámicos: Plot[], para representar las funciones obtenidas en sistemas

dinámicos contínuos y ListPlot[], cuando sean sistemas dinámicos discretos.

Último, debemos mencionar la gran cantidad de contenido descargable que existe

para Mathematica. Este contenido está formado por programas, normalmente escritos

por personas ajenas a la organización de Wolfram, que sirve de extensión y permite

cubrir los vacíos que tiene Mathematica. Básicamente, son programas escritos que

añaden funciones a Mathematica, normalmente resumiendo programas que serían muy

largosy complicados de escribir. En este trabajo hemos utilizado, por ejemplo, el paquete

Dynamica ya que incorpora una función que nos permite dibujar cuencas de atracción,

además de diagramas de bifurcación, diagramas de escalera, etc. Cuando hayamos

descargado una extensión, tendremos que incorporarlo en la carpeta de AddOns de

Mathematica. Para encontrar la ubicación de esta carpeta, solo hemos de introducir

y nos indicará la dirección exacta en nuestro disco duro, donde solo tenemos que pegar

el archivo nuevo en la carpeta “AddOns”. Para utilizar el paquete nuevo, tenemos que

cargarlo antes de introducir cualquiera de sus funciones, ya que si no Mathematica nos

devolverá un mensaje de error. Para ello escribimos <<(NombreDeLaExtensión)`, sin

incluir los paréntesis. Así, para Dynamica sería

- 8 -

3. Mathematica y los sistemas dinámicos

Gracias a su gran poder cálculo, podremos estudiar sistemas dinámicos con bastante

facilidad. Sin embargo, hay que proceder de una forma u otra según el tipo de sistema

que corresponde a nuestro modelo y, por esto, hemos decidido dedicar una sección

entera a explicar detalladamente nuestro procedimiento para llevar a cabo el análisis de

un modelo.

En Mathematica un sistema dinámico discreto se puede tratar de forma muy similar

a la que vimos en el primer capítulo y resulta ser una combinación de los tres input que

hemos explicado antes (las funciones, las ecuaciones y las listas). Para que sea más

fácil de ver y comprender trabajaremos con la ayuda de un ejemplo, un sistema de

ecuaciones en diferencia lineal. Sea nuestro sistema de dos ecuaciones en diferencias,

El sistema que hemos elegido como ejemplo es un sistema de dos dimensiones con

dos variables, invariante respecto al tiempo, no homogénea y de primer orden. El primer

paso en el análisis es hallar el equilibrio o estado estacionario del sistema. Para ello

tendremos que sustituir las variables dependientes del tiempo por otras que sean

constantes en el tiempo. Esto se realiza con el comando "/." seguido de una flecha,

denotada con " - >" , que nos permite sustituir un determinado elemento por otra

expresión. Una vez que hayamos hecho esto, resolvemos con la función Solve[] el

sistema de ecuaciones resultante y habremos obtenido el equilibrio del sistema. Para el

caso de nuestro ejemplo,

Cuando el kernel nos devuelve la solución del sistema, vendrá en forma de lista de lista,

por lo que tendremos que extraer las con el comando [[1]] expresiones para obtener una

simple lista.

Obtenido el equilibrio, podemos proceder al análisis cualitativo del sistema. Para ello

es necesario que hallemos la matriz de coeficientes. En este caso sencillo la podemos

ver sin ninguna dificultad, pero en otros casos no está tan claro debido al número de

parámetros. Cuando estemos tratando sistemas lineales, la matriz de coeficientes y su

jacobiana coinciden, por lo que sólo tenemos que calcular esta matriz, que también

aparecerá cuando tratemos los modelos no lineales. Aplicando la definición de

Jacobiana utilizada en la sección 1.2., la jacobiana de nuestro sistema viene dado por

- 9 -

Por lo tanto, hemos escrito la jacobiana de nuestro sistema como una lista de listas

cuyos elementos son las derivadas parciales del lado derecho de las dos ecuaciones,

que se obtienen con la función D[expresión, variable]. Para seguir adelante con nuestro

estudio de la estabilidad, hemos de calcular los autovalores. Aunque podríamos plantear

y resolver la ecuación (𝐴 − 𝜆𝐼) = 0, Mathematica incorpora una función que calcula los

autovalores directamente. Es la función Eigenvalues[matriz en forma de lista].

Aplicándolo al ejemplo, tenemos que

Hemos obtenido unos autovalores en términos de los parámetros. Hemos tenido en

circunstancias parecidas cuando tratábamos el modelo de Cournot. Una forma rápida

de ver bajo qué circunstancias pertenecerán a la unidad los autovalores es utilizando la

función Reduce[expresión,variables], que funciona de forma similar a Solve, pero con

sistemas de inecuaciones. Si conocemos la relación entre una variable solo tendremos

que crear dos listas, una para cada autovalor, con todas las condiciones e introducirlos

en la función Reduce. Una vez ejecutada, esta nos devolverá las condiciones que han

de cumplirse para que se cumpla la desigualdad. Imaginemos que a>0, b>0, c<0, d<0 y

además a=b y c<d, entonces tendríamos para el primer autovalor

Las salidas aparecen de forma anidada y se interpretan leyendo desde fuera del

paréntesis hacia adentro. Para nuestro ejemplo, tenemos que, dada la igualdad a=b,

hay dos casos posibles que harían que el valor absoluto del autovalor fuera menor a la

unidad, que están separadas por "| |".

Este método no siempre nos valdrá, ya que si los parámetros son muchos y

disponemos de poca información sobre las relaciones entre ellas las salidas pueden ser

muy grandes e incomprensibles debido a la gran variedad de casos posibles. Con estos

casos optaremos por dar valor a los parámetros. Para ello, creamos una lista con los

valores de los parámetros y la sustituimos en la expresión de los autovalores

- 10 -

El valor absoluto de ambos autovalores es menor a la unidad, por lo tanto el sistema,

con estos valores, es estable. Sabiendo esto, pasemos a calcular sus trayectorias. Para

ello utilizamos la función RSolve. Esta función se aplica de la misma forma que Solve,

pero con la diferencia de que requiere tres elementos. El primero es el sistema de

ecuaciones en diferencias que queramos resolver, incluidas las condiciones iniciales de

cada variable de estado, el segundo es la lista de funciones dependientes del tiempo

que ha de encontrar y el tercero es la variable del tiempo, t. Una vez rellenados estos

campos, podemos ejecutar el comando y obtener las soluciones generales del sistema.

Fijando unas condiciones iniciales arbitrarias y aplicando RSolve a nuestro sistema con

los parámetros elegidos antes, tenemos

Es conveniente realizar representaciones gráficas del sistema para tener una idea

de cómo se desarrolla el sistema a través del tiempo. Nosotros emplearemos

principalmente dos tipos de gráficas para este fin. El primero representa las trayectorias

individuales de cada uno de los sistemas a través del tiempo. El segundo es la

representación del sistema en el plano de fases. Aquí no vemos la evolución del tiempo,

pero sí las distintas combinaciones de puntos que va tomando el sistema a lo largo de

su camino hacia el equilibrio. En ambos casos, tendremos que obtener los datos de

cada función en cada período de tiempo. Para ello, utilizamos la función Table, que nos

permite crear listas sustituyendo sucesivos valores, en nuestro caso del tiempo, en una

expresión determinada (que también puede ser una lista). Asignando un valor númerico

a las condiciones iniciales y planteando las tablas con las funciones que hemos obtenido

antes, tenemos

- 11 -

Al hacer las primeras dos tablas, hemos sustituido t=1,2,...,10 en {t, x[t]}. Para que

Mathematica entienda que x[t] es la función hallada de la solución general, es necesario

que sustituyamos este resultado en la función x[t] de la tabla. Podríamos haber calculado

estos datos sin el primer elemento de la lista, t, pero incluyéndolo obtenemos mejores

representaciones gráficas. Como estamos trabajando datos discretos, no podremos

utilizar la función de representación gráfica de funciones, Plot, sino que tendremos que

usar uno de sus variantes: ListPlot. Esta función representa las listas que se le

proporcionen (de nuevo, también listas de listas) en dos dimensiones y dispone de una

gran variedad de opciones de formato (todos las funciones Plot tienen estas opciones,

con la excepción de alguna de fin muy específico).

Los comandos de representar las dos trayectorias a través del tiempo son

Pasemos a representar las trayectorias en el plano de fases. De la misma forma que

antes, usamos la función Table para calcular los puntos y ListPlot para producir la

gráfica.

- 12 -

Esta vez hemos utilizado otro conjunto de mandos para representar la trayectoria en

el plano de fases. En vez de representar solamente la combinación de puntos o

solamente las líneas, hemos hecho dos gráficas separadas, uno de puntos y otro con

líneas, y los hemos ocultado. Para representarlos conjuntamente, hemos utilizado la

función Show. Esta función nos permite representar gráficas de forma conjunta,

combinando su información en una única representación. La mayor ventaja de esta

función es que nos permite mantener nuestro cuaderno ordenado, ya que podremos

elegir cuando queremos que aparezca o no una gráfica.

Observando la gráfica, podemos ver que empezando en el punto (8,-8), nuestro

sistema empieza a tomar valores cada vez más cercanos al equilibrio, (0,0), hasta

alcanzarlo.

Cuando sistema de ecuaciones en diferencias no es lineal, la función Rsolve no nos

devolverá la solución general del sistema, ya que muy rara vez tienen soluciones

explícitas este tipo de sistemas. Pero esto tiene una solución: el desarrollo de Taylor.

Aplicando el mismo procedimiento que seguimos para hallar la matriz de coeficientes

podremos linealizar el sistema alrededor de un punto fijo y estudiar su estabilidad y sus

trayectorias. Entonces, si nuestro sistema fuera

El equilibrio de este sistema es {2, 5}, por lo que tendríamos que realizar un cambio

de variable. Definamos u1(t)=x(t)-x* y u2(t)=y(t)-y*. Al hacer esto, nuestro sistema

linealizado será homogénea, por lo que su equilibrio será {0,0}. Primero, calculamos la

matriz jacobiana

- 13 -

Ahora volvemos a definir el sistema, pero esta vez en forma matricial. Utilizaremos las

nuevas variables además de la matriz jacobiana, que acabamos de calcular.

Este sistema es lineal, por lo que ya podremos estudiar su estabilidad, calcular su

solución general y representar sus trayectorias utilizando el procedimiento explicado

antes.

Sin embargo, para algunos sistemas dinámicos no lineales no es tan sencilla la

solución. Cuando la no linealidad se debe a que el sistema está definido a trozos, este

último procedimiento no nos valdrá ya que los sistemas pueden ir pasando de una rama

de la función a trozos a otra, por lo que están definidas por varias aplicaciones. Esto

significa que el modelo tiene muchas jacobianas y que además tendríamos que

programar de alguna manera que el sistema supiera cuando utilizar una aplicación en

vez de otra.

Tendremos que limitarnos a obtener resultados numéricos y no podremos obtener

las soluciones generales del sistema. Para obtener las trayectorias, tendremos que

hacer uso del comando Set::Delayed, ":=". Cuando definimos una función con este

operador, el kernel no evalúa la función hasta el momento en el que queramos utilizarla

en otro cálculo. Esto es muy útil porque las funciones que vamos a definir son recursivas.

Si usáramos el operador "=" en vez de SetDelayed, el Kernel nos devolvería un error de

límite de recursión. Veamos un ejemplo con x[t] e y[t], que han de ser mayores que cero.

Definimos las funciones recursivas y fijamos los valores iniciales de la siguiente forma:

Utilizando la función Table que vimos antes, podemos calcular los puntos de las dos

trayectorias y representarlas gráficamente.

- 14 -

Este método es muy útil para situaciones en las que no hay solución explícita, pero

tiene algunos inconvenientes. Una vez que hayamos definido las funciones recursivas,

con sus parámetros, no podremos modificarlos. Es decir, si calculamos los datos para

un conjunto de parámetros y decidimos cambiar un valor, tendremos que reiniciar el

kernel para realizar los nuevos cálculos. Otro problema es que no podremos utilizar esta

expresión en ninguna otra parte del cuaderno. Cuando estudiábamos sistemas

utilizando el procedimiento de ecuaciones, podíamos reutilizar variables una y otra vez

porque Mathematica no asignaba ninguna expresión a x[t]. Sin embargo, con

SetDelayed sí que lo hace.

Muchas veces nos encontraremos modelizando sistemas de gran dimensión y

manejando una gran cantidad de variables, funciones y ecuaciones. En estos casos el

único remedio es intentar mantener nuestro cuaderno de Mathematica lo más ordenada

posible. Si utilizamos nombres sistemáticos para todas las funciones, todo el proceso

de programación será mucho más fácil.

15