Found one more occurence of --enable-lang-es-utf8. Remove "-utf8".

[maxima/cygwin.git] / doc / tutorial / es / max.tex

\documentclass[11pt,titlepage,a4paper]{book}
        \pagestyle{headings}
        \title{\textbf{\Huge{Primeros pasos en Maxima}}}
        \author{\Large{Mario Rodr\'{\i}guez Riotorto}\\
          \\
          http://riotorto.users.sourceforge.net\\
          }

\usepackage{graphicx}
\usepackage{lscape}
\usepackage[spanish, activeacute]{babel}
\usepackage{amsfonts}
\usepackage{latexsym}
\usepackage{amsmath,amsthm}
\usepackage{hyperref}
\usepackage{makeidx}
\usepackage{psfrag}
\usepackage[latin1]{inputenc}
\usepackage{fancyvrb}
\decimalpoint

\hypersetup{colorlinks, citecolor=black, filecolor=black, linkcolor=black, urlcolor=black, pdftex}

\newcommand{\R}{\mathbb{R}}
\newcommand{\Q}{\mathbb{Q}}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\A}{\mathcal{A}}
\newcommand{\B}{\mathcal{B}}
\newcommand{\D}{\mathcal{D}}
\newcommand{\E}{\mathcal{E}}
\newcommand{\M}{\mathcal{M}}
\newcommand{\Pot}{\mathcal{P}}
\newcommand{\Salg}{\mathcal{S}}
\newcommand{\normal}{\mathcal{N}}
\newcommand{\region}{\mathcal{R}}

% \doublespacing

\makeindex

\hyphenation{co-rres-pon-dien-te}

%versión: 06-03-08
% Para generar el documento pdf con el índice alfabético:
% $ pdflatex max
% $ pdflatex max
% $ makeindex max.idx
% $ pdflatex max

% Para generar el documento html:
% $ latex2html max.tex

\begin{document}

\maketitle

\thispagestyle{empty}
\newpage

\newpage

\thispagestyle{empty}
\begin{quote}
Copyright \copyright 2004-2011 Mario Rodríguez Riotorto

Este documento es libre; se puede redistribuir y/o
modificar bajo los términos de la GNU General Public License
tal como lo publica la Free Software Foundation.
Para más detalles véase la GNU General Public License
en http://www.gnu.org/copyleft/gpl.html

\emph{This document is free; you can redistribute
it and/or modify it under the terms of the
GNU General Public License as published by
the Free Software Foundation. See the 
GNU General Public License for more details at \\
http://www.gnu.org/copyleft/gpl.html}
\end{quote}

\newpage
\thispagestyle{empty}






\addtocounter{page}{-3}
\tableofcontents




\chapter{Introducción}

Este es un manual introductorio al entorno de cálculo simbólico Maxima, directo sucesor del legendario Macsyma.

El objetivo del manual es facilitar el acceso a este programa a todas aquellas personas que por vez primera se acercan a él.

Maxima es un programa cuyo objeto es la realización de cálculos matemáticos, tanto simbólicos como numéricos; es capaz de manipular expresiones algebraicas y matriciales, derivar e integrar funciones, realizar diversos tipos de gráficos, etc.

Su nombre original fue Macsyma (\emph{MAC's SYmbolic MAnipulation System}, donde MAC, \emph{Machine Aided Cognition}, era el nombre del \emph{Laboratory for Computer Science}  del MIT durante la fase inicial del proyecto Macsyma). Se desarrolló en estos laboratorios a partir del año 1969 con fondos aportados por varias agencias gubernamentales norteamericanas (\emph{National Aeronautics and Space Administration}, \emph{Office  of  Naval Research}, \emph{U.S. Department of Energy} y \emph{U.S. Air Force}).

El concepto y la organización interna del programa están basados en la tesis doctoral que Joel Moses elaboró en el MIT sobre integración simbólica. Según Marvin Minsky, director de esta tesis, Macsyma pretendía automatizar las manipulaciones simbólicas que realizaban los matemáticos, a fin de entender la capacidad de los ordenadores para actuar de forma inteligente.

El año 1982 es clave. El MIT transfiere una copia de Macsyma a la empresa Symbolics Inc. para su explotación económica, haciendo el código propietario, y otra al Departamento de Energía, copia ésta que será conocida con el nombre de DOE-Macsyma. En 1992 la versión comercial de Macsyma sería adquirida por una empresa que se llamaría precisamente Macsyma Inc, y el programa iría perdiendo fuelle progresivamente ante la presencia en el mercado de otros programas similares como Maple o Mathematica, ambos los dos inspirados en sus orígenes en el propio Macsyma.

Pero ocurrieron dos historias paralelas. Desde el año 1982, y hasta su fallecimiento en el 2001, William Schelter de la Universidad de Texas mantuvo una versión de este programa adaptada al estándar Common Lisp en base a DOE-Macsyma, la cual ya se conoce con el nombre de Maxima para diferenciarla de la versión comercial. En el año 1998 Schelter había conseguido del DOE permiso para distribuir Maxima bajo la licencia GNU-GPL (www.gnu.org); con este paso, muchas más personas empezaron a dirigir su mirada hacia Maxima, justo en el momento en el que la versión comercial estaba declinando. Actualmente, el proyecto está siendo mantenido por un grupo de desarrolladores originarios de varios países, asistidos y ayudados por otras muchas personas interesadas en Maxima y que mantienen un cauce de comunicación a través de la lista de correo
\begin{center}
http://maxima.sourceforge.net/maximalist.html
\end{center}

Además, desde el año 2006, se ha activado una lista de correos para usuarios de habla hispana en
\begin{center}
http://lists.sourceforge.net/lists/listinfo/maxima-lang-es
\end{center}

Puesto que Maxima se distribuye bajo la licencia GNU-GPL, tanto el código fuente como los manuales son de libre acceso a través de la página web del proyecto,
\begin{center}
http://maxima.sourceforge.net
\end{center}

Uno de los aspectos más relevantes de este programa es su naturaleza libre; la licencia GPL en la que se distribuye brinda al usuario ciertas libertades:
\begin{itemize}
\item libertad para utilizarlo,
\item libertad para modificarlo y adaptarlo a sus propias necesidades,
\item libertad para distribuirlo,
\item libertad para estudiarlo y aprender su funcionamiento.
\end{itemize}

La gratuidad del programa, junto con las libertades recién mencionadas, hacen de Maxima una formidable herramienta pedagógica, de investigación y de cálculo técnico, accesible a todos los presupuestos, tanto institucionales como individuales.

No quiero terminar esta breve introducción sin antes recordar y agradecer a todo el equipo humano que ha estado y está detrás de este proyecto, desde el comienzo de su andadura allá por los años 70 hasta el momento actual; incluyo también a todas las personas que, aún no siendo desarrolladoras del programa, colaboran haciendo uso de él, presentando y aportando continuamente propuestas e ideas a través de las listas de correos. Un agradecimiento especial a Robert Dodier y James Amundson, quienes me brindaron la oportunidad de formar parte del equipo de desarrollo de Maxima y me abrieron las puertas a una experiencia verdaderamente enriquecedora.

Finalmente, un recuerdo a William Schelter. Gracias a él disponemos hoy de un Maxima que, paradójicamente, por ser libre, no pertenece a nadie pero que es de todos.

\begin{flushright}
\emph{Ferrol-A Coruña}
\end{flushright}








\newpage
\chapter{Despegando con Maxima}

\section{Instalación}

Maxima funciona en Windows, Mac y Linux.

En Windows, la instalación consiste en descargar el binario \verb|exe| desde el enlace correspondiente en la página del proyecto y ejecutarlo. 

En Mac, es necesario descargar el fichero con extensión \verb|dmg|, hacer doble clic sobre él y arrastrar los iconos de Maxima, wxMaxima y Gnuplot a la carpeta Aplicaciones. El proceso detallado se explica aquí:
\begin{center}
http://www.faq-mac.com/41547/instalacion-maximawxmaxima-mac-javier-arantegui
\end{center}

En Linux, la mayoría de las distribuciones tienen ficheros precompilados en sus respectivos repositorios con las extensiones \verb|rpm| o \verb|deb|, según el caso. Sin embargo, en algunas distribuciones las versiones oficiales no suelen estar muy actualizadas, por lo que podría ser recomendable proceder con la compilación de las fuentes, tal como se expone a continuación.

Las siguientes indicaciones sobre la compilación hacen referencia al sistema operativo Linux.

Si se quiere instalar Maxima en su estado actual de desarrollo, será necesario descargar los ficheros fuente completos desde el repositorio de Sourceforge y proceder posteriormente a su compilación. Se deberá tener operativo un entorno Common Lisp en la máquina (\verb|clisp|, \verb|cmucl|, \verb|sbcl| o \verb|gcl| son todas ellas alternativas válidas), así como todos los programas que permitan ejecutar las instrucciones que se indican a continuación, incluidas las dependencias \verb|tcl-tk| y \verb|gnuplot|. \emph{Grosso modo}, estos son los pasos a seguir para tener Maxima operativo en el sistema\footnote{Se supone que se trabaja con clisp, con codificación unicode y que queremos el sistema de ayuda en inglés y español.}:
\begin{enumerate}
\item Descargar las fuentes a un directorio local siguiendo las instrucciones que se indican en el enlace al repositorio de la página del proyecto.
\item Acceder a la carpeta local de nombre \verb|maxima| y ejecutar las instrucciones
\begin{verbatim}
./bootstrap
./configure --enable-clisp --enable-lang-es
make
make check
sudo make install
make clean
\end{verbatim}
\item Para ejecutar Maxima desde la línea de comandos (Figura~\ref{fig:texto}) se deberá escribir
\begin{verbatim}
maxima
\end{verbatim}
si se quiere trabajar con la interfaz gráfica (Figura~\ref{fig:xmaxima}), teclear
\begin{verbatim}
xmaxima
\end{verbatim}
\end{enumerate}

Otro entorno gráfico es Wxmaxima\footnote{http://wxmaxima.sourceforge.net} (Figura~\ref{fig:wxmaxima}), que se distribuye conjuntamente con los ejecutables para Windows y Mac. En Linux, una vez instalado Maxima, se podrá instalar este entorno separadamente.

Una cuarta alternativa, que resulta muy vistosa por hacer uso de \TeX, es la de ejecutar Maxima desde el editor Texmacs\footnote{http://www.texmacs.org} (Figura~\ref{fig:texmacs}).

Emacs es un editor clásico en sistemas Unix. Aunque hay varias formas de ejecutar Maxima desde Emacs, con el modo Imaxima\footnote{http://members3.jcom.home.ne.jp/imaxima} (Figura~\ref{fig:imaxima}) se consigue que los resultados estén formateados en \TeX. 

También se han desarrollado en los últimos años entornos web para Maxima\footnote{http://maxima.sourceforge.net/relatedprojects.html}.

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.73]{texto.pdf} 
\caption{Maxima desde la línea de comandos.}
\label{fig:texto}
\end{center}
\end{figure}

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.73]{xmaxima.pdf} 
\caption{Xmaxima, el entorno gráfico basado en tcl-tk.}
\label{fig:xmaxima}
\end{center}
\end{figure}

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.73]{wxmaxima.pdf} 
\caption{Wxmaxima, el entorno gráfico basado en wxwidgets.}
\label{fig:wxmaxima}
\end{center}
\end{figure}

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.73]{texmacs.pdf} 
\caption{Maxima desde Texmacs.}
\label{fig:texmacs}
\end{center}
\end{figure}

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.6]{imaxima.pdf} 
\caption{Maxima en Emacs.}
\label{fig:imaxima}
\end{center}
\end{figure}






\section{Una primera sesión}

En esta sesión se intenta realizar un primer acercamiento al programa a fin de familiarizarse con el estilo operativo de Maxima, dejando sus habilidades matemáticas para más adelante.

Una vez accedemos a Maxima, lo primero que vamos a ver será la siguiente información:

\begin{Verbatim}
Maxima 5.25.0 http://maxima.sourceforge.net
using Lisp CLISP 2.48 (2009-07-28)
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1) 
\end{Verbatim}

En primer lugar nos informa sobre la versión de Maxima que se está ejecutando y la URL del proyecto, a continuación indica qué entorno Lisp está dándole soporte al programa y la nota legal sobre la licencia, por supuesto GNU-GPL. Finaliza con un recordatorio a Schelter y cómo debemos proceder si encontramos un fallo en el programa, ayudando así a su mejora. Tras esta cabecera, muy importante, aparece el indicador \verb|(%i1)| esperando nuestra primera pregunta (\verb|i| de \emph{input}). Si queremos calcular una simple suma tecleamos la operación deseada seguida de un punto y coma (\verb|;|)\index{1@; (punto y coma)} y una pulsación de la tecla retorno

\begin{Verbatim}
(%i1) 45 + 23;
\end{Verbatim}
\[
68\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2)
\end{Verbatim}

Vemos que el resultado de la suma está etiquetado con el símbolo \verb|(%o1)| indicando que es la salida correspondiente a la primera entrada (\verb|o| de \emph{output}). A continuación \verb|(%i2)| indica que Maxima espera nuestra segunda instrucción.

El punto y coma actúa también como un separador cuando escribimos varias instrucciones en un mismo renglón. Nuestra siguiente operación consistirá en asignar el valor 34578 a la variable \verb|x| y el 984003 a la \verb|y|, solicitando luego su producto,
\begin{Verbatim}
(%i2) x:34578; y:984003; x*y;
\end{Verbatim}
\[
34578\leqno{\tt (\%o2)}
\]
\[
984003\leqno{\tt (\%o3)}
\]
\[
34024855734\leqno{\tt (\%o4)}
\]
conviene prestar atención al hecho de que la asignación de un valor a una variable se hace con los dos puntos (\verb|:|)\index{35@: (operador de asignación)}, no con el signo de igualdad, que se reserva para las ecuaciones.

Es posible que no deseemos los resultados intermedios que Maxima va calculando o, como en este caso, las asignaciones a las variables que va haciendo; en tales situaciones debe hacerse uso del delimitador \verb|$|\index{3@\$}, que no devuelve los resultados que va calculando. Repitiendo el cálculo de la forma 
\begin{Verbatim}
(%i5) x:34578$ y:984003$ x*y;
\end{Verbatim}
\[
34024855734\leqno{\tt (\%o7)}
\]
podemos conseguir una salida más limpia. Las asignaciones a variables se mantienen activas mientras dure la sesión con Maxima, por lo que podemos restar las variables \verb|x| e \verb|y| anteriores
\begin{Verbatim}
(%i8) x-y;
\end{Verbatim}
\[
-949425\leqno{\tt (\%o13)}
\]

Esto tiene un riesgo; si queremos resolver la ecuación $x^2-3x+1=0$,
\begin{Verbatim}
(%i9) solve(x^2-3*x+1=0,x);
A number was found where a variable was expected -`solve'
 -- an error.  Quitting.  To debug this try debugmode(true);
\end{Verbatim}
nos devuelve un mensaje de error, ya que donde se supone que hay una incógnita, lo que realmente encuentra es un número, en este caso 34578. Hay dos formas de resolver esta situación; la primera consiste en utilizar el operador comilla simple (\verb|'|)\index{4@'}, que evita la evaluación de las variables:
\begin{Verbatim}
(%i9) solve('x^2-3*'x+1=0,'x);
\end{Verbatim}
\[
\left[ x=-{{\sqrt{5}-3}\over{2}} , x={{\sqrt{5}+3}\over{2}}
  \right] \leqno{\tt (\%o9)}
\]
\begin{Verbatim}
(%i10) x;
\end{Verbatim}
\[
34578\leqno{\tt (\%o10)}
\]
como se ve, \verb|x| mantiene su valor original.

La segunda forma de evitar este problema consiste en vaciar el contenido de la variable \verb|x| mediante la función \verb|kill|\index{kill},
\begin{Verbatim}
(%i11) kill(x)$
(%i12) solve(x^2-3*x+1=0,x);
\end{Verbatim}
\[
\left[ x=-{{\sqrt{5}-3}\over{2}} , x={{\sqrt{5}+3}\over{2}}
  \right] \leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) x;
\end{Verbatim}
\[
x\leqno{\tt (\%o13)}
\]
en este caso, \verb|x| ha perdido su valor.

Las etiquetas \verb|(%in)|\index{7@\%in} y \verb|(%on)|\index{8@\%on}, siendo \verb|n| un número entero, pueden ser utilizadas a lo largo de una sesión a fin de evitar tener que volver a escribir expresiones; así, si queremos calcular el cociente $\frac{x y}{x-y}$, con $x=34578$ y $y=984003$, podemos aprovechar los resultados \verb|(%o7)| y \verb|(%o8)| y hacer
\begin{Verbatim}
(%i14) %o7/%o8;
\end{Verbatim}
\[
-{{11341618578}\over{316475}}\leqno{\tt (\%o14)}
\]

Las etiquetas que indican las entradas y salidas pueden ser modificadas a voluntad haciendo uso de las variables \verb|inchar|\index{inchar} y \verb|outchar|\index{outchar},
\begin{Verbatim}
(%i15) inchar;
\end{Verbatim}
\[
{\it \%i}\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) outchar;
\end{Verbatim}
\[
{\it \%o}\leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) inchar: 'menda;
\end{Verbatim}
\[
\mbox{{}menda{}}\leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(menda18) outchar: 'lerenda;
\end{Verbatim}
\[
\mbox{{}lerenda{}}\leqno{\tt (lerenda18)}
\]
\begin{Verbatim}
(menda19) 2+6;
\end{Verbatim}
\[
8\leqno{\tt (lerenda19)}
\]
\begin{Verbatim}
(menda20) inchar:'%i$ outchar:'%o$
\end{Verbatim}
\begin{Verbatim}
(%i22)
\end{Verbatim}

Al final se han restaurado los valores por defecto.

En caso de que se pretenda realizar nuevamente un cálculo ya indicado deberán escribirse dos comillas simples (\verb|''|)\index{5@''}, no comilla doble, junto con la etiqueta de la instrucción deseada
\begin{Verbatim}
(%i23) ''%i8;
\end{Verbatim}
\[
x-984003\leqno{\tt (\%o23)}
\]

Obsérvese que al haber dejado a \verb|x| sin valor numérico, ahora el resultado es otro. Cuando se quiera hacer referencia al último resultado calculado por Maxima puede ser más sencillo hacer uso del símbolo  \verb|%|\index{6@\%}, de forma que si queremos restarle la \verb|x| a la última expresión podemos hacer
\begin{Verbatim}
(%i24) %-x;
\end{Verbatim}
\[
-984003\leqno{\tt (\%o24)}
\]

Ciertas constantes matemáticas de uso frecuente tienen un símbolo especial en Maxima: la base de los logaritmos naturales ($e$), el cociente entre la longitud de una circunferencia y su diámetro ($\pi$), la unidad imaginaria ($i=\sqrt{-1}$), la constante de Euler-Mascheroni ($\gamma=-\int_0^\infty e^{-x} \ln x dx$) y la razón aurea ($\phi=\frac{1+\sqrt{5}}{2}$), se representarán por \verb|%e|\index{9@\%e}, \verb|%pi|\index{11@\%pi}, \verb|%i|\index{10@\%i}, \verb|%gamma|\index{12@\%gamma} y \verb|%phi|\index{13@\%phi}, respectivamente.

Es muy sencillo solicitar a Maxima que nos informe sobre alguna función de su lenguaje; la técnica nos servirá para ampliar información sobre cualquier instrucción a la que se haga referencia en este manual, por ejemplo,
\begin{Verbatim}
(%i25) describe(sqrt);

 -- Función: sqrt (<x>)
     Raíz cuadrada de <x>. Se representa internamente por `<x>^(1/2)'.
     Véase también `rootscontract'.

     Si la variable `radexpand' vale `true' hará que las raíces
     `n'-ésimas de los factores de un producto que sean potencias de
     `n' sean extraídas del radical; por ejemplo, `sqrt(16*x^2)' se
     convertirá en `4*x' sólo si `radexpand' vale `true'.


  There are also some inexact matches for `sqrt'.
  Try `?? sqrt' to see them.

(%o25)                      true
\end{Verbatim}
nos instruye sobre la utilización de la función \verb|sqrt|. Alternativamente, se puede utilizar para el mismo fin el operador interrogación (\verb|?|)\index{36@? (operador interrogación)},
\begin{Verbatim}
(%i26) ? sqrt

 -- Función: sqrt (<x>)
     Raíz cuadrada de <x>. Se representa internamente por `<x>^(1/2)'.
     Véase también `rootscontract'.

     Si la variable `radexpand' vale `true' hará que las raíces
     `n'-ésimas de los factores de un producto que sean potencias de
     `n' sean extraídas del radical; por ejemplo, `sqrt(16*x^2)' se
     convertirá en `4*x' sólo si `radexpand' vale `true'.


  There are also some inexact matches for `sqrt'.
  Try `?? sqrt' to see them.

(%o26)                      true
\end{Verbatim}

Cuando no conocemos el nombre completo de la función sobre la que necesitamos información podremos utilizar el operador de doble interrogación (\verb|??|)\index{37@?? (operador doble interrogación)} que nos hace la búsqueda de funciones que contienen en su nombre cierta subcadena,
\begin{Verbatim}
(%i27) ?? sqrt

 0: isqrt  (Operadores generales)
 1: sqrt  (Operadores generales)
 2: sqrtdenest  (Funciones y variables para simplification)
 3: sqrtdispflag  (Operadores generales)
Enter space-separated numbers, `all' or `none': 3

 -- Variable opcional: sqrtdispflag
     Valor por defecto: `true'

     Si `sqrtdispflag' vale `false', hará que `sqrt' se muestre con el
     exponente 1/2.


(%o27)                      true
\end{Verbatim}

Inicialmente muestra un sencillo menú con las funciones que contienen la subcadena \verb|sqrt| y en el que debemos seleccionar qué información concreta deseamos; en esta ocasión se optó por \verb|3| que es el número asociado a la variable opcional \verb|sqrtdispflag|.

A fin de no perder los resultados de una sesión con Maxima, quizás con el objeto de continuar el trabajo en próximas jornadas, podemos guardar en un archivo aquellos valores que nos puedan interesar; supongamos que necesitamos almacenar el contenido de la variable \verb|y|, tal como lo definimos en la entrada \verb|(%i5)|, así como el resultado de la salida 
\verb|(%o9)|, junto con la instrucción que la generó, la entrada \verb|(%i9)|,
\begin{Verbatim}
(%i28) save("mi.sesion",y,resultado=%o9,ecuacion=%i9)$
\end{Verbatim}

Véase que el primer argumento de \verb|save|\index{save} es el nombre del archivo, junto con su ruta si se considera necesario, que la variable \verb|y| se escribe tal cual, pero que las referencias de las entradas y salidas deben ir acompañadas de un nombre que las haga posteriormente reconocibles.

Por último, la forma correcta de abandonar la sesión de Maxima es mediante
\index{quit}\begin{Verbatim}
(%i29) quit();
\end{Verbatim}

Abramos ahora una nueva sesión con Maxima y carguemos en memoria los resultados de la anterior sesión,
\index{load}\begin{Verbatim}
(%i1) load("mi.sesion")$
(%i2) y;
\end{Verbatim}
\[
984003\leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) ecuacion;
\end{Verbatim}
\[
\mathrm{solve}\left(x^2-3\,x+1=0 , x\right)\leqno{\tt (\%o3)}
\]
\begin{Verbatim}
(%i4) resultado;
\end{Verbatim}
\[
\left[ x=-{{\sqrt{5}-3}\over{2}} , x={{\sqrt{5}+3}\over{2}}
  \right] \leqno{\tt (\%o4)}
\]

Si ahora quisiéramos recalcular las soluciones de la ecuación, modificándola previamente de manera que el coeficiente de primer grado se sustituyese por otro número, simplemente haríamos
\index{subst}\index{ev}\begin{Verbatim}
(%i5) subst(5,3,ecuacion);
\end{Verbatim}
\[
\mathrm{solve}\left(x^2-5\,x+1=0 , x\right)\leqno{\tt (\%o5)}
\]
\begin{Verbatim}
(%i6) ev(%, nouns);
\end{Verbatim}
\[
\left[ x=-{{\sqrt{21}-5}\over{2}} , x={{\sqrt{21}+5}\over{2}}
  \right] \leqno{\tt (\%o6)}
\]

La función \verb|save| guarda las expresiones matemáticas en formato Lisp, pero a nivel de usuario quizás sea más claro almacenarlas en el propio lenguaje de Maxima; si tal es el caso, mejor será el uso de \verb|stringout|\index{stringout}, cuyo resultado será un fichero que también se podrá leer mediante \verb|load|.

Continuemos experimentando con esta segunda sesión de Maxima que acabamos de iniciar. 

Maxima está escrito en Lisp, por lo que ya se puede intuir su potencia a la hora de trabajar con listas; en el siguiente diálogo, el texto escrito entre las marcas \verb|/*| y \verb|*/| son comentarios que no afectan a los cálculos,

\begin{Verbatim}
(%i7) /* Se le asigna a la variable x una lista */
      x: [cos(%pi), 4/16, [a, b], (-1)^3, integrate(u^2,u)];
\end{Verbatim}
\[
\left[ -1 , {{1}\over{4}} , \left[ a , b \right]  , -1 , {{u^3
 }\over{3}} \right] \leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) /* Se calcula el número de elementos del último resultado */
      length(%);
\end{Verbatim}
\[
5\leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) /* Se transforma una lista en conjunto, */
      /* eliminando redundancias. Los         */
      /* corchetes se transforman en llaves   */
      setify(x);
\end{Verbatim}
\[
\left \{-1 , {{1}\over{4}} , \left[ a , b \right]  , {{u^3}\over{3
 }} \right \}\leqno{\tt (\%o9)}
\]

Vemos a continuación cómo se procede a la hora de hacer sustituciones en una expresión,

\begin{Verbatim}
(%i10) /* Sustituciones a hacer en x */
       x, u=2, a=c;
\end{Verbatim}
\[
\left[ -1 , {{1}\over{4}} , \left[ c , b \right]  , -1 , {{8}\over{3
 }} \right] \leqno{\tt (\%o10)}
\]
\begin{Verbatim}
(%i11) /* Forma alternativa para hacer lo mismo */
       subst([u=2, a=c],x);
\end{Verbatim}
\[
\left[ -1 , {{1}\over{4}} , \left[ c , b \right]  , -1 , {{8}\over{3
 }} \right] \leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) %o7[5], u=[1,2,3];
\end{Verbatim}
\[
\left[ {{1}\over{3}} , {{8}\over{3}} , 9 \right] \leqno{\tt (\%o12)}
\]

En esta última entrada, \verb|%o7| hace referencia al séptimo resultado devuelto por Maxima, que es la lista guardada en la variable \verb|x|, de modo que \verb|%o7[5]| es el quinto elemento de esta lista, por lo que esta expresión es equivalente a a \verb|x[5]|; después, igualando \verb|u| a la lista \verb|[1,2,3]| este quinto elemento de la lista es sustituído sucesivamente por las tres cantidades. Tal como ya se ha comentado, Maxima utiliza los dos puntos (\verb|:|) para hacer asignaciones a variables, mientras que el símbolo de igualdad se reserva para la construcción de ecuaciones.

Un aspecto a tener en cuenta es que el comportamiento de Maxima está controlado por los valores que se le asignen a ciertas variables globales del sistema. Una de ellas es la variable \verb|numer|\index{numer}, que por defecto toma el valor lógico \verb|false|, lo que indica que Maxima evitará dar resultados en formato decimal, prefiriendo expresiones simbólicas y fraccionarias,
\begin{Verbatim}
(%i13) numer;
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) sqrt(8)/12;
\end{Verbatim}
\[
{{2^ {- {{1}\over{2}} }}\over{3}}\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) numer:true$
(%i16) sqrt(8)/12;
\end{Verbatim}
\[
0.2357022603955159\leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) numer:false$  /*se reinstaura valor por defecto */
\end{Verbatim}

Sin embargo, en general será preferible el uso de la función \verb|float|\index{float},
\begin{Verbatim}
(%i18) float(sqrt(8)/12);
\end{Verbatim}
\[
0.2357022603955159\leqno{\tt (\%o18)}
\]

Las matrices también tienen su lugar en Maxima; la manera más inmediata de construirlas es con la instrucción \verb|matrix|\index{matrix},

\begin{Verbatim}
(%i19) A: matrix([sin(x),2,%pi],[0,y^2,5/8]);
\end{Verbatim}
\[
\begin{pmatrix}\sin x&2&\pi\cr 0&y^2&{{5}\over{8}}\cr \end{pmatrix}\leqno{\tt (\%o19)}
\]

\begin{Verbatim}
(%i20) B: matrix([1,2],[0,2],[-5,integrate(x^2,x,0,1)]);
\end{Verbatim}
\[
\begin{pmatrix}1&2\cr 0&2\cr -5&{{1}\over{3}}\cr \end{pmatrix}\leqno{\tt (\%o20)}
\]

\begin{Verbatim}
(%i21) A.B;  /* producto matricial */
\end{Verbatim}
\[
\begin{pmatrix}\sin x-5\,\pi&2\,\sin x+{{\pi}\over{3}}+4\cr -{{25}\over{8
 }}&2\,y^2+{{5}\over{24}}\cr \end{pmatrix} \leqno{\tt (\%o21)}
\]

En cuanto a las capacidades gráficas de Maxima, se remite al lector a la sección correspondiente.

A fin de preparar publicaciones científicas, si se quiere redactar documentos en formato \LaTeX, la función \verb|tex|\index{tex} de Maxima será una útil compañera; en el siguiente ejemplo se calcula una integral y a continuación se pide la expresión resultante en formato \TeX:

\begin{Verbatim}
(%i22) 'integrate(sqrt(a+x)/x^5,x,1,2) = integrate(sqrt(2+x)/x^5,x,1,2)$

(%i23) tex(%);
$$\int_{1}^{2}{{{\sqrt{x+4}}\over{x^5}}\;dx}={{5\,\sqrt{2}\,\log 
 \left(5-2\,\sqrt{2}\,\sqrt{3}\right)+548\,\sqrt{3}}\over{2048}}-{{15
 \,\sqrt{2}\,\log \left(3-2\,\sqrt{2}\right)+244}\over{6144}}$$
\end{Verbatim}

Al pegar y copiar el código encerrado entre los dobles símbolos de dólar a un documento \LaTeX, el resultado es el siguiente:

\[
\int_{1}^{2}{{{\sqrt{x+a}}\over{x^5}}\;dx}={{5\,\sqrt{2}\,\log
 \left(5-2\,\sqrt{2}\,\sqrt{3}\right)+548\,\sqrt{3}}\over{2048}}-{{15
 \,\sqrt{2}\,\log \left(3-2\,\sqrt{2}\right)+244}\over{6144}}
\]

Un comentario sobre la entrada \verb|%i22|. Se observa en ella que se ha escrito dos veces el mismo código a ambos lados del signo de igualdad. La única diferencia entre ambos es el apóstrofo que antecede al primer \verb|integrate|; éste es el operador de \emph{comilla simple}, ya anteriormente aparecido, que Maxima utiliza para evitar la ejecución de una instrucción, de forma que en el resultado la primera integral no se calcula, pero sí la segunda, dando lugar a la igualdad que se obtiene como resultado final. Las expresiones que en Maxima se marcan con la comilla simple para no ser evaluadas reciben el nombre de \emph{expresiones nominales}, en contraposición a las otras, conocidas como \emph{expresiones verbales}.

Ya se ha comentado más arriba cómo solicitar ayuda de Maxima. Algunos usuarios encuentran engorroso que la ayuda se interfiera con los cálculos; esto se puede arreglar con un mínimo de bricolage informático. Al tiempo que se instala Maxima, se almacena también el sistema de ayuda en formato \verb|html| en una determinada carpeta; el usuario tan sólo tendrá que buscar esta carpeta, en la que se encontrará la página principal \verb|maxima.html|, y hacer uso de la función \verb|system|\index{system} de Maxima que ejecuta comandos del sistema, la cual admite como argumento una cadena alfanumérica con el nombre del navegador (en el ejemplo, \verb|mozilla|) seguido de la ruta hacia el documento \verb|maxima.html|,

\begin{Verbatim}
(%i24)
system("(mozilla /usr/local/share/maxima/5.25.0/doc/html/es.utf8/maxima.html)&")$
\end{Verbatim}

Este proceso se puede automatizar si la instrucción anterior se guarda en un fichero de nombre \verb|maxima-init.mac| y se guarda en la carpeta hacia la que apunta la variable \verb|maxima_userdir|; por ejemplo, en Linux,

\begin{Verbatim}
(%i25) maxima_userdir;
\end{Verbatim}
$$\mbox{{}/home/xefe/.maxima{}}\leqno{\tt (\%o25)}$$

El fichero \verb|maxima-init.mac| se lee cada vez que arranca Maxima y se ejecutan las instrucciones contenidas en él; se puede utilizar para cargar automáticamente módulos adicionales que vayamos a utilizar con frecuencia, funciones especiales definidas por nosotros o, como en este caso, para que se abra el navegador con las páginas del manual.






\newpage
\chapter{Números y sus operaciones}






\section{Enteros y decimales}

Maxima puede trabajar con números enteros tan grandes como sea necesario,

\begin{Verbatim}
(%i1) 200!;
\end{Verbatim}
\[ 
\begin{array}{l}
7886578673647905035523632139321850622951359776871732632947425332443594\\
4996340334292030428401198462390417721213891963883025764279024263710506\\
1926624952829931113462857270763317237396988943922445621451664240254033\\
2918641312274282948532775242424075739032403212574055795686602260319041\\
7032406235170085879617892222278962370389737472000000000000000000000000\\
0000000000000000000000000\end{array}        \leqno{\tt (\%o1)}
\]


Los operadores aritméticos más comunes son:
\index{14@+}\index{16@-}\index{17@*}\index{18@/}\index{19@\^\ }\index{20@**}\begin{center}
\begin{tabular}{|c|l|} \hline
\verb|+|    & suma \\
\verb|-|    & resta \\
\verb|*|    & producto \\
\verb|/|    & división \\
\verb|^| o  \verb|**|  & potencia \\ \hline
\end{tabular}
\end{center}

Maxima devuelve los resultados de forma exacta, sin aproximaciones decimales; así tenemos que para realizar el cálculo de la expresión
\[
\left[
\left( \frac{3^7}{4+\frac{3}{5}} \right)^{-1} + \frac{7}{9}
\right]^3
\]
haremos


\begin{Verbatim}
(%i2) ((3^7/(4+3/5))^(-1)+7/9)^3;
\end{Verbatim}
\[
{{620214013952}\over{1307544150375}}\leqno{\tt (\%o2)}
\]
obteniendo el resultado en forma de fracción simplificada.

De todos modos podemos solicitar el resultado en forma decimal; por ejemplo, si queremos la expresión decimal del último resultado,
\index{float}\begin{Verbatim}
(%i3) float(%);
\end{Verbatim}
\[
0.4743350454163436\leqno{\tt (\%o3)}
\]

Maxima puede trabajar con precisión arbitraria. Para calcular el valor del cociente $\frac{e}{\pi}$ con 100 cifras decimales, deberemos especificar primero la precisión requerida asignándole a la variable \verb|fpprec|\index{fpprec} el valor 100 y a continuación realizar el cálculo, solicitando la expresión decimal con una llamada a la función \verb|bfloat|\index{bfloat}:
\index{fpprec}\index{bfloat}\begin{Verbatim}
(%i4) fpprec:100$  bfloat(%e / %pi);
\end{Verbatim}
\[
\begin{array}{l}
8.65255979432265087217774789646089617428744623908515539454330288948045\\
0445706770586319246625161845173_B \times 10^{-1}\end{array} \leqno{\tt (\%o5)}
\]

Nótese que cuando un resultado es devuelto en el formato \verb|bfloat| se escribe la letra \verb|B|\index{B} en lugar de la clásica \verb|E|\index{E} para indicar el exponente.

En la instrucción \verb|%i4| se establece la precisión deseada y luego se transforma el valor simbólico \verb|%e / %pi| mediante la función \verb|bfloat|. Recuérdese que el símbolo \verb|$| sirve como delimitador entre instrucciones.

Veamos cómo factorizar un números tal como $200!$ en sus factores primos,
\index{factor}\begin{Verbatim}
(%i6) factor(%o1);
\end{Verbatim}
\[
\begin{array}{l}
2^{197}\,3^{97}\,5^{49}\,7^{32}\,11^{19}\,13^{16}\,17^{11}\,19^{10}
 \,23^8\,29^6\,31^6\,37^5\,41^4\,43^4\,47^4\,53^3\,59^3\,61^3\,67^2\,71^2\\
 \,73^2\,79^2\,83^2\,89^2\,97^2\,101\,103\,107\,109\,113\,127\,131
 \,137\,139\,149\,151\,157\,163\,167\,173\\
\,179\,181\,191\,193\,197\,199\end{array}    \leqno{\tt (\%o6)}
\]

En la siguiente factorización hacemos uso de la variable global \verb|showtime|\index{showtime} para saber el tiempo que le lleva ejecutar el cálculo,
\index{33@/*...*/}\begin{Verbatim}
(%i7) showtime:true$
Evaluation took 0.00 seconds (0.00 elapsed) using 80 bytes.
(%i8) factor(2^300-1);
Evaluation took 0.86 seconds (0.85 elapsed) using 48.571 MB.
\end{Verbatim}
\[
\begin{array}{l}
3^2\,5^3\,7\,11\,13\,31\,41\,61\,101\,151\,251\,331\,601\,1201\,1321
 \,1801\,4051\,8101\,63901\,100801\\
 \,268501\,10567201\,13334701\,1182468601\,1133836730401\end{array}    \leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) /* desactivamos la información de los tiempos */
      showtime: false$
\end{Verbatim}
El texto que se escribe entre \verb|/*| y \verb|*/| son comentarios que Maxima ignora.

Además de la variable opcional \verb|showtime|, otro mecanismo de control de los tiempos de ejecución es la función \verb|time|\index{time},
\index{33@/*...*/}\begin{Verbatim}
(%i10) time(%o8);
\end{Verbatim}
\[
\left[ 1.7161081 \right] \leqno{\tt (\%o10)}
\]

En relación con los números primos, para saber si un número lo es o no,
\index{primep}\begin{Verbatim}
(%i11) primep(3^56-1);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o11)}
\]

Y para solicitarle a Maxima que compruebe si un número es par o impar necesitamos echar mano de las funciones \verb|evenp|\index{evenp} or \verb|oddp|\index{oddp}, respectivamente,
\begin{Verbatim}
(%i12) evenp(42);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) oddp(31);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o13)}
\]

Le solicitamos a Maxima que nos haga una lista con todos los divisores de un número,
\index{divisors}\begin{Verbatim}
(%i14) divisors(100);
\end{Verbatim}
\[
\left \{1 , 2 , 4 , 5 , 10 , 20 , 25 , 50 , 100 \right \}\leqno{\tt (\%o14)}
\]

En lo que concierne a la división, puede ser necesario conocer el cociente entero y el resto correspondiente; para ello se dispone de las funciones \verb|quotient|\index{quotient} y \verb|remainder|\index{remainder},
\begin{Verbatim}
(%i15) quotient(5689,214);
\end{Verbatim}
\[
26\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) remainder(5689,214);
\end{Verbatim}
\[
125\leqno{\tt (\%o16)}
\]





\section{Números complejos}

Como ya se comentó más arriba, la unidad imaginaria $\sqrt{-1}$ se representa en Maxima mediante el símbolo \verb|%i|\index{i},
\begin{Verbatim}
(%i1) %i^2;
\end{Verbatim}
\[
-1\leqno{\tt (\%o1)}
\]

Se soportan las operaciones básicas con números complejos,
\begin{Verbatim}
(%i2) z1:3+5*%i$ z2:1/2-4*%i$  /*z1 y z2*/
(%i4) z1 + z2;     /*suma*/
\end{Verbatim}
\[
i+{{7}\over{2}}\leqno{\tt (\%o4)}
\]
\begin{Verbatim}
(%i5) z1 - z2;     /*resta*/
\end{Verbatim}
\[
9\,i+{{5}\over{2}}\leqno{\tt (\%o5)}
\]
\begin{Verbatim}
(%i6) z1 * z2;     /*multiplicación*/
\end{Verbatim}
\[
\left({{1}\over{2}}-4\,i\right)\,\left(5\,i+3\right)\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) z1 / z2;     /* división */
\end{Verbatim}
\[
{{5\,i+3}\over{{{1}\over{2}}-4\,i}}\leqno{\tt (\%o7)}
\]

Es posible que estos dos últimos resultados nos parezcan frustrantes y los deseemos en otro formato; a tal efecto podemos pedir a Maxima que nos devuelva \verb|(%o6)| y \verb|(%o7)| en forma cartesiana,
\index{rectform}\begin{Verbatim}
(%i8) rectform(%o6);
\end{Verbatim}
\[
{{43}\over{2}}-{{19\,i}\over{2}}\leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) rectform(%o7);
\end{Verbatim}
\[
{{58\,i}\over{65}}-{{74}\over{65}}\leqno{\tt (\%o9)}
\]

Las funciones \verb|realpart|\index{realpart} e \verb|imagpart|\index{imagpart} extraen del número complejo sus partes real e imaginaria, respectivamente,
\begin{Verbatim}
(%i10) realpart(%o7);
\end{Verbatim}
\[
-{{74}\over{65}}\leqno{\tt (\%o10)}
\]
\begin{Verbatim}
(%i11) imagpart(%o7);
\end{Verbatim}
\[
{{58}\over{65}}\leqno{\tt (\%o11)}
\]

Antes hemos optado por los resultados en formato cartesiano; pero también es posible solicitarlos en su forma polar,
\index{polarform}\begin{Verbatim}
(%i12) polarform(%o7);
\end{Verbatim}
\[
{{2\,\sqrt{34}\,e^{i\,\left(\pi-\arctan \left({{29}\over{37}}
 \right)\right)}}\over{\sqrt{65}}}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) rectform(%);  /* forma rectangular */
\end{Verbatim}
\[
{{58\,\sqrt{34}\,i}\over{\sqrt{65}\,\sqrt{2210}}}-{{74\,\sqrt{34}
 }\over{\sqrt{65}\,\sqrt{2210}}}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) float(%);  /* formato decimal */
\end{Verbatim}
\[
0.8923076923076924\,i-1.138461538461538\leqno{\tt (\%o14)}
\]

El módulo de un número complejo se calcula con la función \verb|abs|\index{abs} y se le puede pasar el número tanto en su forma cartesiana como polar,
\begin{Verbatim}
(%i15) abs(%o9);
\end{Verbatim}
\[
{{2\,\sqrt{34}}\over{\sqrt{65}}}\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) abs(%o12);
\end{Verbatim}
\[
{{2\,\sqrt{34}}\over{\sqrt{65}}}\leqno{\tt (\%o16)}
\]

El argumento de un número complejo se calcula con la función \verb|carg|\index{carg}, que devuelve un ángulo en el intervalo $(-\pi, \pi]$,
\begin{Verbatim}
(%i17) carg(%o9);
\end{Verbatim}
$$\pi-\arctan \left({{29}\over{37}}\right)\leqno{\tt (\%o17)}$$

Por último, el conjugado de un número complejo se calcula con la función \verb|conjugate|\index{conjugate}. Como se ve en este ejemplo, el resultado dependerá del formato del argumento, cartesiano o polar,
\begin{Verbatim}
(%i18) conjugate(%o9);       /*forma cartesiana*/
\end{Verbatim}
\[
-{{58\,i}\over{65}}-{{74}\over{65}}\leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) conjugate(%o12);      /*forma polar*/
\end{Verbatim}
\[
-{{2\,\sqrt{34}\,e^{i\,\arctan \left({{29}\over{37}}\right)}}\over{
 \sqrt{65}}}\leqno{\tt (\%o19)}
\]




\section{Combinatoria}

Ya hemos visto el cálculo del factorial de un número natural, bien con el operador \verb|!|, bien con la función \verb|factorial|\index{factorial}; así podemos calcular el número de permutacions de $n$ elementos, $P_n = n!$,

\begin{Verbatim}
(%i1) /* permutaciones de 23 elementos */
      factorial(23);
\end{Verbatim}
$$25852016738884976640000\leqno{\tt (\%o1)}$$

Esto nos da el número de ordenaciones diferentes que se pueden hacer con $n$ objetos; si queremos generarlas podemos hacer uso de la función \verb|permutations|\index{permutations},

\begin{Verbatim}
(%i2) permutations([1,2,3]);
\end{Verbatim}
$$\left \{\left[ 1 , 2 , 3 \right]  , \left[ 1 , 3 , 2 \right]  , 
 \left[ 2 , 1 , 3 \right]  , \left[ 2 , 3 , 1 \right]  , \left[ 3 , 1
  , 2 \right]  , \left[ 3 , 2 , 1 \right]  \right \}\leqno{\tt (\%o2)}$$

Cuando se trabaja con factoriales, la función \verb|minfactorial|\index{minfactorial} puede ayudarnos a simplificar algunas expresiones,

\begin{Verbatim}
(%i3) n!/(n+2)!;
\end{Verbatim}
$${{n!}\over{\left(n+2\right)!}}\leqno{\tt (\%o3)}$$
\begin{Verbatim}
(%i4) minfactorial (%);
\end{Verbatim}
$${{1}\over{\left(n+1\right)\,\left(n+2\right)}}\leqno{\tt (\%o4)}$$

El cálculo del número de variaciones con repetición de $m$ elementos tomados de $n$ en $n$, $VR_m^n = m^n$, no necesita de ninguna función especial,

\begin{Verbatim}
(%i5) /* VR de 17 tomados de 4 en 4 */
      17^4;
\end{Verbatim}
$$83521\leqno{\tt (\%o5)}$$

Sin embargo, para calcular el número de variaciones sin repetición de $m$ elementos tomados de $n$ en $n$, 
$V_m^n = m!/(m-n)!$, debemos hacer uso de la función \verb|permutation|\index{permutation} definida en el módulo \verb|functs|, que tendremos que cargar en memoria previamente,

\begin{Verbatim}
(%i6) load("functs")$
(%i7) /* V de 17 tomados de 4 en 4 */
      permutation(17,4);
\end{Verbatim}
$$57120\leqno{\tt (\%o7)}$$

Nótese que podemos calcular $P_{23}$ con esta misma función, sin llamar al factorial,

\begin{Verbatim}
(%i8) /* permutaciones de 23 elementos, otra vez */
      permutation(23,23);
\end{Verbatim}
$$25852016738884976640000\leqno{\tt (\%o8)}$$

El número de combinaciones de $m$ elementos tomados de $n$ en $n$, $C_m^n = V_m^n / P_n$, se puede calcular con la función \verb|binomial|\index{binomial},

\begin{Verbatim}
(%i9) /* combinaciones de 30 elementos, tomados de 5 en 5 */
      binomial(30,5);
\end{Verbatim}
$$142506\leqno{\tt (\%o9)}$$

El número de permutaciones de $n$ elementos, con repeticiones $a_1, \ldots, a_k$,
$$
P_n^{a_1, \ldots, a_r} = \frac{(a_1+ \ldots + a_r)!}{a_1! \cdot \ldots \cdot a_r!},
$$
siendo $a_1+ \ldots + a_r = n$, se calcula con la función \verb|multinomial_coeff|\index{multinomial\_coeff},

\begin{Verbatim}
(%i10) /* permutaciones con repetición de 5 elementos,
         con repeticiones 2, 2 y 1 */
      multinomial_coeff(2,2,1);
\end{Verbatim}
$$30\leqno{\tt (\%o10)}$$

La función \verb|stirling1|\index{stirling1} calcula el número de Stirling de primera especie, $s(n,k)$, que se define de la forma
\[
(-1)^{n-k} \cdot s(n,k) = \mbox{Card} \{\sigma | \sigma \mbox{ es permutación de } \{1, \ldots, n\} \land \sigma \mbox{ tiene } k \mbox{ ciclos}\}
\]

\begin{Verbatim}
(%i11) stirling1(5,2);
\end{Verbatim}
$$-50\leqno{\tt (\%o11)}$$

Por otro lado, la función \verb|stirling2|\index{stirling2} calcula el número de Stirling de segunda especie, $S(n,k)$, que se define de la forma
 \[
S(n,k) = \mbox{Card} \{\pi | \pi \mbox{ es partición de } \{1, \ldots, n\} \land \mbox{Card}(\pi) = k \}
\]

\begin{Verbatim}
(%i12) stirling2(3,2);
\end{Verbatim}
$$3\leqno{\tt (\%o12)}$$

Esto es, hay 3 particiones de $\{1,2,3\}$ formadas por dos subconjuntos, las cuales podemos obtener invocando la función 
\verb|set_partitions|\index{set\_partitions},

\begin{Verbatim}
(%i13) set_partitions ({1,2,3}, 2);
\end{Verbatim}
$$\left \{\left \{\left \{1 \right \} , \left \{2 , 3 \right \}
  \right \} , \left \{\left \{1 , 2 \right \} , \left \{3 \right \}
  \right \} , \left \{\left \{1 , 3 \right \} , \left \{2 \right \}
  \right \} \right \}\leqno{\tt (\%o13)}$$

El número de Bell, que calculamos con la función \verb|belln|\index{belln} es el número total de particiones que admite un conjunto finito,
\[
B(n) = \sum_{k=1}^{n} S(n,k).
\]

\begin{Verbatim}
(%i14) /* número de particiones en un conjunto de cardinalidad 3 */
       belln(3);
\end{Verbatim}
$$5\leqno{\tt (\%o14)}$$

En relación con la combinatoria, véanse también las secciones \ref{conjuntos} y \ref{grafos}, sobre conjuntos y grafos, respectivamente.









\newpage
\chapter{Estructuras de datos}




\section{Listas}
\label{listas}

Las listas son objetos muy potentes a la hora de representar estructuras de datos; de hecho, toda expresión de Maxima se representa internamente como una lista, lo que no es de extrañar habida cuenta de que Maxima está programado en Lisp (\emph{List Processing}). Veamos cómo podemos ver la representación interna, esto es en Lisp, de una sencilla expresión tal como $1+3a$,
\index{31@:lisp}\begin{Verbatim}
(%i1) ?print(1+3*a)$
((MPLUS SIMP) 1 ((MTIMES SIMP) 3 $A))
\end{Verbatim}

Pero al nivel del usuario que no está interesado en las interioridades de Maxima, también se puede trabajar con listas como las definidas a continuación, siempre encerradas entre corchetes,
\index{34@[...]}\index{32@``...''}\begin{Verbatim}
(%i2) r:[1,[a,3],sqrt(3)/2,"Don Quijote"];
\end{Verbatim}
\[
\left[ 1 , \left[ a , 3 \right]  , {{\sqrt{3}}\over{2}} , 
 \mbox{{}Don Quijote{}} \right] \leqno{\tt (\%o2)}
\]

Vemos que los elementos de una lista pueden a su vez ser también listas, expresiones matemáticas o cadenas de caracteres incluidas entre comillas dobles, lo que puede ser aprovechado para la construcción y manipulación de estructuras más o menos complejas. Extraigamos a continuación alguna información de las listas anteriores,
\index{listp}\index{first}\index{second}\index{third}\index{last}\index{rest}\index{part}\index{length}\index{reverse}\index{member}\index{sort}\index{delete}\begin{Verbatim}
(%i3) listp(r); /* es r una lista? */
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o3)}
\]
\begin{Verbatim}
(%i4) first(r); /* primer elemento */
\end{Verbatim}
\[
1\leqno{\tt (\%o4)}
\]
\begin{Verbatim}
(%i5) second(r); /* segundo elemento */
\end{Verbatim}
\[
\left[ a , 3 \right] \leqno{\tt (\%o5)}
\]
\begin{Verbatim}
(%i6) third(r); /* ...hasta tenth */
\end{Verbatim}
\[
{{\sqrt{3}}\over{2}}\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) last(r); /* el último de la lista */
\end{Verbatim}
\[
\mbox{{}Don Quijote{}}\leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) rest(r); /* todos menos el primero */
\end{Verbatim}
\[
\left[ \left[ a , 3 \right]  , {{\sqrt{3}}\over{2}} , 
 \mbox{{}Don Quijote{}} \right] \leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) part(r,3); /* pido el que quiero */
\end{Verbatim}
\[
{{\sqrt{3}}\over{2}}\leqno{\tt (\%o9)}
\]
\begin{Verbatim}
(%i10) length(r); /* ¿cuántos hay? */
\end{Verbatim}
\[
4\leqno{\tt (\%o10)}
\]
\begin{Verbatim}
(%i11) reverse(r); /* le damos la vuelta */
\end{Verbatim}
\[
\left[ \mbox{{}Don Quijote{}} , {{\sqrt{3}}\over{2}} , \left[ a , 3
  \right]  , 1 \right] \leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) member(a,r); /* ¿es a un elemento?*/
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) member([a,3],r); /* ¿lo es [a,3]? */
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) /* asigno valor a q y ordeno */
       sort(q: [7,a,1,d,5,3,b]);
\end{Verbatim}
\[
\left[ 1 , 3 , 5 , 7 , a , b , d \right] \leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) delete([a,3],r); /* borro elemento */
\end{Verbatim}
\[
\left[ 1 , {{\sqrt{3}}\over{2}} , \mbox{{}Don Quijote{}} \right] \leqno{\tt (\%o15)}
\]
Nótese que en todo este tiempo la lista \verb|r| no se ha visto alterada,
\begin{Verbatim}
(%i16) r;
\end{Verbatim}
\[
\left[ 1 , \left[ a , 3 \right]  , {{\sqrt{3}}\over{2}} , 
 \mbox{{}Don Quijote{}} \right] \leqno{\tt (\%o16)}
\]

Algunas funciones de Maxima permiten añadir nuevos elementos a una lista, tanto al principio como al final,
\index{cons}\index{endcons}\begin{Verbatim}
(%i17) cons(1+2,q);
\end{Verbatim}
\[
\left[ 3 , 7 , a , 1 , d , 5 , 3 , b \right] \leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) endcons(x,q);
\end{Verbatim}
\[
\left[ 7 , a , 1 , d , 5 , 3 , b , x \right] \leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) q;
\end{Verbatim}
\[
\left[ 7 , a , 1 , d , 5 , 3 , b \right] \leqno{\tt (\%o19)}
\]

En este ejemplo hemos observado también que la lista \verb|q| no ha cambiado. Si lo que queremos es actualizar su contenido,
\begin{Verbatim}
(%i20) q: endcons(x,cons(1+2,q))$
(%i21) q;
\end{Verbatim}
\[
\left[ 3 , 7 , a , 1 , d , 5 , 3 , b , x \right] \leqno{\tt (\%o21)}
\]

Es posible unir dos listas,
\index{append}\begin{Verbatim}
(%i22) append(r,q);
\end{Verbatim}
\[
\left[ 1 , \left[ a , 3 \right]  , {{\sqrt{3}}\over{2}} , 
 \mbox{{}Don Quijote{}} , 3 , 7 , a , 1 , d , 5 , 3 , b , x \right] \leqno{\tt (\%o22)}
\]

Cuando los elementos de una lista van a obedecer un cierto criterio de construcción, podemos utilizar la función \verb|makelist|\index{makelist} para construirla,
\begin{Verbatim}
(%i23) s:makelist(2+k*2,k,0,10);
\end{Verbatim}
\[
\left[ 2 , 4 , 6 , 8 , 10 , 12 , 14 , 16 , 18 , 20 , 22 \right] \leqno{\tt (\%o23)}
\]
donde le hemos indicado a Maxima que nos construya una lista con elementos de la forma \verb|2+2*k|, de modo que \verb|k| tome valores enteros de 0 a 10.

La función \verb|apply|\index{apply} permite suministrar a otra función todos los elementos de una lista como argumentos, así podemos sumar o multiplicar todos los elementos de la lista \verb|s| recién creada,
\index{14@+}\index{16@*}\begin{Verbatim}
(%i24) apply("+",s);
\end{Verbatim}
\[
132\leqno{\tt (\%o24)}
\]
\begin{Verbatim}
(%i25) apply("*",s);
\end{Verbatim}
\[
81749606400\leqno{\tt (\%o25)}
\]
aunque estas dos operaciones hubiese sido quizás más apropiado haberlas realizado con las funciones \verb|sum|\index{sum} y \verb|product|\index{product}.

A veces interesará aplicar una misma función a varios elementos de una lista de forma independiente, para lo que haremos uso de \verb|map|\index{map}. A continuación un ejemplo de cálculo de factoriales y otro trigonométrico; en este último, no es necesario aplicar \verb|map|, ya que algunas funciones se distribuyen automáticamente sobre los elementos de una lista,
\begin{Verbatim}
(%i26) map("!",s);
\end{Verbatim}
\[
\begin{array}{l}
\left[ 2 , 24 , 720 , 40320 , 3628800 , 479001600 , 87178291200 , 20922789888000 , \right.\\
  \left. 6402373705728000 , 2432902008176640000 , 1124000727777607680000
  \right]\end{array}  \leqno{\tt (\%o26)}
\]
\begin{Verbatim}
(%i27) sin(s);
\end{Verbatim}
\[
\left[ \sin 2 , \sin 4 , \sin 6 , \sin 8 , \sin 10 , \sin 12 , 
 \sin 14 , \sin 16 , \sin 18 , \sin 20 , \sin 22 \right] \leqno{\tt (\%o27)}
\]

A veces se quiere utilizar en \verb|map| una función que no está definida y que no va a ser utilizada más que en esta llamada a \verb|map|. En tales casos se puede hacer uso de las funciones \emph{lambda}\index{lambda}; supóngase que a cada elemento $x$ de una lista se le quiere aplicar la función $f(x)= \sin(x) + \frac{1}{2}$, sin necesidad de haberla definido previamente,

\begin{Verbatim}
(%i28) map(lambda([x], sin(x) + 1/2),[7,3,4,9]);
\end{Verbatim}
\[
\left[ \sin 7+{{1}\over{2}} , \sin 3+{{1}\over{2}} , \sin 4+{{1
 }\over{2}} , \sin 9+{{1}\over{2}} \right] \leqno{\tt (\%o28)}
\]

Como se ve, la función \emph{lambda} admite dos argumentos; el primero es una lista (no se puede evitar la redundancia) 
de argumentos, siendo el segundo la expresión que indica qué se hace con los elementos de la lista anterior.


Por último, las listas también pueden ser utilizadas en operaciones aritméticas. Algunas de las operaciones que se aplican a continuación no están definidas matemáticamente, por lo que Maxima se toma la libertad de definirlas por su cuenta, lo que redunda en un ahorro de código por parte del usuario y en un estilo de programación más compacto,
\index{14@+}\index{15@-}\index{16@*}\index{17@/}\index{18@\^\ }\index{21@.}\begin{Verbatim}
(%i29) [1,2,3]+[a,b,c];
\end{Verbatim}
\[
\left[ a+1 , b+2 , c+3 \right] \leqno{\tt (\%o29)}
\]
\begin{Verbatim}
(%i30) [1,2,3]*[a,b,c];
\end{Verbatim}
\[
\left[ a , 2\,b , 3\,c \right] \leqno{\tt (\%o30)}
\]
\begin{Verbatim}
(%i31) [1,2,3]/[a,b,c];
\end{Verbatim}
\[
\left[ {{1}\over{a}} , {{2}\over{b}} , {{3}\over{c}} \right] \leqno{\tt (\%o31)}
\]
\begin{Verbatim}
(%i32) [1,2,3]-[a,b,c];
\end{Verbatim}
\[
\left[ 1-a , 2-b , 3-c \right] \leqno{\tt (\%o32)}
\]
\begin{Verbatim}
(%i33) [1,2,3].[a,b,c]; /* producto escalar */
\end{Verbatim}
\[
3\,c+2\,b+a\leqno{\tt (\%o33)}
\]
\begin{Verbatim}
(%i34) [a,b,c]^3;
\end{Verbatim}
\[
\left[ a^3 , b^3 , c^3 \right] \leqno{\tt (\%o34)}
\]
\begin{Verbatim}
(%i35) 3^[a,b,c];
\end{Verbatim}
\[
\left[ 3^{a} , 3^{b} , 3^{c} \right] \leqno{\tt (\%o35)}
\]

En Maxima, las listas se pueden interpretar como vectores; para más información, acúdase a la Sección~\ref{vectores}.

Para que estas operaciones puedan realizarse sin problemas, la variable global \verb|listarith|\index{listarith} debe tomar el valor \verb|true|, en caso contrario el resultado será bien distinto,
\begin{Verbatim}
(%i36) listarith:false$
(%i37) [1,2,3]+[4,5,6];
\end{Verbatim}
\[
\left[ 4 , 5 , 6 \right] +\left[ 1 , 2 , 3 \right] \leqno{\tt (\%o37)}
\]
\begin{Verbatim}
(%i38) listarith:true$
\end{Verbatim}

Como ya se vió al comienzo de esta sección, una lista puede ser elemento de otra lista, si queremos deshacer todas las listas interiores para que sus elementos pasen a formar parte de la exterior,
\index{flatten}\begin{Verbatim}
(%i39) flatten([1,[a,b],2,3,[c,[d,e]]]);
\end{Verbatim}
\[
\left[ 1 , a , b , 2 , 3 , c , d , e \right] \leqno{\tt (\%o39)}
\]

El cálculo del módulo de un vector se puede hacer mediante la definición previa de una función al efecto:

\begin{Verbatim}
(%i40) modulo(v):=
          if listp(v)
             then sqrt(apply("+",v^2))
             else error("Mucho ojito: ", v, " no es un vector !!!!")$
(%i41) xx:[a,b,c,d,e]$
(%i42) yy:[3,4,-6,0,4/5]$
(%i43) modulo(xx-yy);
\end{Verbatim}
\[
\sqrt{\left(e-{{4}\over{5}}\right)^2+d^2+\left(c+6\right)^2+\left(b
 -4\right)^2+\left(a-3\right)^2}\leqno{\tt (\%o43)}
\]








\section{Arrays}
\label{arrays}

Los arrays son estructuras que almacenan datos secuencial o matricialmente. Se diferencian de las listas en que éstas pueden alterar su estructura interna y los arrays no; pero la ventaja frente a las listas estriba en que el acceso a un dato cualquiera es directo, mientras que en las listas, al ser estructuras dinámicas, para acceder al $n$-ésimo dato, un puntero debe recorrer todos los elementos de la lista desde el que ocupa el primer lugar. Así pues, se recomienda el uso de arrays cuando se vaya a utilizar una secuencia larga de expresiones cuya estructura se va a mantener inalterable; en general, se mejorarán los tiempos de procesamiento.

Si queremos construir un array, lo debemos declarar previamente mediante la función \verb|array|\index{array}, indicando su nombre y dimensiones; a continuación le asignaríamos valores a sus elementos,
\begin{Verbatim}
(%i1) array(arreglillo,2,2);
\end{Verbatim}
\[
{\it arreglillo}\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) arreglillo[0,0]: 34$
(%i3) arreglillo[1,2]:x+y$
(%i4) arreglillo[2,2]:float(%pi)$
(%i5) listarray(arreglillo);
\end{Verbatim}
\[
\begin{array}{l}
\left[ 34 , {\it \#\#\#\#\#} , {\it \#\#\#\#\#} , {\it \#\#\#\#\#} , {\it \#\#\#\#\#}  , \right. \\ 
 \left.  y+x , {\it \#\#\#\#\#} , {\it \#\#\#\#\#} , 3.141592653589793 \right] \end{array} \leqno{\tt (\%o5)}
\]

En el ejemplo, hemos definido un array de dimensiones 3 por 3, ya que la indexación de los arrays comienza por el cero, no por el uno como en el caso de las listas; a continuación hemos asignado valores a tres elementos del array: un entero, una expresión simbólica y un número decimal en coma flotante. Finalmente, la función \verb|listarray|\index{listarray} nos permite ver el contenido del array, utilizando el símbolo \verb|#####| para aquellos elementos a los que aún no se les ha asignado valor alguno.

Si ya se sabe de antemano que el array va a contener únicamente números enteros o números decimales, podemos declararlo al definirlo para que Maxima optimice el procesamiento de los datos. A continuación se declara un array de números enteros haciendo uso del símbolo \verb|fixnum|\index{fixnum} (en el caso de números decimales en coma flotante se utilizaría \verb|flonum|\index{flonum}) y a continuación la función \verb|fillarray|\index{fillarray} rellenará el array con los elementos previamente almacenados en una lista,
\begin{Verbatim}
(%i6) lis: [6,0,-4,456,56,-99];
\end{Verbatim}
\[
\left[ 6 , 0 , -4 , 456 , 56 , -99 \right] \leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) array(arr,fixnum,5);
\end{Verbatim}
\[
{\it arr}\leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) fillarray(arr,lis);
\end{Verbatim}
\[
{\it arr}\leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) arr[4];
\end{Verbatim}
\[
56\leqno{\tt (\%o9)}
\]
\begin{Verbatim}
(%i10) listarray(arr);
\end{Verbatim}
\[
\left[ 6 , 0 , -4 , 456 , 56 , -99 \right] \leqno{\tt (\%o10)}
\]

Hasta ahora hemos hecho uso de los llamados array declarados. Si no hacemos la declaración pertinente mediante la función \verb|array|, y en su lugar realizamos asignaciones directas a los elementos de la estructura, creamos lo que se conoce como array de claves (\emph{hash array}) o, en la terminología de Maxima, array no declarado; estos arrays son mucho más generales que los declarados, puesto que pueden ir creciendo de forma dinámica y los índices no tienen que ser necesariamente números enteros,
\begin{Verbatim}
(%i11) tab[9]:76;
\end{Verbatim}
\[
76\leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) tab[-58]:2/9;
\end{Verbatim}
\[
{{2}\over{9}}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) tab[juan]:sqrt(8);
\end{Verbatim}
\[
2^{{{3}\over{2}}}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) tab["cadena"]: a-b;
\end{Verbatim}
\[
a-b\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) tab[x+y]:5;
\end{Verbatim}
\[
5\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) listarray(tab);
\end{Verbatim}
\[
\left[ {{2}\over{9}} , 76 , a-b , 2^{{{3}\over{2}}} , 5 \right] \leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) tab["cadena"];
\end{Verbatim}
\[
a-b\leqno{\tt (\%o17)}
\]
Esta generalidad en la estructura de los arrays no declarados tiene la contrapartida de restarle eficiencia en el procesamiento de los datos almacenados, siendo preferible, siempre que sea posible, la utilización de los declarados.

Ya por último, junto con los arrays declarados y no declarados mencionados, es posible trabajar a nivel de Maxima con arrays de Lisp. En este caso su construcción se materializa con la función \verb|make_array|\index{make\_array},
\begin{Verbatim}
(%i18) a: make_array(flonum,5);
\end{Verbatim}
\[
\left\{ {\it Array}: \# \left(0.0 \;\; 0.0 \;\; 0.0 \;\; 0.0 \;\; 0.0\right)   \right\} \leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) a[0]:3.4;
\end{Verbatim}
\[
3.4\leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) a[4]:6.89;
\end{Verbatim}
\[
6.89\leqno{\tt (\%o20)}
\]
\begin{Verbatim}
(%i21) a;
\end{Verbatim}
\[
\left\{ {\it Array}: \# \left(3.4 \;\; 0.0 \;\; 0.0 \;\; 0.0 \;\; 6.89\right)   \right\} \leqno{\tt (\%o21)}
\]

Nótense aquí un par de diferencias respecto de la función \verb|array|: el número 5 indica el número de elementos (indexados de 0 a 4) y no el índice máximo admisible; por otro lado, la función no devuelve el nombre del objeto array, sino el propio objeto.









\section{Cadenas}

Una cadena se construye escribiendo un texto o cualquier otra expresión entre comillas dobles. Vamos a hacer algunos ejemplos básicos,
\begin{Verbatim}
(%i1) xx: "Los ";
\end{Verbatim}
\[
\mbox{{}Los {}}\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) yy: " cerditos";
\end{Verbatim}
\[
\mbox{{} cerditos{}}\leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) zz: concat(xx,sqrt(9),yy);
\end{Verbatim}
\[
\mbox{{}Los 3 cerditos{}}\leqno{\tt (\%o3)}
\]
la función \verb|concat|\index{concat} admite varios parámetros, los cuales evalúa y luego concatena convirtiéndolos en una cadena.

La función \verb|stringp|\index{stringp} nos indica si su argumento es o no una cadena,
\begin{Verbatim}
(%i4) stringp(zz);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o4)}
\]

Para saber el número de caracteres de una cadena haremos uso de \verb|slength|\index{slength}
\begin{Verbatim}
(%i5) slength(zz);
\end{Verbatim}
\[
14\leqno{\tt (\%o5)}
\]

Una vez transformada en cadena una expresión de Maxima, deja de ser evaluable, 
\begin{Verbatim}
(%i6) concat(sqrt(25));
\end{Verbatim}
\[
\mbox{{}5{}}\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) % + 2;
\end{Verbatim}
\[
\mbox{{}5{}}+2\leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) stringp(%);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o8)}
\]
el resultado no se simplifica porque uno de los sumandos es una cadena y no se reconoce como cantidad numérica.

La función \verb|charat|\index{charat} devuelve el carácter que ocupa una posición determinada,
\begin{Verbatim}
(%i9) charat(zz,7);
\end{Verbatim}
\[
\mbox{{}c{}}\leqno{\tt (\%o9)}
\]

También podemos solicitar que Maxima nos devuelva una lista con todos los caracteres o palabras que forman una cadena, 
\index{charlist}\index{tokens}
\begin{Verbatim}
(%i10) charlist(zz);
\end{Verbatim}
\[
\left[ \mbox{{}L{}} , \mbox{{}o{}} , \mbox{{}s{}} , \mbox{{} {}} , 
 \mbox{{}3{}} , \mbox{{} {}} , \mbox{{}c{}} , \mbox{{}e{}} , 
 \mbox{{}r{}} , \mbox{{}d{}} , \mbox{{}i{}} , \mbox{{}t{}} , 
 \mbox{{}o{}} , \mbox{{}s{}} \right] \leqno{\tt (\%o10)}
\]
\begin{Verbatim}
(%i11) tokens(zz);
\end{Verbatim}
\[
\left[ \mbox{{}Los{}} , \mbox{{}3{}} , \mbox{{}cerditos{}} \right] \leqno{\tt (\%o11)}
\]

O podemos transformar letras minúsculas en mayúsculas y viceversa, todas las letras o sólo un rango de ellas,
\index{supcase}\index{sdowncase}
\begin{Verbatim}
(%i12) /* todo a mayúsculas */
       supcase(zz); 
\end{Verbatim}
\[
\mbox{{}LOS 3 CERDITOS{}}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) /* a minúsculas entre la 9a y 12a */
       sdowncase(%,9,12);
\end{Verbatim}
\[
\mbox{{}LOS 3 CErdiTOS{}}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) /* a minúsculas de la 13a hasta el final */
       sdowncase(%,13);
\end{Verbatim}
\[
\mbox{{}LOS 3 CErdiTos{}}\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) /* todo a minúsculas */
       sdowncase(%);
\end{Verbatim}
\[
\mbox{{}los 3 cerditos{}}\leqno{\tt (\%o72)}
\]
\begin{Verbatim}
(%i16) /* a mayúsculas entre la 1a y 2a */
       supcase(%,1,2);
\end{Verbatim}
\[
\mbox{{}Los 3 cerditos{}}\leqno{\tt (\%o74)}
\]

Para comparar si dos cadenas son iguales disponemos de la función \verb|sequal|\index{sequal},
\begin{Verbatim}
(%i17) tt: zz;
\end{Verbatim}
\[
\mbox{{}Los 3 cerditos{}}\leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) sequal(tt,zz);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) tt: supcase(zz);
\end{Verbatim}
\[
\mbox{{}LOS 3 CERDITOS{}}\leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) sequal(tt,zz);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o20)}
\]

Podemos buscar subcadenas dentro de otras cadenas mediante la función \verb|ssearch|\index{ssearch}; los siguientes ejemplos pretenden aclarar su uso,
\begin{Verbatim}
(%i21) zz;
\end{Verbatim}
\[
\mbox{{}Los 3 cerditos{}}\leqno{\tt (\%o21)}
\]
\begin{Verbatim}
(%i22) /* busca la subcadena "cer" */
       ssearch("cer",zz);
\end{Verbatim}
\[
7\leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i23) /* busca la subcadena "Cer" */
       ssearch("Cer",zz);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o23)}
\]
\begin{Verbatim}
(%i24) /* busca "Cer" ignorando tamaño */
       ssearch("Cer",zz,'sequalignore);
\end{Verbatim}
\[
7\leqno{\tt (\%o24)}
\]
\begin{Verbatim}
(%i25) /* busca sólo entre caracteres 1 y 5 */
       ssearch("Cer",zz,'sequalignore,1,5);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o25)}
\]

Igual que buscamos subcadenas dentro de otra cadena, también podemos hacer sustituciones; en este caso la función a utilizar es \verb|ssubst|\index{ssubst},
\begin{Verbatim}
(%i26) ssubst("mosqueteros","cerditos",zz);
\end{Verbatim}
\[
\mbox{{}Los 3 mosqueteros{}}\leqno{\tt (\%o26)}
\]

Esta función tiene como mínimo tres argumentos, el primero indica la nueva cadena a introducir, el segundo es la subcadena a ser sustituída y el tercero la cadena en la que hay que realizar la sustitución. Es posible utilizar esta función con más argumentos; como siempre, para más información, \verb|? ssubst|.

Con la función \verb|substring|\index{substring} podemos obtener una subcadena a partir de otra, para lo cual debemos indicar los extremos de la subcadena,
\begin{Verbatim}
(%i27) substring(zz,7);
\end{Verbatim}
\[
\mbox{{}cerditos{}}\leqno{\tt (\%o27)}
\]
\begin{Verbatim}
(%i28) substring(zz,3,8);
\end{Verbatim}
\[
\mbox{{}s 3 c{}}\leqno{\tt (\%o28)}
\]

Como se ve, el segundo argumento indica la posición a partir de la cual queremos la subcadena y el tercero la última posición; si no se incluye el tercer argumento, se entiende que la subcadena se extiende hasta el final de la de referencia.

En algunos contextos el usuario tiene almacenada una expresión sintácticamente correcta de Maxima en formato de cadena y pretende evaluarla, en cuyo caso la función \verb|eval_string|\index{eval\_string} la analizará y evaluará, en tanto que \verb|parse_string|\index{parse\_string} la analiza pero no la evalúa, limitándose a transformarla a una expresión nominal de Maxima,
\begin{Verbatim}
(%i29) /* una cadena con una expresión de Maxima */
       expr: "integrate(x^5,x)";
\end{Verbatim}
\[
% \mbox{{}integrate(x^5,x){}}    \leqno{\tt (\%o29)}
\mbox{{}integrate(x\^{}5,x){}}    \leqno{\tt (\%o29)}
\]
\begin{Verbatim}
(%i30) /* se evalúa la cadena */
       eval_string(expr);
\end{Verbatim}
\[
{{x^6}\over{6}}\leqno{\tt (\%o30)}
\]
\begin{Verbatim}
(%i31) /* se transforma en una expresión nominal */
       parse_string(expr);
\end{Verbatim}
\[
{\it integrate}\left(x^5 , x\right)\leqno{\tt (\%o31)}
\]
\begin{Verbatim}
(%i32) ''%;
\end{Verbatim}
\[
{{x^6}\over{6}}\leqno{\tt (\%o32)}
\]

Véase que el resultado de \verb|parse_string| ya no es una cadena, sino una expresión correcta de Maxima sin evaluar, cuya evaluación se solicita a continuación con la doble comilla simple.

Para más información sobre el procesamiento de cadenas de texto, se sugiere la lectura del capítulo \verb|stringproc| del manual de referencia.







\section{Conjuntos}
\label{conjuntos}

Se define a continuación un conjunto mediante la función \verb|set|\index{set},
\begin{Verbatim}
(%i1) c1:set(a,[2,k],b,sqrt(2),a,set(a,b),
             3,"Sancho",set(),b,sqrt(2),a);
\end{Verbatim}
\[
\left \{3 , \sqrt{2} , \left \{ \right \} , \left[ 2 , k \right] 
  , \mbox{{}Sancho{}} , a , \left \{a , b \right \} , b \right \}\leqno{\tt (\%o1)}
\]

Como se ve, se admiten objetos de muy diversa naturaleza como elementos de un conjunto: números, expresiones, el conjunto vacío (\verb|{}|), listas, otros conjuntos o cadenas de caracteres. Se habrá observado que al construir un conjunto se eliminan las repeticiones de elementos, cual es el caso del símbolo $a$ en la lista anterior.

Cuando se trabaja con listas, puede ser de utilidad considerar sus componentes como elementos de un conjunto, luego se necesita una función que nos transforme una lista en conjunto,
\index{setify}\begin{Verbatim}
(%i2) [[2,k],sqrt(2),set(b,a),[k,2],"Panza"];
\end{Verbatim}
\[
\left[ \left[ 2 , k \right]  , \sqrt{2} , \left \{a , b \right \}
  , \left[ k , 2 \right]  , \mbox{{}Panza{}} \right] \leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) c2:setify(%);
\end{Verbatim}
\[
\left \{\sqrt{2} , \left[ 2 , k \right]  , \mbox{{}Panza{}} , 
 \left \{a , b \right \} , \left[ k , 2 \right]  \right \}\leqno{\tt (\%o3)}
\]
el cambio en la naturaleza de estas dos colecciones de objetos se aprecia en la presencia de llaves en lugar de corchetes. De igual manera, podemos transformar un conjunto en lista,
\index{listify}\begin{Verbatim}
(%i4) listify(%o1);
\end{Verbatim}
\[
\left[ 3 , \sqrt{2} , \left \{ \right \} , \left[ 2 , k \right]  , 
 \mbox{{}Sancho{}} , a , \left \{a , b \right \} , b \right] \leqno{\tt (\%o4)}
\]

Comprobemos de paso que \verb|{}| representa al conjunto vacío,
\index{emptyp}\begin{Verbatim}
(%i5) emptyp(%[3]);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o5)}
\]

Recuérdese que \verb|%| sustituye a la última respuesta dada por Maxima, que en este caso había sido una lista, por lo que \verb|%[3]| hace referencia a su tercera componente.

Para comprobar si un cierto objeto forma parte de un conjunto hacemos uso de la instrucción \verb|elementp|\index{elementp},
\begin{Verbatim}
(%i6) elementp(sqrt(2),c1);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o6)}
\]

Es posible extraer un elemento de un conjunto y luego añadirle otro distinto
\index{disjoin}\index{adjoion}\begin{Verbatim}
(%i7) c1: disjoin(sqrt(2),c1);  /* sqrt(2) fuera */
\end{Verbatim}
\[
\left \{3 , \left \{ \right \} , \left[ 2 , k \right]  , 
 \mbox{{}Sancho{}} , a , \left \{a , b \right \} , b \right \}\leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) c1: adjoin(sqrt(3),c1);  /* sqrt(3) dentro */
\end{Verbatim}
\[
\left \{3 , \sqrt{3} , \left \{ \right \} , \left[ 2 , k \right] 
  , \mbox{{}Sancho{}} , a , \left \{a , b \right \} , b \right \}\leqno{\tt (\%o8)}
\]

La sustitución que se acaba de realizar se pudo haber hecho con la función \verb|subst|\index{subst},
\begin{Verbatim}
(%i9) /* nuevamente a poner sqrt(2) */
      subst(sqrt(2),sqrt(3),c1);
\end{Verbatim}
\[
\left \{3 , \sqrt{2} , \left \{ \right \} , \left[ 2 , k \right] 
  , \mbox{{}Sancho{}} , a , \left \{a , b \right \} , b \right \}\leqno{\tt (\%o9)}
\]

La comprobación de si un conjunto es subconjunto de otro se hace con la fución \verb|subsetp|\index{subsetp},
\begin{Verbatim}
(%i10) subsetp(set([k,2],"Panza"),c2);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o10)}
\]

A continuación algunos ejemplos de operaciones con conjuntos,
\index{union}\index{intersection}\index{setdifference}\index{cardinality}\begin{Verbatim}
(%i11) union(c1,c2);
\end{Verbatim}
\[
\left \{3 , \sqrt{2} , \sqrt{3} , \left \{ \right \} , \left[ 2 , k
  \right]  , \mbox{{}Panza{}} , \mbox{{}Sancho{}} , a , \left \{a , b
  \right \} , b , \left[ k , 2 \right]  \right \}\leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) intersection(c1,c2);
\end{Verbatim}
\[
\left \{\left[ 2 , k \right]  , \left \{a , b \right \} \right \}\leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) setdifference(c1,c2);
\end{Verbatim}
\[
\left \{3 , \sqrt{3} , \left \{ \right \} , \mbox{{}Sancho{}} , a
  , b \right \}\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) cardinality(%);
\end{Verbatim}
\[
6\leqno{\tt (\%o14)}
\]

Vemos aquí también cómo pedir el cardinal de un conjunto.

Igual que se ha visto cómo aplicar una función a todos los elementos de una lista, podemos hacer lo mismo con los de un conjunto,
\index{map}\begin{Verbatim}
(%i15) map(sin,set(1,2,3,4,5));
\end{Verbatim}
\[
\left \{\sin 1 , \sin 2 , \sin 3 , \sin 4 , \sin 5 \right \}\leqno{\tt (\%o15)}
\]

Por último ya, el producto cartesiano de tres conjuntos,
\index{cartesianproduct@cartesian\_product}\begin{Verbatim}
(%i16) cartesian_product(set(1,2),set(a,b,c),set(x,y));
\end{Verbatim}
\[
\begin{array}{l}
\left \{\left[ 1 , a , x \right]  , \left[ 1 , a , y \right]  , 
 \left[ 1 , b , x \right]  , \left[ 1 , b , y \right]  , \left[ 1 , c
  , x \right]  , \left[ 1 , c , y \right]  , \right.\\
  \left. \left[ 2 , a , x \right]  , \left[ 2 , a , y \right]  , \left[ 2 , b , x \right]  , 
 \left[ 2 , b , y \right]  , \left[ 2 , c , x \right]  , \left[ 2 , c
  , y \right]  \right \}\end{array}       \leqno{\tt (\%o16)}
\]

Ya por último, el conjunto de las partes de un conjunto, o conjunto potencia, lo podemos obtener con la función \verb|powerset|\index{powerset}

\begin{Verbatim}
(%i17) powerset({1,a,sqrt(2)});
\end{Verbatim}
$$\left \{\left \{ \right \} , \left \{1 \right \} , \left \{1 , 
 \sqrt{2} \right \} , \left \{1 , \sqrt{2} , a \right \} , \left \{1
  , a \right \} , \left \{\sqrt{2} \right \} , \left \{\sqrt{2} , a
  \right \} , \left \{a \right \} \right \}\leqno{\tt (\%o17)}$$





\section{Grafos}
\label{grafos}

El soporte para el desarrollo de algoritmos en el ámbito de la teoría de grafos se encuentra en el módulo \verb|graphs|\index{graphs}. Se trata de un paquete de funciones que aporta la infraestructura básica para el trabajo con grafos, orientados o no. No se admiten bucles ni aristas múltiples.

\index{create\_graph}\begin{Verbatim}
(%i1) load(graphs)$
(%i2) g: create_graph(
            [1,2,3,4,5,6,7],
            [ [1,2],[2,3],[2,4],[3,4],
              [4,5],[5,6],[4,6],[6,7] ]);
\end{Verbatim}
\[
\mbox{GRAPH}\leqno{\tt (\%o2)}
\]

Como vemos, la respuesta de la función \verb|create_graph| no es muy informativa, pero nos podemos hacer una idea de la estructura del grafo haciendo

\index{print\_graph}\begin{Verbatim}
(%i3) print_graph(g)$

Graph on 7 vertices with 8 edges.
Adjacencies:
  7 :  6
  6 :  7  4  5
  5 :  6  4
  4 :  6  5  3  2
  3 :  4  2
  2 :  4  3  1
  1 :  2
\end{Verbatim}

Vemos que, por ejemplo, el vértice número 3 comparte aristas (no orientadas) con los vértices 4 y 2.

En caso de que el grafo anterior fuese orientado (digrafo) su definición sería:

\begin{Verbatim}
(%i4) dg: create_graph(
            [1,2,3,4,5,6,7],
            [ [1,2],[2,3],[2,4],[3,4],
              [4,5],[5,6],[4,6],[6,7] ],
            directed = true)$
(%i5) print_graph(dg)$

Digraph on 7 vertices with 8 arcs.
Adjacencies:
  7 :
  6 :  7
  5 :  6
  4 :  6  5
  3 :  4
  2 :  4  3
  1 :  2
\end{Verbatim}

En este caso, \verb|print_graph| nos muestra los nodos hijos a la derecha de los padres. En particular, el nodo 7 no es origen de ningún arco, pero es hijo del nodo 6. Otra manera alternativa de mostrar la estructura de un grafo es mediante la función \verb|draw_graph|

\index{draw\_graph}\begin{Verbatim}
(%i6) draw_graph(g, show_id=true, terminal=eps)$
(%i7) draw_graph(dg, show_id=true, head_length=0.05, terminal=eps)$
\end{Verbatim}

Cuyos aspectos se pueden observar en los apartados \emph{a)} y \emph{b)} de la Figura~\ref{fig:graph}.

\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.50]{graph1.pdf} 
\includegraphics[scale=0.50]{graph2.pdf} \\
\emph{a)} \hspace{6.5cm}  \emph{b)} \\
\includegraphics[scale=0.50]{graph3.pdf} 
\includegraphics[scale=0.50]{graph4.pdf} \\
\emph{c)} \hspace{6.5cm}  \emph{d)} \\
\caption{Grafos: \emph{a)} no orientado; \emph{b)} orientado; \emph{c)} complemetario del no orientado; \emph{d)} camino más corto.}
\label{fig:graph}
\end{center}
\end{figure}

Continuemos con el grafo no orientado \verb|g| definido más arriba y veamos cómo extraer de él cierta información: el número cromático, matriz de adyacencia, grafo complementario, si es conexo, o planar, su diámetro, etc.

\index{chromatic\_number}\begin{Verbatim}
(%i8) chromatic_number(g);
\end{Verbatim}
\[
3\leqno{\tt (\%o8)}
\]

\index{adjacency\_matrix}\begin{Verbatim}
(%i9) adjacency_matrix(g);
\end{Verbatim}
\[
\begin{pmatrix}0&1&0&0&0&0&0\cr 1&0&1&1&0&0&0\cr 0&1&0&1&0&0&0\cr 0&1&1&0
 &1&1&0\cr 0&0&0&1&0&1&0\cr 0&0&0&1&1&0&1\cr 0&0&0&0&0&1&0\cr \end{pmatrix} \leqno{\tt (\%o9)}
\]

\index{complement\_graph}\begin{Verbatim}
(%i10) gc:complement_graph(g);
\end{Verbatim}
\[
\mbox{GRAPH}\leqno{\tt (\%o10)}
\]

\begin{Verbatim}
(%i11) print_graph(%)$

Graph on 7 vertices with 13 edges.
Adjacencies:
  1 :  3  4  5  6  7
  2 :  5  6  7
  3 :  1  5  6  7
  4 :  1  7
  5 :  1  2  3  7
  6 :  1  2  3
  7 :  1  2  3  4  5
\end{Verbatim}

Pedimos ahora a Maxima que nos represente gráficamente el complementario de \verb|g|, cuyo aspecto es el del apartado \emph{c)} de la Figura~\ref{fig:graph}.

\begin{Verbatim}
(%i12) draw_graph(gc, show_id=true, terminal=eps)$
\end{Verbatim}

Continuamos con algunas otras propiedades:

\index{is\_connected}\begin{Verbatim}
(%i13) is_connected(g);
\end{Verbatim}
\[
\mbox{true}\leqno{\tt (\%o13)}
\]
\index{is\_planar}\begin{Verbatim}
(%i14) is_planar(g);
\end{Verbatim}
\[
\mbox{true}\leqno{\tt (\%o14)}
\]
\index{diameter}\begin{Verbatim}
(%i15) diameter(g);
\end{Verbatim}
\[
4\leqno{\tt (\%o15)}
\]

Junto con la definición manual, también es posible generar determinados grafos mediante funciones, como el cíclico, el completo, el dodecaedro, un grafo aleatorio, etc.

\index{cycle\_graph}\begin{Verbatim}
(%i16) print_graph(g1: cycle_graph(5))$

Graph on 5 vertices with 5 edges.
Adjacencies:
  4 :  0  3
  3 :  4  2
  2 :  3  1
  1 :  2  0
  0 :  4  1
\end{Verbatim}

\index{complete\_graph}\begin{Verbatim}
(%i17) print_graph(g2: complete_graph(4))$

Graph on 4 vertices with 6 edges.
Adjacencies:
  3 :  2  1  0
  2 :  3  1  0
  1 :  3  2  0
  0 :  3  2  1
\end{Verbatim}

\index{dodecahedron\_graph}\begin{Verbatim}
(%i18) print_graph(g3: dodecahedron_graph())$

Graph on 20 vertices with 30 edges.
Adjacencies:
 19 : 14 13  1
 18 : 13 12  2
 17 : 12 11  3
 16 : 11 10  4
 15 : 14 10  0
 14 :  5 19 15
 13 :  7 19 18
 12 :  9 18 17
 11 :  8 17 16
 10 :  6 16 15
  9 :  7  8 12
  8 :  9  6 11
  7 :  5  9 13
  6 :  8  5 10
  5 :  7  6 14
  4 : 16  0  3
  3 : 17  4  2
  2 : 18  3  1
  1 : 19  2  0
  0 : 15  4  1
\end{Verbatim}

\index{random\_graph}\begin{Verbatim}
(%i19) /* 0.4 de probabilidad para cada arco */
       print_graph(g4: random_graph(10,0.4))$

Graph on 10 vertices with 15 edges.
Adjacencies:
  9 :  8  5  2  1  0
  8 :  9  6  3
  7 :  5  2  1
  6 :  8  3
  5 :  9  7
  4 :  2
  3 :  8  6  0
  2 :  9  7  4  0
  1 :  9  7  0
  0 :  9  3  2  1
\end{Verbatim}

Por último ya, un ejemplo de cálculo de la ruta más corta. Se genera un grafo orientado aleatorio, a continuación se calcula la ruta más corta entre dos vértices dados y finalmente se hace una representación gráfica del cálculo realizado, la cual se puede ver en el apartado \emph{d)} de la Figura~\ref{fig:graph}.

\index{random\_digraph}\begin{Verbatim}
(%i20) r : random_digraph(20, 0.25)$
\end{Verbatim}
\index{vertices}\begin{Verbatim}
(%i21) /* Una lista de los vértices del digrafo */
       vertices(r);
\end{Verbatim}
\[
\left[ 19 , 18 , 17 , 16 , 15 , 14 , 13 , 12 , 11 , 10 , 9 , 8 , 7
  , 6 , 5 , 4 , 3 , 2 , 1 , 0 \right] \leqno{\tt (\%o21)}
\]
\index{shortest\_path}\begin{Verbatim}
(%i22) sh: shortest_path(0,14,r);
\end{Verbatim}
\[
\left[ 0 , 4 , 1 , 17 , 14 \right] \leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i23) draw_graph(
          r,
          show_edges  = vertices_to_path(sh),
          show_id     = true,
          head_length = 0.05,
          terminal    = eps)$
\end{Verbatim}

El paquete \verb|graphs| también permite el uso de etiquetas en los nodos y ponderaciones en las aristas y arcos. El lector interesado podrá consultar la documentación correspondiente en el manual de referencia. 






\newpage
\chapter{Álgebra}


\section{Transformaciones simbólicas}


\subsubsection{Expresiones algebraicas}

Sin duda, una de las capacidades más destacables de Maxima es su habilidad para manipular expresiones algebraicas. Desarrollemos un ejemplo que empieza por asignar a la variable \verb|q| una expresión literal:
\begin{Verbatim}
(%i1) q: (x+3)^5-(x-a)^3+(x+b)^(-1)+(x-1/4)^(-5);
\end{Verbatim}
\[
{{1}\over{x+b}}-\left(x-a\right)^3+\left(x+3\right)^5+{{1}\over{
 \left(x-{{1}\over{4}}\right)^5}}\leqno{\tt (\%o1)}
\]

Se observa que en principio Maxima no realiza ningún cálculo. La función \verb|expand|\index{expand} se encarga de desarrollar las potencias y los productos algebraicos,
\begin{Verbatim}
(%i2) expand(q);
\end{Verbatim}
\[
\begin{array}{c}
{{1}\over{x^5-{{5\,x^4}\over{4}}+{{5\,x^3}\over{8}}-{{5\,x^2}\over{32
 }}+{{5\,x}\over{256}}-{{1}\over{1024}}}}+{{1}\over{x+b}}+ 
   x^5+15\,x^4+89\,x^3+3\,a\,x^2+270\,x^2- \\ 
  3\,a^2\,x+405\,x+a^3+243 \end{array}  \leqno{\tt (\%o2)}
\]

No obstante es posible que no nos interese desplegar toda la expresión, entre otras cosas para evitar una respuesta farragosa y difícil de interpretar; en tal caso podemos utilizar \verb|expand|\index{expand} añadiéndole dos argumentos y operar de la manera siguiente
\begin{Verbatim}
(%i3) expand(q,3,2);
\end{Verbatim}
\[
{{1}\over{x+b}}+\left(x+3\right)^5-x^3+3\,a\,x^2-3\,a^2\,x+{{1
 }\over{\left(x-{{1}\over{4}}\right)^5}}+a^3\leqno{\tt (\%o3)}
\]

Con los argumentos adicionales indicamos que queremos la expansión de todas aquellas potencias con exponente positivo menor o igual a 3 y de las que teniendo el exponente negativo no excedan en valor absoluto de 2.

Dada una expresión con valores literales, podemos desear sustituir alguna letra por otra expresión; por ejemplo, si queremos hacer los cambios $a=2$, $b=2c$ en el último resultado obtenido,
\begin{Verbatim}
(%i4) %,a=2,b=2*c;
\end{Verbatim}
\[
{{1}\over{x+2\,c}}+\left(x+3\right)^5-x^3+6\,x^2-12\,x+{{1}\over{
 \left(x-{{1}\over{4}}\right)^5}}+8\leqno{\tt (\%o4)}
\]

En el ejemplo \verb|%i4| se presenta una sentencia en la que hay elementos separados por comas (\verb|,|)\index{2@, (coma)}. Esta es una forma simplificada de utilizar la función \verb|ev|, que evalúa la primera expresión asignando los valores que se le van indicando a continuación; por ejemplo, \verb|(%i4)| se podría haber escrito como \verb|ev(%,a=2,b=2*c)|. El uso de la variante con \verb|ev|\index{ev} está más indicado para ser utilizado dentro de expresiones más amplias. Obsérvese el resultado siguiente
\begin{Verbatim}
(%i5) 3*x^2 + ev(x^4,x=5);
\end{Verbatim}
\[
3\,x^2+625\leqno{\tt (\%o5)}
\]
donde la sustitución $x=5$ se ha realizado exclusivamente dentro del contexto delimitado por la función \verb|ev|.

De forma más general, la función \verb|subst|\index{subst} sustituye subexpresiones enteras. En el siguiente ejemplo, introducimos una expresión algebraica y a continuación sustituimos todos los binomios \verb|x+y| por la letra \verb|k|,
\begin{Verbatim}
(%i6) 1/(x+y)-(y+x)/z+(x+y)^2;
\end{Verbatim}
\[
-{{y+x}\over{z}}+\left(y+x\right)^2+{{1}\over{y+x}}\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) subst(k,x+y,%);
\end{Verbatim}
\[
-{{k}\over{z}}+k^2+{{1}\over{k}}\leqno{\tt (\%o7)}
\]

No obstante, el siguiente resultado nos sugiere que debemos ser precavidos con el uso de esta función, ya que Maxima no siempre interpretará como subexpresión aquella que para nosotros sí lo es:
\index{subst}\begin{Verbatim}
(%i8) subst(sqrt(k),x+y,(x+y)^2+(x+y));
\end{Verbatim}
\[
y+x+k\leqno{\tt (\%o8)}
\]

La función \verb|subst| realiza una simple sustitución sintáctica que, si bien es suficiente en la mayor parte de los casos, a veces se queda corta como en la situación anterior; la función \verb|ratsubst|\index{ratsubst} es capaz de utilizar información semántica y obtene mejores resultados,

\index{subst}\begin{Verbatim}
(%i9) ratsubst(sqrt(k),x+y,(x+y)^2+(x+y));
\end{Verbatim}
$$k+\sqrt{k}\leqno{\tt (\%o9)}$$

Como una aplicación práctica de \verb|subst|, veamos cómo podemos utilizarla para obtener el conjugado de un número complejo,
\begin{Verbatim}
(%i10) subst(-%i,%i,a+b*%i);
\end{Verbatim}
\[
a-i\,b\leqno{\tt (\%o10)}
\]

La operación inversa de la expansión es la factorización. Expandamos y factoricemos sucesivamente un polinomio para comprobar los resultados,
\index{expand}\index{factor}\begin{Verbatim}
(%i11) expand((a-2)*(b+1)^2*(a+b)^5);
\end{Verbatim}
\[
\begin{array}{c}
a\,b^7-2\,b^7+5\,a^2\,b^6-8\,a\,b^6-4\,b^6+10\,a^3\,b^5-10\,a^2\,b^5
 -19\,a\,b^5-2\,b^5+10\,a^4\,b^4-  \\ 35\,a^2\,b^4-10\,a\,b^4+5\,a^5\,b^3+10
  \,a^4\,b^3-30\,a^3\,b^3-20\,a^2\,b^3+a^6\,b^2+8\,a^5\,b^2-10\,a^4\,b
 ^2- \\ 20\,a^3\,b^2+2\,a^6\,b+a^5\,b-10\,a^4\,b+a^6-2\,a^5 \end{array} \leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) factor(%);
\end{Verbatim}
\[
\left(a-2\right)\,\left(b+1\right)^2\,\left(b+a\right)^5\leqno{\tt (\%o12)}
\]

El máximo común divisor de un conjunto de polinomios se calcula con la función \verb|gcd|\index{gcd} y el mínimo común múltiplo con \verb|lcm|\index{lcm}
\begin{Verbatim}
(%i13) p1: x^7-4*x^6-7*x^5+8*x^4+11*x^3-4*x^2-5*x;
\end{Verbatim}
\[
x^7-4\,x^6-7\,x^5+8\,x^4+11\,x^3-4\,x^2-5\,x\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) p2: x^4-2*x^3-4*x^2+2*x+3;
\end{Verbatim}
\[
x^4-2\,x^3-4\,x^2+2\,x+3\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) gcd(p1,p2);
\end{Verbatim}
\[
x^3+x^2-x-1\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) load(functs)$
(%i17) lcm(p1,p2);
\end{Verbatim}
\[
\left(x-5\right)\,\left(x-3\right)\,\left(x-1\right)^2\,x\,\left(x+1
 \right)^3\leqno{\tt (\%o17)}
\]

En \verb|(%i13)| y \verb|(%i14)| definimos los polinomios \verb|p1| y \verb|p2|, a continuación calculamos su máximo común divisor (mcd) en \verb|(%i15)| y antes de pedir el mínimo común múltiplo en \verb|(%i17)| cargamos el paquete \verb|functs| en el que se encuentra definida la función \verb|lcm|. Es posible que deseemos disponer del mcd factorizado, por lo que hacemos
\index{factor}\begin{Verbatim}
(%i18) factor(%o15);
\end{Verbatim}
\[
\left(x-1\right)\,\left(x+1\right)^2\leqno{\tt (\%o18)}
\]

Hay varias funciones en Maxima que se pueden utilizar para extraer coeficientes de expresiones algebraicas; una de ellas es \verb|ratcoef|\index{ratcoef}. Dado el polinomio $(x-y)^4$, podemos querer extraer el coeficiente de $x^2 y^2$,

\begin{Verbatim}
(%i19) ratcoef((x-y)^4, x^2*y^2);
\end{Verbatim}
$$6\leqno{\tt (\%o19)}$$

Cuando tenemos expandido un polinomio de varias variables, podemos querer transformarlo en otro univariante con coeficientes literales; aquí puede ser de ayuda la función \verb|rat|\index{rat},

\begin{Verbatim}
(%i20) q: m^2*x^2+x^2+2*b*m*x-6*m*x-4*x+b^2-6*b+13;
\end{Verbatim}
$$m^2\,x^2+x^2+2\,b\,m\,x-6\,m\,x-4\,x+b^2-6\,b+13\leqno{\tt (\%o20)}$$
\begin{Verbatim}
(%i21) rat(q, x);
\end{Verbatim}
$$\left(m^2+1\right)\,x^2+\left(\left(2\,b-6\right)\,m-4\right)\,x+b^
 2-6\,b+13\leqno{\tt (\%o21)}$$

Llamando nuevamente a \verb|ratcoef| podemos extraer el coeficiente del término de primer grado respecto de $x$,

\begin{Verbatim}
(%i22) ratcoef(%,x);
\end{Verbatim}
$$\left(2\,b-6\right)\,m-4\leqno{\tt (\%o22)}$$

Otro ejemplo ilstrativo de \verb|rat| en acción,

\begin{Verbatim}
(%i23) rat((x^b+a*x^b+x)^2, x^b);
\end{Verbatim}
$$\left(a^2+2\,a+1\right)\,\left(x^{b}\right)^2+\left(2\,a+2\right)\,
 x\,x^{b}+x^2\leqno{\tt (\%o23)}$$

Si en algún momento queremos inhibir las simplificaciones, podemos hacer uso de la variable global \verb|simp|\index{simp}, cuyo valor por defecto es \verb|true|,

\begin{Verbatim}
(%i24) simp: false$
(%i25) 2 + 2 + a + a;
\end{Verbatim}
\[
2+2+a+a\leqno{\tt (\%o25)}
\]
\begin{Verbatim}
(%i26) simp: true$
(%i27) %o25;
\end{Verbatim}
\[
2\,a+4\leqno{\tt (\%o27)}
\]

Veamos ahora algunas transformaciones que se pueden hacer con fracciones algebraicas.

\begin{Verbatim}
(%i28) expr:(x^2-x)/(x^2+x-6)-5/(x^2-4);
\end{Verbatim}
\[
{{x^2-x}\over{x^2+x-6}}-{{5}\over{x^2-4}}\leqno{\tt (\%o28)}
\]

Podemos factorizar esta expresión,

\index{factor}\begin{Verbatim}
(%i29) factor(expr);
\end{Verbatim}
\[
{{\left(x-3\right)\,\left(x^2+4\,x+5\right)}\over{\left(x-2\right)
 \,\left(x+2\right)\,\left(x+3\right)}}\leqno{\tt (\%o29)}
\]

La expansión devuelve el siguiente resultado,

\index{expand}\begin{Verbatim}
(%i30) expand(expr);
\end{Verbatim}
\[
{{x^2}\over{x^2+x-6}}-{{x}\over{x^2+x-6}}-{{5}\over{x^2-4}}\leqno{\tt (\%o30)}
\]

Ahora descomponemos la fracción algebraica \verb|expr| en fracciones simples,

\index{partfrac}\begin{Verbatim}
(%i31) partfrac(expr,x);
\end{Verbatim}
\[
-{{12}\over{5\,\left(x+3\right)}}+{{5}\over{4\,\left(x+2\right)}}-
 {{17}\over{20\,\left(x-2\right)}}+1\leqno{\tt (\%o31)}
\]

Por último, transformamos la misma expresión a su forma canónica CRE (\emph{Cannonical Rational Expression}), que es un formato que Maxima utiliza para reducir expresiones algebraicas equivalentes a una forma única,

\index{radcan}\begin{Verbatim}
(%i32) radcan(expr);
\end{Verbatim}
\[
{{x^3+x^2-7\,x-15}\over{x^3+3\,x^2-4\,x-12}}\leqno{\tt (\%o32)}
\]

La función \verb|ratsimp|\index{ratsimp} también simplifica cualquier expresión racional, así como las subexpresiones racionales que son argumentos de funciones cualesquiera. El resultado se devuelve como el cociente de dos polinomios. En ocasiones no es suficiente con una sola ejecución de \verb|ratsimp|, por lo que será necesario aplicarla más veces, esto es lo que hace precisamente la función \verb|fullratsimp|\index{fullratsimp}; concretemos esto con un ejemplo:
\begin{Verbatim}
(%i33) (x^(a/2)-1)^2*(x^(a/2)+1)^2 / (x^a-1);
\end{Verbatim}
\[
{{\left(x^{{{a}\over{2}}}-1\right)^2\,\left(x^{{{a}\over{2}}}+1
 \right)^2}\over{x^{a}-1}}\leqno{\tt (\%o33)}
\]
\begin{Verbatim}
(%i34) ratsimp(%);  /* simplificamos una vez */
\end{Verbatim}
\[
{{x^{2\,a}-2\,x^{a}+1}\over{x^{a}-1}}\leqno{\tt (\%o34)}
\]
\begin{Verbatim}
(%i35) ratsimp(%);  /* simplificamos otra vez */
\end{Verbatim}
\[
x^{a}-1\leqno{\tt (\%o35)}
\]
\begin{Verbatim}
(%i36) fullratsimp(%o32);   /* ¡simplificamos todo de una vez! */
\end{Verbatim}
\[
x^{a}-1\leqno{\tt (\%o36)}
\]

Dada una fracción algebraica, podemos obtener separadamente el numerador y el denominador,
\index{num}\index{denom}\begin{Verbatim}
(%i37) fr: (x^3-4*x^2+4*x-2)/(x^2+x+1);
\end{Verbatim}
\[
{{x^3-4\,x^2+4\,x-2}\over{x^2+x+1}}\leqno{\tt (\%o37)}
\]
\begin{Verbatim}
(%i38) num(fr);
\end{Verbatim}
\[
x^3-4\,x^2+4\,x-2\leqno{\tt (\%o38)}
\]
\begin{Verbatim}
(%i39) denom(fr);
\end{Verbatim}
\[
x^2+x+1\leqno{\tt (\%o39)}
\]

Maxima nunca puede adivinar a priori las intenciones del usuario para con las expresiones con las que está trabajando, por ello sigue la política de no tomar ciertas decisiones, por lo que a veces puede parecer que no hace lo suficiente o que no sabe hacerlo. Esta forma \emph{vaga} de proceder la suple con una serie de funciones y variables globales que permitirán al usuario darle al motor simbólico ciertas directrices sobre qué debe hacer con las expresiones, cómo reducirlas o transformarlas. Sin ánimo de ser exhaustivos, siguen algunos ejemplos en los que se controlan transformaciones de tipo logarítmico y trigonométrico.



\subsubsection{Expresiones logarítmicas}

Las expresiones que contienen logaritmos suelen ser ambiguas a la hora de reducirlas. Transformamos a continuación la misma expresión según diferentes criterios,

\begin{Verbatim}
(%i1) log(x^r)-log(x*y) + a*log(x/y);
\end{Verbatim}
\[
-\log \left(x\,y\right)+a\,\log \left({{x}\over{y}}\right)+r\,\log 
 x\leqno{\tt (\%o1)}
\]

En principio, ha hecho la transformación $\log x^r \rightarrow r \log x$. Esto se controla con la variable global \verb|logexpand|\index{logexpand}, cuyo valor por defecto es \verb|true|, lo cual sólo permite la reducción recién indicada. Si también queremos que nos expanda los logaritmos de productos y divisiones, le cambiaremos el valor a esta variable global, tal como se indica a continuación,

\begin{Verbatim}
(%i2) logexpand: super$
(%i3) log(x^r)-log(x*y) + a*log(x/y);
\end{Verbatim}
\[
-\log y+a\,\left(\log x-\log y\right)+r\,\log x-\log x\leqno{\tt (\%o3)}
\]

\begin{Verbatim}
(%i4) /* pedimos que nos simplifique la expresión anterior */
       ratsimp(%);
\end{Verbatim}
\[
\left(-a-1\right)\,\log y+\left(r+a-1\right)\,\log x\leqno{\tt (\%o4)}
\]

En caso de no querer que nos haga transformación alguna sobre la expresión de entrada, simplemente haremos

\begin{Verbatim}
(%i5) logexpand: false$
(%i6) log(x^r)-log(x*y) + a*log(x/y);
\end{Verbatim}
\[
-\log \left(x\,y\right)+a\,\log \left({{x}\over{y}}\right)+\log x^{
 r}\leqno{\tt (\%o6)}
\]

Devolvemos ahora la variable \verb|logexpand| a su estado por defecto,

\begin{Verbatim}
(%i7) logexpand: true$
\end{Verbatim}

La función \verb|logcontract|\index{logcontract} es la que nos va a permitir compactar expresiones logarítmicas,

\begin{Verbatim}
(%i8) logcontract(2*(a*log(x) + 2*a*log(y)));
\end{Verbatim}
\[
a\,\log \left(x^2\,y^4\right)\leqno{\tt (\%o8)}
\]

Por defecto, Maxima contrae los coeficientes enteros; para incluir en este caso la variable $a$ dentro del logaritmo le asignaremos la propiedad de ser un número entero,

\begin{Verbatim}
(%i9) declare(a, integer)$
(%i10) ''%i8;  /* fuerza reevaluación de expresión nominal */
\end{Verbatim}
\[
\log \left(x^{2\,a}\,y^{4\,a}\right)\leqno{\tt (\%o10)}
\]

Esta es una forma de hacerlo, pero Maxima permite un mayor refinamiento sobre este particular haciendo uso de la variable global \verb|logconcoeffp|\index{logconcoeffp}.




\subsubsection{Expresiones trigonométricas}

Toda esta casuística de diferentes formas de representar una misma expresión aumenta considerablemente con aquéllas en las que intervienen las funciones trigonométricas e hiperbólicas. Empecemos con la función \verb|trigexpand|\index{trigexpand}, cuyo comportamiento se controla con las variables globales \verb|trigexpand| (que le es homónima), \verb|trigexpandplus|\index{trigexpandplus} y \verb|trigexpandtimes|\index{trigexpandtimes}, cuyos valores por defectos son, respectivamente, \verb|false|, \verb|true| y \verb|true|. Puestos a experimentar, definamos primero una expresión trigonométrica e interpretamos algunos resultados,

\begin{Verbatim}
(%i1) expr: x+sin(3*x+y)/sin(x);
\end{Verbatim}
\[
{{\sin \left(y+3\,x\right)}\over{\sin x}}+x\leqno{\tt (\%o1)}
\]

\begin{Verbatim}
(%i2) trigexpand(expr); /* aquí trigexpand vale false */
\end{Verbatim}
\[
{{\cos \left(3\,x\right)\,\sin y+\sin \left(3\,x\right)\,\cos y
 }\over{\sin x}}+x\leqno{\tt (\%o2)}
\]

Vemos que sólo se desarrolló la suma del numerador; ahora cambiamos el valor lógico de \verb|trigexpand|,

\begin{Verbatim}
(%i3) trigexpand(expr), trigexpand=true;
\end{Verbatim}
\[
{{\left(\cos ^3x-3\,\cos x\,\sin ^2x\right)\,\sin y+\left(3\,\cos ^2
 x\,\sin x-\sin ^3x\right)\,\cos y}\over{\sin x}}+x\leqno{\tt (\%o3)}
\]
 
Cuando la asignación de la variable global se hace como se acaba de indicar, sólo tiene efecto temporal durante esa ejecución, sin haberse alterado a nivel global. Podemos ordenar a Maxima que simplifique la expresión anterior,

\begin{Verbatim}
(%i4) ratsimp(%);
\end{Verbatim}
\[
-{{\left(3\,\cos x\,\sin ^2x-\cos ^3x\right)\,\sin y+\left(\sin ^3x
 -3\,\cos ^2x\,\sin x\right)\,\cos y-x\,\sin x}\over{\sin x}}\leqno{\tt (\%o4)}
\]

Podemos inhibir el desarrollo de la suma,

\begin{Verbatim}
(%i5) trigexpand(expr), trigexpandplus=false;
\end{Verbatim}
\[
{{\sin \left(y+3\,x\right)}\over{\sin x}}+x\leqno{\tt (\%o5)}
\]

Otra variable global de interés, que no tiene nada que ver con la función \verb|trigexpand|, es \verb|halfangles|\index{halfangles}, con valor \verb|false| por defecto, que controla si se reducen los argumentos trigonométricos con denominador dos,

\begin{Verbatim}
(%i6) sin(x/2);
\end{Verbatim}
\[
\sin \left({{x}\over{2}}\right)\leqno{\tt (\%o6)}
\]

\begin{Verbatim}
(%i7) sin(x/2), halfangles=true;
\end{Verbatim}
\[
{{\sqrt{1-\cos x}}\over{\sqrt{2}}}\leqno{\tt (\%o7)}
\]

La función \verb|trigsimp|\index{trigsimp} fuerza el uso de las identidades fundamentales $\sin^2 x + \cos^2 x = 1$ y $\cosh^2 x - \sinh^2 x = 1$ para simplificar expresiones,

\begin{Verbatim}
(%i8) 5*sin(x)^2 + 4*cos(x)^2;
\end{Verbatim}
\[
5\,\sin ^2x+4\,\cos ^2x\leqno{\tt (\%o8)}
\]

\begin{Verbatim}
(%i9) trigsimp(%);
\end{Verbatim}
\[
\sin ^2x+4\leqno{\tt (\%o9)}
\]

Como un último ejemplo, veamos cómo reducir productos y potencias de funciones trigonométricas a combinaciones lineales,

\begin{Verbatim}
(%i10) -sin(x)^2+3*cos(x)^2*tan(x);
\end{Verbatim}
\[
3\,\cos ^2x\,\tan x-\sin ^2x\leqno{\tt (\%o10)}
\]

\begin{Verbatim}
(%i11) trigreduce(%);
\end{Verbatim}
\[
{{3\,\sin \left(2\,x\right)}\over{2}}+{{\cos \left(2\,x\right)
 }\over{2}}-{{1}\over{2}}\leqno{\tt (\%o11)}
\]

Y si queremos transformar expresiones trigonométricas en complejas,

\begin{Verbatim}
(%i12) exponentialize(%);
\end{Verbatim}
\[
{{e^{2\,i\,x}+e^ {- 2\,i\,x }}\over{4}}-{{3\,i\,\left(e^{2\,i\,x}-e
 ^ {- 2\,i\,x }\right)}\over{4}}-{{1}\over{2}}\leqno{\tt (\%o12)}
\]

Otras funciones útiles en este contexto y que el usuario podrá consultar en la documentación son: \verb|triginverses|\index{triginverses}, \verb|trigsign|\index{trigsign} y \verb|trigrat|\index{trigrat}.








\section{Ecuaciones}

Almacenar una ecuación en una variable es tan simple como hacer
\begin{Verbatim}
(%i1) ec: 3 * x = 1 + x;
\end{Verbatim}
\[
3\,x=x+1\leqno{\tt (\%o1)}
\]

A partir de ahí, aquellas operaciones en las que intervenga la variable serán realizadas a ambos miembros de la igualdad; restamos \verb|x| en los dos lados y a continuación dividimos lo que queda entre \verb|2|,
\begin{Verbatim}
(%i2) %-x;
\end{Verbatim}
\[
2\,x=1\leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) %/2;
\end{Verbatim}
\[
x={{1}\over{2}}\leqno{\tt (\%o3)}
\]
obteniendo de esta manera la solución de la ecuación como si hubiésemos operado manualmente.

Ni qué decir tiene que la ecuación anterior se pudo haber resuelto de un modo más inmediato,
\index{solve}\begin{Verbatim}
(%i4) solve(ec);
\end{Verbatim}
\[
\left[ x={{1}\over{2}} \right] \leqno{\tt (\%o4)}
\]

La instrucción \verb|solve| puede admitir como segundo argumento la incógnita que se pretende calcular, lo que resultará de utilidad cuando en la ecuación aparezcan constantes literales,
\begin{Verbatim}
(%i5) solve((2-a)/x-3=b*x+1/x,x);
\end{Verbatim}
\[
\left[ x=-{{\sqrt{\left(4-4\,a\right)\,b+9}+3}\over{2\,b}} , x={{
 \sqrt{\left(4-4\,a\right)\,b+9}-3}\over{2\,b}} \right] \leqno{\tt (\%o5)}
\]

Las soluciones de las ecuaciones serán probablemente utilizadas en cálculos posteriores, por lo que nos interesará poder extraerlas de la lista anterior; a continuación tomamos el primer resultado calculado por Maxima mediante la función \verb|part|\index{part} y después asignamos a la variable \verb|sol| el resultado numérico,
\begin{Verbatim}
(%i6) part(%,1);
\end{Verbatim}
\[
x=-{{\sqrt{\left(4-4\,a\right)\,b+9}+3}\over{2\,b}}\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) sol: rhs(%);
\end{Verbatim}
\[
-{{\sqrt{\left(4-4\,a\right)\,b+9}+3}\over{2\,b}}\leqno{\tt (\%o7)}
\]

La función \verb|rhs|\index{rhs} devuelve el miembro derecho de la igualdad, mientras que \verb|lhs|\index{lhs} haría lo propio con el miembro izquierdo.

Es posible resolver ecuaciones polinómicas de grado $\leq 4$, pero desgraciadamente, como es de esperar, Maxima no dispone de un método general algebraico que permita resolver ecuaciones polinómicas de grado mayor que cuatro,
\begin{Verbatim}
(%i8) solve(x^5 - 3*x^4 + 2*x^3 -2*x^2 - x + 4 = 0);
\end{Verbatim}
\[
\left[ 0=x^5-3\,x^4+2\,x^3-2\,x^2-x+4 \right] \leqno{\tt (\%o8)}
\]
por lo que \verb|solve| devolverá la misma ecuación sin resolver.

También \verb|solve| se puede utilizar para la resolución de sistemas, en cuyo caso las ecuaciones deben ir agrupadas en una lista, así como las incógnitas; nos planteamos la resolución del siguiente sistema no lineal de incógnitas $x$ e $y$,

\[
\left\{
   \begin{array}{rcl}
      3*x^2-y^2 & = & 6 \\
              x & = & y+a
   \end{array}
\right.
\]

\begin{Verbatim}
(%i9) solve([3*x^2-y^2=6,x=y+a],[x,y]);
\end{Verbatim}
\[
\begin{array}{c}
\left[ \left[ x=-{{\sqrt{3}\,\sqrt{a^2+4}+a}\over{2}} , y=-{{\sqrt{3
 }\,\sqrt{a^2+4}+3\,a}\over{2}} \right]  , \right.\\
  \left. \left[ x={{\sqrt{3}\,
 \sqrt{a^2+4}-a}\over{2}} , y={{\sqrt{3}\,\sqrt{a^2+4}-3\,a}\over{2}}
  \right]  \right] \end{array}  \leqno{\tt (\%o9)}
\]

Una alternativa al uso de \verb|solve| es la función \verb|algsys|\index{algsys}. Veamos cómo \verb|algsys| trata la resolución de la ecuación polinómica anterior \verb|%o8|,
\begin{Verbatim}
(%i10) algsys([x^5 - 3*x^4 + 2*x^3 -2*x^2 - x + 4 = 0],[x]);
\end{Verbatim}
\[
\begin{array}{c}
\left[ \left[ x=2.478283086356668 \right]  , \left[ x=.1150057557117295
 -1.27155810694299\,i \right]  , \right.\\
  \left. \left[ x=1.27155810694299\,i+.1150057557117295
  \right]  , \left[ x=-.8598396689940523 \right]  , \right.\\
  \left. \left[ x=1.151545166402536
  \right]  \right] \end{array} \leqno{\tt (\%o10)}
\]

Como se ve, al no ser capaz de resolverla algebraicamente, nos brinda la oportunidad de conocer una aproximación numérica de la solución. La función \verb|algsys| reconoce la variable global \verb|realonly|\index{realonly}, que cuando toma el valor \verb|true|, hará que se ignoren las soluciones complejas,
\begin{Verbatim}
(%i11) realonly:true$
(%i12) ''%i10;  /* recalcula la entrada %i10 */
\end{Verbatim}
\[
\left[ \left[ x=2.478283086356668 \right]  , \left[ x=1.151545166402536
  \right]  , \left[ x=-.8598396689940523 \right]  \right] \leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) realonly:false$  /* le devolvemos el valor por defecto */
\end{Verbatim}

Un sistema no lineal con coeficientes paramétricos y complejos
\[
\left\{
   \begin{array}{rcl}
      3 u- a v          & = & t \\
      \frac{2 + i}{u+t} & = & 3 v + u \\
      \frac{t}{u}       & = & 1
   \end{array}
\right.
\]

\begin{Verbatim}
(%i14) algsys([3*u-a*v=t,(2+%i)/(u+t)=3*v+u,t/u=1],[u,v,t]);
\end{Verbatim}
\[
\begin{array}{l}
\left[ \left[ u={{\sqrt{{{i\,a}\over{a+6}}+{{2\,a}\over{a+6}}}
 }\over{\sqrt{2}}} , v={{2\,\sqrt{i+2}}\over{\sqrt{2}\,\sqrt{a}\,
 \sqrt{a+6}}} , t={{\sqrt{i+2}\,\sqrt{a}}\over{\sqrt{2}\,\sqrt{a+6}}} \right] \right. , \\
 \left. \left[ u=-{{\sqrt{{{i\,a}\over{a+6}}+{{2\,a}\over{a+6}}}
 }\over{\sqrt{2}}} , v=-{{2\,\sqrt{i+2}}\over{\sqrt{2}\,\sqrt{a}\,
 \sqrt{a+6}}} , t=-{{\sqrt{i+2}\,\sqrt{a}}\over{\sqrt{2}\,\sqrt{a+6}
 }} \right] \right]  \end{array} \leqno{\tt (\%o14)}
\]

Veamos cómo trata \verb|algsys| las ecuaciones indeterminadas, devolviendo la solución en términos paramétricos,
\begin{Verbatim}
(%i15) algsys([3*x^2-5*y=x],[x,y]);
\end{Verbatim}
\[
\left[ \left[ x={\it \%r_1} , y={{3\,{\it \%r_1}^2-{\it \%r_1}
 }\over{5}} \right]  \right] \leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) %, %r1:1;
\end{Verbatim}
\[
\left[ \left[ x=1 , y={{2}\over{5}} \right]  \right] \leqno{\tt (\%o16)}
\]

Maxima nombra los parámetros siguiendo el esquema \verb|%rn|\index{14@\%rn}, siendo \verb|n| un número entero positivo. En la entrada \verb|%i16| pedimos que en \verb|%o15| se sustituya el parámetro por la unidad.

En ocasiones conviene eliminar las variables de los sistemas de forma controlada; en tales casos la función a utilizar será \verb|eliminate|\index{eliminate},

\begin{Verbatim}
(%i17) eliminate([3*u-a*v=t,(2+%i)/(u+t)=3*v+u,t/u=1],[u]);
\end{Verbatim}
\[
\left[ 2\,t-a\,v , -\left(a^2+9\,a\right)\,v^2-\left(5\,a+36\right)
 \,t\,v-4\,t^2+9\,i+18 \right] \leqno{\tt (\%o17)}
\]

Cuando de lo que se trata es de resolver un sistema de ecuaciones lineales, la mejor opción es \verb|linsolve|\index{linsolve}, cuya sintaxis es similar a la de las funciones anteriores. En el siguiente ejemplo, el objetivo es

\[
\left\{ \begin{array}{rcrcrcc}
       2 x & - & 4 y & + & 2 z & = & -2 \\
       \frac{1}{3} x & + & 2 y & + & 9 z & = & x+y \\
       -4 x & + & \sqrt{2} y & + & z & = & 3 y
       \end{array}
\right.
\]

\begin{Verbatim}
(%i18) linsolve(
         [ 2 * x - 4 * y + 2 * z = -2,
          1/3* x + 2 * y + 9 * z = x + y,
         -4 * x + sqrt(2) * y + z = 3 * y],
         [x,y,z]);
\end{Verbatim}
\[
\left[ x={{3021\,\sqrt{2}-12405}\over{48457}} , y={{1537\,\sqrt{2}+16642
 }\over{48457}} , z={{53\,\sqrt{2}-2768}\over{48457}} \right] \leqno{\tt (\%o18)}
\]

Cuando la matriz de coeficientes del sistema es dispersa, la función \verb|fast_linsolve|\index{fast\_linsolve} será preferible, ya que aprovechará tal circunstancia para encontrar las soluciones de forma más rápida.

Si los coeficientes del sistema se tienen en formato matricial, quizás sea más apropiado el uso de la función \verb|linsolve_by_lu|\index{linsolve\_by\_lu}, tal como se indica en la sección dedicada a las matrices.

No todo es resoluble simbólicamente. Existen en Maxima varios procedimientos cuya naturaleza es estrictamente numérica. Uno de ellos es \verb|realroots|\index{realroots}, especializado en el cálculo de \emph{aproximaciones racionales} de las raíces reales de ecuaciones polinómicas; el segundo parámetro, que es opcional, indica la cota de error.

\begin{Verbatim}
(%i19) realroots(x^8+x^3+x+1, 5e-6);
\end{Verbatim}
\[
\left[ x=-1 , x=-{{371267}\over{524288}} \right] \leqno{\tt (\%o19)}
\]

En cambio, \verb|allroots|\index{allroots} obtiene aproximaciones en formato decimal de coma flotante de todas las raíces de las ecuaciones polinómicas, tanto reales como complejas,

\begin{Verbatim}
(%i20) allroots(x^8+x^3+x+1);
\end{Verbatim}
\[
\begin{array}{l}
\left[ x=.9098297401801199\,i+.2989522918873167 , \right. , \\ \left. x=.2989522918873167
 -.9098297401801199\,i \right. , \\ \left. 
x=-.7081337759784606 , x=.9807253637807569\,
 i-.4581925662678885 \right. , \\ \left. 
x=-.9807253637807569\,i-.4581925662678885 , \right. , \\ \left. x=.5359278244124014
 \,i+1.013307162369803 \right. , \\ \left. 
x=1.013307162369803-.5359278244124014\,i , x=
 -1.000000000000001 \right]  \end{array} \leqno{\tt (\%o20)}
\]

Más allá de las ecuaciones algebraicas, \verb|find_root|\index{find\_root} utiliza el método de bipartición para resolver ecuaciones en su más amplio sentido,

\begin{Verbatim}
(%i21) f(x):=144 * sin(x) + 12*sqrt(3)*%pi - 36*x^2 - 12*%pi*x$
(%i22) find_root(f(z),z,1,2);
\end{Verbatim}
\[
1.899889962840263\leqno{\tt (\%o22)}
\]

\label{pag:mnewton}
El uso del método de Newton requiere cargar en memoria el módulo correspondiente. Veamos como ejemplo la ecuación

\[
2 u^u-5=u
\]

\index{mnewton}\begin{Verbatim}
(%i23) load(mnewton)$  /* carga el paquete */
(%i24) mnewton([2*u^u-5],[u],[1]);
0 errors, 0 warnings
\end{Verbatim}
\[
\left[ \left[ u=1.70927556786144 \right]  \right] \leqno{\tt (\%o14)}
\]

y el sistema
\[
\left\{
   \begin{array}{rcl}
      x+3 \log(x)-y^2 & = & 0 \\
      2 x^2-x y-5 x+1  & = & 0
   \end{array}
\right.
\]

\begin{Verbatim}
(%i25) mnewton([x+3*log(x)-y^2, 2*x^2-x*y-5*x+1],[x, y], [5, 5]);
\end{Verbatim}
\[
\left[ \left[ x=3.756834008012769 , y=2.779849592817897 \right] 
  \right] \leqno{\tt (\%o25)}
\]

\begin{Verbatim}
(%i26) mnewton([x+3*log(x)-y^2, 2*x^2-x*y-5*x+1],[x, y], [1, -2]);
\end{Verbatim}
\[
\left[ \left[ x=1.373478353409809 , y=-1.524964836379522 \right] 
  \right] \leqno{\tt (\%o26)}
\]

En los anteriores ejemplos, el primer argumento es una lista con la ecuación o ecuaciones a resolver, las cuales se suponen igualadas a cero; el segundo argumento es la lista de variables y el último el valor inicial a partir del cual se generará el algoritmo y cuya elección determinará las diferentes soluciones del problema.









\section{Inecuaciones}

Las rutinas para resolver inecuaciones las guarda Maxima en el paquete de funciones \verb|fourier_elim|, por lo que primero las debemos cargar en memoria,

\begin{Verbatim}
(%i1) load("fourier_elim")$
\end{Verbatim}

Ciertos mensajes de avisos que nos devuelve Maxima los podemos olvidar, ya que solo nos indican que algunas macros del sistema han tenido que ser redefinidas.

Vamos a resolver una inecuación de primer grado,

\begin{Verbatim}
(%i2) ine : (5*x-16)/6 + (x+8)/12 < (x+1)/3;
\end{Verbatim}
$${{5\,x-16}\over{6}}+{{x+8}\over{12}}<{{x+1}\over{3}}\leqno{\tt (\%o2)}$$

La función clave a llamar se llama precisamente \verb|fourier_elim|\index{realroots} y la sintaxis es similar a la de \verb|solve|; el primer argumento a pasarle es la lista de inecuaciones, de momento una sola, y el segundo la lista de incógnitas, también una sola,

\begin{Verbatim}
(%i3) fourier_elim([ine], [x]);
\end{Verbatim}
$$\left[ x<4 \right] \leqno{\tt (\%o3)}$$

Vamos a ver ahora en qué intervalos de la recta el polinomio $x^4+5 x^3+5 x^2-5 x-6$ toma valores positivos,

\begin{Verbatim}
(%i4) p : x^4+5*x^3+5*x^2-5*x-6 $
\end{Verbatim}
\begin{Verbatim}
(%i5) fourier_elim([p > 0],[x]);
\end{Verbatim}
$$\left[ 1<x \right] \lor \left[ -2<x , x<-1 \right] \lor \left[ x<-3
  \right] \leqno{\tt (\%o5)}$$

Tal como se ha visto hasta ahora, la función \verb|fourier_elim| nos devuelve los resultados como disyunciones de listas, interpretándose cada una de ellas como una conjunción lógica de proposiciones; así, el último resultado habría que interpretarlo como

$$(1<x) \lor ( -2<x \land x<-1 ) \lor (x<-3).$$

El resultado anterior cambia sensiblemente cuando admitimos la igualdad en la inecuación,

\begin{Verbatim}
(%i6) fourier_elim([p >= 0],[x]);
\end{Verbatim}
$$\left[ x=-3 \right] \lor \left[ x=-2 \right] \lor \left[ x=-1
  \right] \lor \left[ x=1 \right] \lor \left[ 1<x \right] \lor 
 \left[ -2<x , x<-1 \right] \lor \left[ x<-3 \right] \leqno{\tt (\%o6)}$$

Abordamos ahora la resolución de un sistema de inecuaciones lineales con una incógnita,

\begin{Verbatim}
(%i7) fourier_elim(
        [(x+2)/4 <= x/2-3, (8-x)/3 < (1+x)/2-1],
        [x]);
\end{Verbatim}
$$\left[ x=14 \right] \lor \left[ 14<x \right] \leqno{\tt (\%o7)}$$

Ahora con tres,

\begin{Verbatim}
(%i8) fourier_elim(
        [0 < x, 
         x < 1, 
         0 < y+x*y, 
         y-2*z+x < 1, 
         0 < z,
         x+y+z < 4],
        [z,x,y] );
\end{Verbatim}
$$\left[ {\it max}\left(0 , {{y}\over{2}}+{{x}\over{2}}-{{1}\over{2}}
 \right)<z , z<-y-x+4 , 0<x , x<{\it min}\left(1 , 3-y\right) , 0<y
  , y<3 \right] \leqno{\tt (\%o8)}$$

Otros ejemplos de inecuaciones no lineales,

\begin{Verbatim}
(%i9) fourier_elim([max(x,y) < 1, min(x,y) > -1],[x,y]);
\end{Verbatim}
$$\left[ -1<x , x<1 , -1<y , y<1 \right] \leqno{\tt (\%o19)}$$

\begin{Verbatim}
(%i10) fourier_elim([abs(x) + abs(x/2) + abs(x/3) #  1],[x]);
\end{Verbatim}
$$\left[ x=0 \right] \lor \left[ 0<x , x<{{6}\over{11}} \right] \lor 
 \left[ -{{6}\over{11}}<x , x<0 \right] \lor \left[ x<-{{6}\over{11}}
  \right] \lor \left[ {{6}\over{11}}<x \right] \leqno{\tt (\%o10)}$$


\begin{Verbatim}
(%i11) fourier_elim([log(x) < log(a)],[x,a]);
\end{Verbatim}
$$\left[ 0<x , x<a , 0<a \right] \leqno{\tt (\%o11)}$$










\section{Matrices}

La definición de una matriz es extremadamente simple en Maxima,
\index{matrix}\begin{Verbatim}
(%i1) m1: matrix([3,4,0],[6,0,-2],[0,6,a]);
\end{Verbatim}
\[
\begin{pmatrix}3&4&0\cr 6&0&-2\cr 0&6&a\cr  \end{pmatrix} \leqno{\tt (\%o1)}
\]

También es posible definir una matriz de forma interactiva tal y como muestra el siguiente ejemplo,
\index{entermatrix}\begin{Verbatim}
(%i2) entermatrix(2,3);
Row 1 Column 1:
4/7;
Row 1 Column 2:
0;
Row 1 Column 3:
%pi;
Row 2 Column 1:
sqrt(2);
Row 2 Column 2:
log(3);
Row 2 Column 3:
-9;

Matrix entered.
\end{Verbatim}
\[
\begin{pmatrix}{{4}\over{7}}&0&\pi\cr \sqrt{2}&\log 3&-9\cr \end{pmatrix} \leqno{\tt (\%o2)}
\]

Existe un tercer método para construir matrices que es útil cuando el elemento $(i,j)$-ésimo de la misma es función de su posición dentro de la matriz. A continuación, se fija en primer lugar la regla que permite definir un elemento cualquiera y luego en base a ella se construye una matriz de dimensiones $2 \times 5$
\index{29@:=}\index{genmatrix}\begin{Verbatim}
(%i3) a[i,j]:=i+j$
(%i4) genmatrix(a,2,5);
\end{Verbatim}
\[
\begin{pmatrix}2&3&4&5&6\cr 3&4&5&6&7\cr \end{pmatrix} \leqno{\tt (\%o4)}
\]
Obsérvese que el símbolo de asignación para el elemento genérico es \verb|:=|.


Podemos acceder a los diferentes elementos de la matriz haciendo referencia a sus subíndices, indicando primero la fila y después la columna:
\begin{Verbatim}
(%i5) m1[3,1];
\end{Verbatim}
\[
0\leqno{\tt (\%o5)}
\]

Se puede extraer una submatriz con la función \verb|submatrix|\index{submatrix}, teniendo en cuenta que los enteros que preceden al nombre de la matriz original son las filas a eliminar y los que se colocan detrás indican las columnas que no interesan; en el siguiente ejemplo, queremos la submatriz que nos queda de \verb|m1| después de extraer la primera fila y la segunda columna,
\begin{Verbatim}
(%i6) submatrix(1,m1,2);
\end{Verbatim}
\[
\begin{pmatrix}6&-2\cr 0&a\cr \end{pmatrix} \leqno{\tt (\%o6)}
\]

Otro ejemplo es el siguiente,
\begin{Verbatim}
(%i7) submatrix(1,2,m1,3);
\end{Verbatim}
\[
\begin{pmatrix}0&6\cr \end{pmatrix} \leqno{\tt (\%o7)}
\]
en el que eliminamos las dos primeras filas y la última columna, ?`se pilla el truco?

Al igual que se extraen submatrices, es posible añadir filas y columnas a una matriz dada; por ejemplo,
\index{addrow}\index{addcol}\begin{Verbatim}
(%i8) addrow(m1,[1,1,1],[2,2,2]);
\end{Verbatim}
\[
\begin{pmatrix}3&4&0\cr 6&0&-2\cr 0&6&a\cr 1&1&1\cr 2&2&2\cr \end{pmatrix} \leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) addcol(%,[7,7,7,7,7]);
\end{Verbatim}
\[
\begin{pmatrix}3&4&0&7\cr 6&0&-2&7\cr 0&6&a&7\cr 1&1&1&7\cr 2&2&2&7\cr \end{pmatrix} \leqno{\tt (\%o9)}
\]

La matriz identidad es más fácil construirla mediante la función \verb|ident|\index{ident},
\begin{Verbatim}
(%i10) ident(3);
\end{Verbatim}
\[
\begin{pmatrix}1&0&0\cr 0&1&0\cr 0&0&1\cr  \end{pmatrix} \leqno{\tt (\%o10)}
\]
y la matriz con todos sus elementos iguales a cero,
\index{zeromatrix}\begin{Verbatim}
(%i11) zeromatrix(2,4);
\end{Verbatim}
\[
\begin{pmatrix}0&0&0&0\cr 0&0&0&0\cr \end{pmatrix} \leqno{\tt (\%o11)}
\]

También, una matriz diagonal con todos los elementos de la diagonal principal iguales puede construirse con una llamada a la función \verb|diagmatrix|\index{diagmatrix},
\begin{Verbatim}
(%i12) diagmatrix(4,%e);
\end{Verbatim}
\[
\begin{pmatrix}e&0&0&0\cr 0&e&0&0\cr 0&0&e&0\cr 0&0&0&e\cr \end{pmatrix} \leqno{\tt (\%o12)}
\]

En todo caso, debe tenerse cuidado en que si la matriz no se construye de forma apropiada, Maxima no la reconoce como tal. Para saber si una expresión es reconocida como una matriz se utiliza la función \verb|matrixp|\index{matrixp}; la siguiente secuencia permite aclarar lo que se pretende decir,
\begin{Verbatim}
(%i13) matrix([[1,2,3],[4,5,6]]);  /* construcción correcta */
\end{Verbatim}
\[
\begin{pmatrix}\left[ 1 , 2 , 3 \right] &\left[ 4 , 5 , 6 \right] \cr \end{pmatrix} \leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) matrixp(%);  /* es la anterior realmente una matriz? */
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) [[7,8,9],[0,1,2]];    /* otra matriz */
\end{Verbatim}
\[
\left[ \left[ 7 , 8 , 9 \right]  , \left[ 0 , 1 , 2 \right] 
  \right] \leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) matrixp(%);   /* será una matriz? */
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o16)}
\]

Casos particulares de submatrices son las filas y las columnas; los ejemplos se explican por sí solos:
\index{col}\index{row}\begin{Verbatim}
(%i17) col(m1,3);
\end{Verbatim}
\[
\begin{pmatrix}0\cr -2\cr a\cr \end{pmatrix} \leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) row(m1,2);
\end{Verbatim}
\[
\begin{pmatrix}6&0&-2\cr \end{pmatrix} \leqno{\tt (\%o18)}
\]

Con las matrices se pueden realizar múltiples operaciones. Empezamos por el cálculo de la potencia de una matriz:
\index{21@\^\ \^\ }\begin{Verbatim}
(%i19) m1^^2;
\end{Verbatim}
\[
\begin{pmatrix}33&12&-8\cr 18&12&-2\,a\cr 36&6\,a&a^2-12\cr \end{pmatrix} \leqno{\tt (\%o19)}
\]

Nótese que se utiliza dos veces el símbolo \verb|^| antes del exponente; en caso de escribirlo una sola vez se calcularían las potencias de cada uno de los elementos de la matriz independientemente, como se indica en el siguiente ejemplo,
\index{18@\^\ }\begin{Verbatim}
(%i20) m2:m1^2;
\end{Verbatim}
\[
\begin{pmatrix}9&16&0\cr 36&0&4\cr 0&36&a^2\cr \end{pmatrix} \leqno{\tt (\%o38)}
\]

Para la suma, resta y producto matriciales se utilizan los operadores \verb|+|, \verb|-| y \verb|.|, respectivamente,
\index{14@+}\index{15@-}\index{17@/}\index{17@.}\begin{Verbatim}
(%i21) m1+m2;
\end{Verbatim}
\[
\begin{pmatrix}12&20&0\cr 42&0&2\cr 0&42&a^2+a\cr \end{pmatrix} \leqno{\tt (\%o21)}
\]
\begin{Verbatim}
(%i22) m1-m2;
\end{Verbatim}
\[
\begin{pmatrix}-6&-12&0\cr -30&0&-6\cr 0&-30&a-a^2\cr \end{pmatrix} \leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i23) m1.m2;
\end{Verbatim}
\[
\begin{pmatrix}171&48&16\cr 54&24&-2\,a^2\cr 216&36\,a&a^3+24\cr \end{pmatrix} \leqno{\tt (\%o23)}
\]

Sin embargo, tanto el producto elemento a elemento de dos matrices, como la multiplicación por un escalar se realizan mediante el operador \verb|*|, como indican los siguientes dos ejemplos,
\index{16@*}\begin{Verbatim}
(%i24) m1*m2;
\end{Verbatim}
\[
\begin{pmatrix}27&64&0\cr 216&0&-8\cr 0&216&a^3\cr \end{pmatrix} \leqno{\tt (\%o24)}
\]
\begin{Verbatim}
(%i25) 4*m1;
\end{Verbatim}
\[
\begin{pmatrix}12&16&0\cr 24&0&-8\cr 0&24&4\,a\cr \end{pmatrix} \leqno{\tt (\%o25)}
\]

Otros cálculos frecuentes con matrices son la transposición, el determinante, la inversión, el polinomio característico, así como los valores y vectores propios; para todos ellos hay funciones en Maxima:
\index{transpose}\index{determinant}\index{invert}\index{detout}\index{charpoly}\begin{Verbatim}
(%i26) transpose(m1);    /*la transpuesta*/
\end{Verbatim}
\[
\begin{pmatrix}3&6&0\cr 4&0&6\cr 0&-2&a\cr \end{pmatrix} \leqno{\tt (\%o26)}
\]
\begin{Verbatim}
(%i27) determinant(m1);  /*el determinante*/
\end{Verbatim}
\[
36-24\,a\leqno{\tt (\%o27)}
\]
\begin{Verbatim}
(%i28) invert(m1);       /*la inversa*/
\end{Verbatim}
\[
\begin{pmatrix}{{12}\over{36-24\,a}}&-{{4\,a}\over{36-24\,a}}&-{{8}\over{36
 -24\,a}}\cr -{{6\,a}\over{36-24\,a}}&{{3\,a}\over{36-24\,a}}&{{6
 }\over{36-24\,a}}\cr {{36}\over{36-24\,a}}&-{{18}\over{36-24\,a}}&-
 {{24}\over{36-24\,a}}\cr \end{pmatrix} \leqno{\tt (\%o28)}
\]
\begin{Verbatim}
(%i29) invert(m1),detout;  /*la inversa, con el determinante fuera*/
\end{Verbatim}
\[
{{\begin{pmatrix}12&-4\,a&-8\cr -6\,a&3\,a&6\cr 36&-18&-24\cr \end{pmatrix} }\over{36-24
 \,a}}\leqno{\tt (\%o29)}
\]
\begin{Verbatim}
(%i30) charpoly(m1,x); /*pol.  caract. con variable x*/
\end{Verbatim}
\[
\left(3-x\right)\,\left(12-\left(a-x\right)\,x\right)-24\,\left(a-x
 \right)\leqno{\tt (\%o30)}
\]
\begin{Verbatim}
(%i31) expand(%);     /*pol. caract. expandido*/
\end{Verbatim}
\[
-x^3+a\,x^2+3\,x^2-3\,a\,x+12\,x-24\,a+36\leqno{\tt (\%o31)}
\]

Vamos a suponer ahora que \verb|a| vale cero y calculemos los valores propios de la matriz,
\index{eigenvalues}\begin{Verbatim}
(%i32) m1,a=0;
\end{Verbatim}
\[
\begin{pmatrix}3&4&0\cr 6&0&-2\cr 0&6&0\cr \end{pmatrix} \leqno{\tt (\%o32)}
\]
\begin{Verbatim}
(%i33) eigenvalues(%);
\end{Verbatim}
\[
\left[ \left[ -{{\sqrt{15}\,i+3}\over{2}} , {{\sqrt{15}\,i-3}\over{2
 }} , 6 \right]  , \left[ 1 , 1 , 1 \right]  \right] \leqno{\tt (\%o33)}
\]

El resultado que se obtiene es una lista formada por dos sublistas, en la primera se encuentran los valores propios, que en este caso son $\lambda_1=-\frac{3}{2}-\frac{\sqrt{15}}{2} i$, $\lambda_2=-\frac{3}{2}+\frac{\sqrt{15}}{2} i$ y $\lambda_3=6$, mientras que en la segunda sublista se nos indican las multiplicidades de cada una de las $\lambda_i$.

Para el cálculo de los vectores propios,
\index{eigenvectors}\begin{Verbatim}
(%i34) eigenvectors(%o32);
\end{Verbatim}
\[
\begin{array}{l}
\left[ \left[ \left[ -{{\sqrt{15}\,i+3}\over{2}} , {{\sqrt{15}\,i-3
 }\over{2}} , 6 \right]  , \left[ 1 , 1 , 1 \right]  \right]  ,  \right. \\ \left. 
 \left[ 1 , -{{\sqrt{15}\,i+9}\over{8}} , -{{3\,\sqrt{3}\,\sqrt{5}\,i
 -21}\over{8}} \right]  , \left[ 1 , {{\sqrt{15}\,i-9}\over{8}} , {{3
 \,\sqrt{3}\,\sqrt{5}\,i+21}\over{8}} \right]  , \left[ 1 , {{3
 }\over{4}} , {{3}\over{4}} \right]  \right] \end{array} \leqno{\tt (\%o34)}
\]

Lo que se obtiene es, en primer lugar, los valores propios junto con sus multiplicidades, el mismo resultado que se obtuvo con la función \verb|eigenvalues|, y a continuación los vectores propios de la matriz asociados a cada uno de los valores propios. A veces interesa que los vectores sean unitarios, de norma 1, para lo que será de utilidad la función \verb|uniteigenvectors|\index{uniteigenvectors}, que se encuentra definida en el paquete \verb|eigen.lisp|, lo que significa que antes de hacer uso de ella habrá que ejecutar la orden \verb|load(eigen)|. También podemos solicitar los vectores propios unitarios por medio de la función \verb|uniteigenvectors|\index{uniteigenvectors},
\begin{Verbatim}
(%i35) uniteigenvectors(%o32);
\end{Verbatim}
\[
\begin{array}{l}
\left[ \left[ \left[ -{{\sqrt{15}\,i+3}\over{2}} , {{\sqrt{15}\,i-3
 }\over{2}} , 6 \right]  , \left[ 1 , 1 , 1 \right]  \right]  , \right. \\ \left. 
 \left[ {{\sqrt{2}}\over{\sqrt{23}}} , -{{\sqrt{2}\,\sqrt{15}\,i+9\,
 \sqrt{2}}\over{8\,\sqrt{23}}} , -{{3\,\sqrt{2}\,\sqrt{3}\,\sqrt{5}\,
 i-21\,\sqrt{2}}\over{8\,\sqrt{23}}} \right] ,  \right. \\ \left. \left[ {{\sqrt{2}
 }\over{\sqrt{23}}} , {{\sqrt{2}\,\sqrt{15}\,i-9\,\sqrt{2}}\over{8\,
 \sqrt{23}}} , {{3\,\sqrt{2}\,\sqrt{3}\,\sqrt{5}\,i+21\,\sqrt{2}
 }\over{8\,\sqrt{23}}} \right]  , \left[ {{2\,\sqrt{2}}\over{\sqrt{17
 }}} , {{3\,\sqrt{2}}\over{2\,\sqrt{17}}} , {{3\,\sqrt{2}}\over{2\,
 \sqrt{17}}} \right]  \right] \end{array} \leqno{\tt (\%o35)}
\]

El rango, el menor de un elemento y una base del espacio nulo de cierta matriz pueden calcularse, respectivamente, con las funciones \verb|rank|\index{rank}, \verb|minor|\index{minor} y \verb|nullspace|\index{nullspace},

\begin{Verbatim}
(%i36) rank(%o32);   /* el rango de la matriz*/
\end{Verbatim}
\[
3\leqno{\tt (\%o36)}
\]
\begin{Verbatim}
(%i37) minor(%o32,2,1);  /* el menor de un elemento */
\end{Verbatim}
\[
\begin{pmatrix}4&0\cr 6&0\cr \end{pmatrix} \leqno{\tt (\%o37)}
\]
\begin{Verbatim}
(%i38) nullspace(%o32);  /* base del núcleo */
0 errors, 0 warnings
\end{Verbatim}
\[
{\it span}\left(\right) \leqno{\tt (\%o38)}
\]
que es la respuesta que se obtiene cuando el espacio nulo está formado por un único elemento.

De forma similar a como la instrucción \verb|map| aplica una función a todos los elementos de una lista, \verb|matrixmap|\index{matrixmap} hace lo propio con los elementos de una matriz,

\begin{Verbatim}
(%i39) matrixmap(sin,%o32);
\end{Verbatim}
\[
\begin{pmatrix}\sin 3&\sin 4&0\cr \sin 6&0&-\sin 2\cr 0&\sin 6&0\cr \end{pmatrix} \leqno{\tt (\%o39)}
\]

Avancemos un poco más en otros aspectos del álgebra lineal. Empezamos con el cálculo de la matriz de Jordan $J$ de cierta matriz dada $A$, esto es, la matriz que verifica $A=S J S^{-1}$, para cierta $S$. Para ello es necesario cargar previamente el paquete \verb|diag|\index{diag}, se introduce la matriz $A$ y la función \verb|jordan|\index{jordan} se encargará de obtener lo que buscamos en un formato que luego utilizamos para obtener las matrices $J$ y $S$. Finalmente, comprobamos los resultados:

\begin{Verbatim}
(%i40) A: matrix([2,4,-6,0],[4,6,-3,-4],[0,0,4,0],[0,4,-6,2]);
\end{Verbatim}
\[
\begin{pmatrix}2&4&-6&0\cr 4&6&-3&-4\cr 0&0&4&0\cr 0&4&-6&2\cr \end{pmatrix}  \leqno{\tt (\%o40)}
\]

\begin{Verbatim}
(%i41) load(diag)$  jl: jordan(A);
\end{Verbatim}
\[
\left[ \left[ 6 , 1 \right]  , \left[ 2 , 2 \right]  , \left[ 4 , 1
  \right]  \right] \leqno{\tt (\%o42)}
\]

\index{dispJordan}\begin{Verbatim}
(%i43) J: dispJordan(jl);
\end{Verbatim}
\[
\begin{pmatrix}6&0&0&0\cr 0&2&1&0\cr 0&0&2&0\cr 0&0&0&4\cr \end{pmatrix}\leqno{\tt (\%o43)}
\]

\index{ModeMatrix}\begin{Verbatim}
(%i44) S: ModeMatrix (A,jl);
\end{Verbatim}
\[
\begin{pmatrix}1&4&0&0\cr 1&0&1&1\cr 0&0&0&{{2}\over{3}}\cr 1&4&1&0\cr \end{pmatrix}\leqno{\tt (\%o44)}
\]

\begin{Verbatim}
(%i45) is(A = S.J.(S^^-1));
\end{Verbatim}
\[
\mbox{true}\leqno{\tt (\%o45)}
\]

Cuando los coeficientes de un sistema lineal se tengan en forma matricial y los términos independientes en un vector, el sistema se podrá resolver con la función \verb|linsolve_by_lu|\index{linsolve\_by\_lu},

\begin{Verbatim}
(%i46) A : matrix([sqrt(2),4],[a,4/5]);
\end{Verbatim}
\[
\begin{pmatrix}\sqrt{2}&4\cr a&{{4}\over{5}}\cr \end{pmatrix} \leqno{\tt (\%o46)}
\]

\begin{Verbatim}
(%i47) B : [1/3,a];
\end{Verbatim}
\[
\left[ {{1}\over{3}} , a \right] \leqno{\tt (\%o47)}
\]

Resolvemos ahora $A X=B$ y luego simplificamos algo el resultado

\begin{Verbatim}
(%i48) linsolve_by_lu(A,B);
\end{Verbatim}
\[
\left[ \begin{pmatrix}{{{{1}\over{3}}-{{4\,\left(a-{{a}\over{3\,\sqrt{2}
 }}\right)}\over{{{4}\over{5}}-2\,\sqrt{2}\,a}}}\over{\sqrt{2}}}\cr 
 {{a-{{a}\over{3\,\sqrt{2}}}}\over{{{4}\over{5}}-2\,\sqrt{2}\,a}}\cr 
 \end{pmatrix} , \mbox{false} \right] \leqno{\tt (\%o48)}
\]

\begin{Verbatim}
(%i49) ratsimp(%);
\end{Verbatim}
\[
\left[ \begin{pmatrix}{{15\,\sqrt{2}\,a-\sqrt{2}}\over{15\,\sqrt{2}\,a-6
 }}\cr -{{\left(15\,\sqrt{2}-5\right)\,a}\over{60\,a-12\,\sqrt{2}}}
 \cr \end{pmatrix} , \mbox{false} \right] \leqno{\tt (\%o49)}
\]

El resultado que se obtiene es una lista que contiene la solución y el símbolo \verb|false|. Cuando la resolución del sistema sea de índole numérica, esta segunda componente será sustituida por el número de condición, una medida de la bondad del resultado numérico. Veamos de aplicar esto a cierta ecuación matricial del estilo $M X = M M$

\begin{Verbatim}
(%i50) M : matrix([sqrt(3),2/5],[3,sin(2)]);
\end{Verbatim}
\[
\begin{pmatrix}\sqrt{3}&{{2}\over{5}}\cr 3&\sin 2\cr \end{pmatrix} \leqno{\tt (\%o50)}
\]

\begin{Verbatim}
(%i51) linsolve_by_lu(M,M.M,'floatfield);
\end{Verbatim}
\[
\left[ \begin{pmatrix}1.732050807568877&.4000000000000005\cr 3.000000000000001
 &.9092974268256803\cr \end{pmatrix} , 49.33731560796254 \right] \leqno{\tt (\%o51)}
\]

Veamos ahora cómo obtener algunas matrices especiales: la hessiana de una función, la de Hilbert, la de Toeplitz, la de Vandermone y la de Hankel,

\index{hessian}\begin{Verbatim}
(%i52) hessian(exp(x^2*y+a*z),[x,y,z]);
\end{Verbatim}
\[
\begin{pmatrix}4\,x^2\,y^2\,e^{a\,z+x^2\,y}+2\,y\,e^{a\,z+x^2\,y}&2\,x^3
 \,y\,e^{a\,z+x^2\,y}+2\,x\,e^{a\,z+x^2\,y}&2\,a\,x\,y\,e^{a\,z+x^2\,
 y}\cr 2\,x^3\,y\,e^{a\,z+x^2\,y}+2\,x\,e^{a\,z+x^2\,y}&x^4\,e^{a\,z+
 x^2\,y}&a\,x^2\,e^{a\,z+x^2\,y}\cr 2\,a\,x\,y\,e^{a\,z+x^2\,y}&a\,x^2
 \,e^{a\,z+x^2\,y}&a^2\,e^{a\,z+x^2\,y}\cr \end{pmatrix} \leqno{\tt (\%o52)}
\]

\index{hilbert\_matrix}\begin{Verbatim}
(%i53) hilbert_matrix(5);
\end{Verbatim}
\[
\begin{pmatrix}1&{{1}\over{2}}&{{1}\over{3}}&{{1}\over{4}}&{{1}\over{5}}
 \cr {{1}\over{2}}&{{1}\over{3}}&{{1}\over{4}}&{{1}\over{5}}&{{1
 }\over{6}}\cr {{1}\over{3}}&{{1}\over{4}}&{{1}\over{5}}&{{1}\over{6
 }}&{{1}\over{7}}\cr {{1}\over{4}}&{{1}\over{5}}&{{1}\over{6}}&{{1
 }\over{7}}&{{1}\over{8}}\cr {{1}\over{5}}&{{1}\over{6}}&{{1}\over{7
 }}&{{1}\over{8}}&{{1}\over{9}}\cr \end{pmatrix} \leqno{\tt (\%o53)}
\]

\index{toeplitz}\begin{Verbatim}
(%i54) toeplitz([1,2,3,4],[t,x,y,z]);
\end{Verbatim}
\[
\begin{pmatrix}1&x&y&z\cr 2&1&x&y\cr 3&2&1&x\cr 4&3&2&1\cr \end{pmatrix} \leqno{\tt (\%o54)}
\]

\index{vandermonde\_matrix}\begin{Verbatim}
(%i55) vandermonde_matrix([u,v,x,y,z]);
0 errors, 0 warnings
\end{Verbatim}
\[
\begin{pmatrix}1&u&u^2&u^3&u^4\cr 1&v&v^2&v^3&v^4\cr 1&x&x^2&x^3&x^4\cr 1
 &y&y^2&y^3&y^4\cr 1&z&z^2&z^3&z^4\cr \end{pmatrix} \leqno{\tt (\%o55)}
\]

\index{hankel}\begin{Verbatim}
(%i56) hankel ([v,x,y,z],[p,q,r,s]);
\end{Verbatim}
\[
\begin{pmatrix}v&x&y&z\cr x&y&z&q\cr y&z&q&r\cr z&q&r&s\cr \end{pmatrix} \leqno{\tt (\%o56)}
\]

El lector interesado puede obtener información sobre otras funciones matriciales accediendo a la documentación sobre el paquete \verb|linearalgebra|\index{linearalgebra}. 

Veamos ahora cómo trabajar con matrices por bloques. Puesto que los elementos de una matriz pueden ser objetos de cualquier tipo, definamos los elementos como matrices,

\begin{Verbatim}
(%i57) m: matrix([matrix([1,0],[0,-1]),matrix([0,1],[1,0])],
                 [matrix([0,1],[1,0]),matrix([1,0],[0,-1])]) ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}1&0\cr 0&-1\cr \end{pmatrix} & \begin{pmatrix}0&1\cr 1&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&1\cr 1&0\cr \end{pmatrix}&\begin{pmatrix}1&0\cr 0&-1\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o57)}$$

Podemos ahora hacer algunas operaciones básicas con esta matriz,

\begin{Verbatim}
(%i58) m + m ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}2&0\cr 0&-2\cr \end{pmatrix} & \begin{pmatrix}0&2\cr 2&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&2\cr 2&0\cr \end{pmatrix}&\begin{pmatrix}2&0\cr 0&-2\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o58)}$$

\begin{Verbatim}
(%i59) m - m ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix} & \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}&\begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o59)}$$

\begin{Verbatim}
(%i60) 3 * m ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}3&0\cr 0&-3\cr \end{pmatrix} & \begin{pmatrix}0&3\cr 3&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&3\cr 3&0\cr \end{pmatrix}&\begin{pmatrix}3&0\cr 0&-3\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o60)}$$

Veamos lo que pasa con la multiplicación matricial,

\begin{Verbatim}
(%i61) m . m ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}1&1\cr 1&1\cr \end{pmatrix} & \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}&\begin{pmatrix}1&1\cr 1&1\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o61)}$$

Este resultado es incorrecto porque en la multiplicación matricial, los productos entre elementos se hacen con el operador \verb|*|, que es el correcto cuando los elementos son números; pero cuando los elementos son también matrices, la multiplicación de elementos debe realizarse con el operador del producto matricial. En el ejemplo anterior, los bloques se multiplicaron elemento a elemento. Para indicarle a Maxima la operación correcta, debemos hacer uso de la variable global \verb|matrix_element_mult|\index{matrix\_element\_mult},

\begin{Verbatim}
(%i62) matrix_element_mult : "." $
\end{Verbatim}
\begin{Verbatim}
(%i63) m . m ;
\end{Verbatim}
$$\begin{pmatrix}
    \begin{pmatrix}2&0\cr 0&2\cr \end{pmatrix} & \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}\cr 
    \begin{pmatrix}0&0\cr 0&0\cr \end{pmatrix}&\begin{pmatrix}2&0\cr 0&2\cr \end{pmatrix}\cr 
  \end{pmatrix} \leqno{\tt (\%o63)}$$












\section{Patrones y reglas}

En un programa de cálculo simbólico, éste no sólo debe tener información sobre una función u operación a partir de su definición, sino que también habrá propiedades y reglas de transformación de expresiones de las que un programa como Maxima debe tener noticia.

Nos planteamos la siguiente situación: necesitamos trabajar con una función $G(x,y)$ que, independientemente de que esté definida o no, sabemos que es igual a la expresión $\frac{H(x,y)}{x}$ en todo su dominio, siendo $H(x,y)$ otra función; queremos que la primera expresión sea sustituída por la segunda y además queremos tener bajo control estas sustituciones. Todo ello se consigue trabajando con patrones y reglas.

Antes de definir la regla de sustitución es necesario saber a qué patrones será aplicable, para lo cual admitiremos que los argumentos de $G(x,y)$ pueden tener cualquier forma:

\index{matchdeclare}\begin{Verbatim}
(%i1) matchdeclare ([x,y], true);
\end{Verbatim}
\[
\mathrm{done}\leqno{\tt (\%o1)}
\]

En este caso, las variables patrón serán \verb|x| e \verb|y|, siendo el segundo argumento una función de predicado\footnote{Se denominan así todas aquellas funciones que devuelven como resultado de su evaluación \emph{true} o \emph{false}.} que devolverá \verb|true| si el patrón se cumple; en el caso presente, el patrón es universal y admite cualquier formato para estas variables. Si quisiésemos que la regla se aplicase sólo a números enteros, se debería escribir \verb|matchdeclare ([x,y], integerp)|; si quisiésemos que la regla se aplicase siempre que \verb|x| sea un número, sin imponer restricciones a \verb|y|, escribiríamos \verb|matchdeclare (x, numberp, y, true)|. Como se ve, los argumentos impares son variables o listas de variables y los pares las condiciones de los patrones.

Se define ahora la regla de sustitución indicada más arriba, a la que llamaremos \verb|regla1|,

\index{defrule}\begin{Verbatim}
(%i2) defrule (regla1, G(x,y), H(x,y)/x);
\end{Verbatim}
\[
{\it regla_1}:G\left(x , y\right)\rightarrow {{H\left(x , y\right)
 }\over{x}}\leqno{\tt (\%o2)}
\]

Aplicamos ahora la regla a las expresiones $G(f,2+k)$ y $G(G(4,6),2+k)$,

\index{apply1}\begin{Verbatim}
(%i3) apply1(G(f,2+k),regla1);
\end{Verbatim}
\[
{{H\left(f , k+2\right)}\over{f}}\leqno{\tt (\%o3)}
\]
\begin{Verbatim}
(%i4) apply1(G(G(4,6),2+k),regla1);
\end{Verbatim}
\[
{{4\,H\left({{H\left(4 , 6\right)}\over{4}} , k+2\right)}\over{H
 \left(4 , 6\right)}}\leqno{\tt (\%o4)}
\]

Como se ve en este último ejemplo, la regla se aplica a todas las subexpresiones que contengan a la función $G$. Además, \verb|apply1| aplica la regla desde fuera hacia adentro. La variable global \verb|maxapplydepth|\index{maxapplydepth} indica a Maxima hasta qué nivel puede bajar en la expresión para aplicar la regla; su valor por defecto es 10000, pero se lo podemos cambiar,

\begin{Verbatim}
(%i5) maxapplydepth;
\end{Verbatim}
\[
10000\leqno{\tt (\%o5)}
\]
\begin{Verbatim}
(%i6) maxapplydepth:1;
\end{Verbatim}
\[
1\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) apply1(G(G(4,6),2+k),regla1);
\end{Verbatim}
\[
{{H\left(G\left(4 , 6\right) , k+2\right)}\over{G\left(4 , 6\right)
 }}\leqno{\tt (\%o7)}
\]

Quizás sea nuestro deseo realizar la sustitución desde dentro hacia fuera, controlando también a qué niveles se aplica; \verb|applyb1|\index{applyb1} y \verb|maxapplyheight|\index{maxapplyheight} son las claves ahora.

\begin{Verbatim}
(%i8) maxapplyheight:1;
\end{Verbatim}
\[
1\leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) applyb1(G(G(4,6),2+k),regla1);
\end{Verbatim}
\[
G\left({{H\left(4 , 6\right)}\over{4}} , k+2\right)\leqno{\tt (\%o9)}
\]

Obsérvese que hemos estado controlando el comportamiento de las funciones $G$ y $H$ sin haberlas definido explícitamente, pero nada nos impide hacerlo,

\begin{Verbatim}
(%i10) H(u,v):= u^v+1;
                                     v
(%o10)                   H(u, v) := u  + 1
(%i11) applyb1(G(G(4,6),2+k),regla1);
\end{Verbatim}
\[
G\left({{4097}\over{4}} , k+2\right)\leqno{\tt (\%o11)}
\]

Continuemos esta exposición con un ejemplo algo más sofisticado. Supongamos que cierta función $F$ verifica la igualdad
\[
F(x_1+x_2+\ldots+x_n) = F(x_1) + F(x_2) + \ldots + F(x_n) + x_1 x_2 \ldots x_n
\]
y que queremos definir una regla que realice esta transformación. Puesto que la regla se aplicará sólo cuando el argumento de $F$ sea un sumando, necesitamos una función de predicado que defina este patrón,

\index{matchdeclare}\begin{Verbatim}
(%i12) esunasuma(expr):= not atom(expr) and op(expr)="+" $
(%i13) matchdeclare(z,esunasuma)$
\end{Verbatim}

En la definición de la nueva regla, le indicamos a Maxima que cada vez que se encuentre con la función $F$ y que ésta tenga como argumento una suma, la transforme según se indica: \verb|map(F, args(z))| aplica la función a cada uno de los sumandos de \verb|z|, sumando después estos resultados con la función \verb|apply|, finalmente a este resultado se le suma el producto de los sumandos de \verb|z|,

\index{defrule}\begin{Verbatim}
(%i14) defrule(regla2, 
               F(z),
               apply("+",map(F, args(z))) + apply("*", args(z)));
\end{Verbatim}
\[
{\it regla_2}:F\left(z\right)\rightarrow {\it apply}\left(
 \mbox{{}+{}} , {\it map}\left(F , {\it args}\left(z\right)\right)
 \right)+{\it apply}\left(\mbox{{}*{}} , {\it args}\left(z\right)
 \right)\leqno{\tt (\%o14)}
\]

Veamos unos cuantos resultados de la aplicación de esta regla,

\index{apply1}\begin{Verbatim}
(%i15) apply1(F(a+b), regla2);
\end{Verbatim}
\[
F\left(b\right)+a\,b+F\left(a\right)\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) apply1(F(a+b), regla2) - apply1(F(a+c), regla2) ;
\end{Verbatim}
\[
-F\left(c\right)-a\,c+F\left(b\right)+a\,b\leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) apply1(F(a+b+c), regla2);
\end{Verbatim}
\[
F\left(c\right)+a\,b\,c+F\left(b\right)+F\left(a\right)\leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) apply1(F(4), regla2);
\end{Verbatim}
\[
F\left(4\right)\leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) apply1(F(4+5), regla2);
\end{Verbatim}
\[
F\left(9\right)\leqno{\tt (\%o19)}
\]
\index{simp}\begin{Verbatim}
(%i20) simp:false$  /* inhibe la simplificación de Maxima */
(%i21) apply1(F(4+5), regla2);
\end{Verbatim}
\[
4\,5+\left(F\left(4\right)+F\left(5\right)\right)\leqno{\tt (\%o21)}
\]
\begin{Verbatim}
(%i22) simp:true$   /* restaura la simplificación de Maxima */
(%i23) %o21;
\end{Verbatim}
\[
F\left(5\right)+F\left(4\right)+20\leqno{\tt (\%o23)}
\]

En los ejemplos recién vistos, hemos tenido que indicar expresamente a Maxima en qué momento debe aplicar una regla. Otro mecanismo de definición de reglas es el aportado por \verb|tellsimp|\index{tellsimp} y \verb|tellsimpafter|\index{tellsimpafter}; el primero define reglas a aplicar antes de que Maxima aplique las suyas propias, y el segundo para reglas que se aplican después de las habituales de Maxima.

Otra función útil en estos contextos es \verb|declare|\index{declare}, con la que se pueden declarar propiedades algebraicas a nuevos operadores. A continuación se declara una operación de nombre \verb|o| como \emph{infija} (esto es, que sus operandos se colocan a ambos lados del operador); obsérvese que sólo cuando la operación se declara como conmutativa Maxima considera que \verb|a o b| es lo mismo que \verb|b o a|, además, no ha sido necesario definir qué es lo que hace la nueva operación con sus argumentos,

\index{infix}\begin{Verbatim}
(%i24) infix("o");
\end{Verbatim}
\[
\mbox{{}o{}}\leqno{\tt (\%o24)}
\]
\index{is}\begin{Verbatim}
(%i25) is(a o b = b o a);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o25)}
\]
\index{declare}\begin{Verbatim}
(%i26) declare("o", commutative)$
(%i27) is(a o b = b o a);
\end{Verbatim}
\[
\mathrm{true}\leqno{\tt (\%o27)}
\]








\newpage
\chapter{Cálculo}


\section{Funciones matemáticas}

En Maxima están definidas un gran número de funciones, algunas de las cuales se presentan en la 
Figura~\ref{fig:funciones}. A continuación se desarrollan algunos ejemplos sobre su uso.

\index{abs}\index{min}\index{max}\index{signum}\index{binomial}\index{genfact}\index{sqrt}\index{exp}\index{log}\index{sin}\index{cos}\index{tan}\index{csc}\index{sec}\index{cot}\index{asin}\index{acos}\index{atan}\index{atan2}\index{sinh}\index{cosh}\index{tanh}\index{asinh}\index{acosh}\index{atanh}\index{gamma}\index{beta}\index{erf}\begin{figure}
\begin{center}
\begin{tabular}{|c|c|} \hline
\verb|abs(x)|   &    $\mbox{abs}(x)$     \\ \hline
\verb|min(x1,x2,...)|   &    $\min(x_1,x_2,\ldots)$     \\ \hline
\verb|max(x1,x2,...)|   &    $\max(x_1,x_2,\ldots)$     \\ \hline
\verb|signum(x)| &  $\mbox{signo}(x)=\left\{
                                        \begin{array}{rl}
                                           -1 & \mbox{si $x<0$} \\ 
                                            0 & \mbox{si $x=0$} \\ 
                                            1 & \mbox{si $x>0$} 
                                        \end{array}\right.$ \\ \hline
\verb|x!|  &    $x!$     \\ \hline
\verb|x!!|  &    $x!!$     \\ \hline
\verb|binomial(m,n)|  &    $\binom{m}{n}=\frac{m(m-1)\ldots[m-(n-1)]}{n!}$     \\ \hline
\verb|genfact(m,n,p)|  &    $m(m-p)(m-2p)\ldots[m-(n-1)p]$    \\ \hline
\verb|sqrt(x)|   &    $\sqrt{x}$     \\ \hline
\verb|exp(x)|    &    $e^x$      \\ \hline
\verb|log(x)|    &    $\ln(x)$      \\ \hline
\verb|sin(x)|    &    $\sin(x)$      \\ \hline
\verb|cos(x)|    &    $\cos(x)$      \\ \hline
\verb|tan(x)|    &    $\tan(x)$      \\ \hline
\verb|csc(x)|    &    $\csc(x)$      \\ \hline
\verb|sec(x)|    &    $\sec(x)$      \\ \hline
\verb|cot(x)|    &    $\cot(x)$      \\ \hline
\verb|asin(x)|   &    $\arcsin(x)$      \\ \hline
\verb|acos(x)|   &    $\arccos(x)$      \\ \hline
\verb|atan(x)|   &    $\arctan(x)$      \\ \hline
\verb|atan2(x,y)|&    $\arctan(\frac{x}{y}) \in (-\pi,\pi)$      \\ \hline
\verb|sinh(x)|   &    $\sinh(x)=\frac{1}{2}(e^x-e^{-x})$      \\ \hline
\verb|cosh(x)|   &    $\cosh(x)=\frac{1}{2}(e^x+e^{-x})$      \\ \hline
\verb|tanh(x)|   &    $\tanh(x)=\frac{\sinh(x)}{\cosh(x)}$      \\ \hline
\verb|asinh(x)|   &    $\mbox{arcsinh}(x)$      \\ \hline
\verb|acosh(x)|   &    $\mbox{arccosh}(x)$      \\ \hline
\verb|atanh(x)|   &    $\mbox{arctanh}(x)$      \\ \hline
\verb|gamma(x)|  &    $\Gamma(x)=\int_0^\infty e^{-u}u^{x-1}du, \forall x>0$      \\ \hline
\verb|gamma_incomplete(a,x)|  &  
      $\Gamma(a,x)=\int_x^\infty e^{-t}t^{a-1}dt$      \\ \hline
\verb|beta(a,b)| &  $\mbox{B}(a,b)=\frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)}$     \\ \hline
\verb|beta_incomplete(a,b,x)| &  
      $\mbox{B}(a,b,x)=\int_0^x (1-t)^{b-1} t^{a-1}dt$   \\ \hline
\verb|erf(x)|    &    $\mbox{erf}(x)=\int_0^x \frac{2}{\sqrt{\pi}}e^{-u^2}du$      \\ \hline
\end{tabular}
\end{center}
\caption{Algunas funciones de Maxima.}
\label{fig:funciones}
\end{figure}


Empecemos por algunos ejemplos,
\begin{Verbatim}
(%i1) log(%e);
\end{Verbatim}
\[
1\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) abs(-3^-x);
\end{Verbatim}
\[
{{1}\over{3^{x}}}\leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) signum(-3^-x);
\end{Verbatim}
\[
-1\leqno{\tt (\%o3)}
\]

La función \verb|genfact(m,n,p)|\index{genfact} es el factorial generalizado, de forma que \verb|genfact(m,m,1)| coincide con $m!$,
\begin{Verbatim}
(%i4) genfact(5,5,1)-5!;
\end{Verbatim}
\[
0\leqno{\tt (\%o4)}
\]
y \verb|genfact(m,m/2,2)| es igual a $m!!$,
\begin{Verbatim}
(%i5) genfact(5,5/2,2)-5!!;
\end{Verbatim}
\[
0\leqno{\tt (\%o5)}
\]

Maxima siempre devuelve resultados exactos, que nosotros podemos solicitar en formato decimal,
\index{asin}\begin{Verbatim}
(%i6) asin(1);
\end{Verbatim}
\[
{{\pi}\over{2}}\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) float(%);
\end{Verbatim}
\[
1.570796326794897\leqno{\tt (\%o7)}
\]

Pero si damos el argumento en formato decimal, Maxima también devuelve el resultado en este mismo formato, sin necesidad de hacer uso de \verb|float|,
\begin{Verbatim}
(%i8) asin(1.0);
\end{Verbatim}
\[
1.570796326794897\leqno{\tt (\%o8)}
\]

Recordemos que el formato decimal lo podemos pedir con precisión arbitraria,
\begin{Verbatim}
(%i9) fpprec:50$ bfloat(%o8);
\end{Verbatim}
\[
1.5707963267948966192313216916397514420985846996876_B \times 10^{0}\leqno{\tt (\%o9)}
\]

La función de error está relacionada con la función de distribución de la variable aleatoria normal $X \sim \normal(0,1)$ de la forma
\[
\Phi(x)=\Pr(X \leq x)=\frac{1}{2}+\frac{1}{2}\mbox{erf}\left(\frac{x}{\sqrt{2}} \right),
\]
por lo que la probabilidad de que esta variable tome un valor menor que $1.5$ es
\index{erf}\begin{Verbatim}
(%i10) 0.5+0.5*erf(1.5/sqrt(2)),numer;
\end{Verbatim}
\[
0.9331927987311419\leqno{\tt (\%o10)}
\]

Una forma más elegante de hacer lo anterior es definir nuestra propia función de distribución a partir de la de error, para lo que se hace uso del símbolo \verb|:=|,
\index{28@:=}\begin{Verbatim}
(%i11) F(x):=1/2+erf(x/sqrt(2))/2 $
(%i12) F(1.5),numer;
\end{Verbatim}
\[
0.9331927987311419\leqno{\tt (\%o12)}
\]

No terminan aquí las funciones de Maxima; junto a las ya expuestas habría que incluir las funciones de Airy, elípticas y de Bessel, sobre las que se podrá obtener más información ejecutando la instrucción \verb|??| y utilizando como argumento \verb|airy|\index{airy}, \verb|elliptic|\index{elliptic} o \verb|bessel|\index{bessel}, según el caso. Por ejemplo,
\begin{Verbatim}
(%i13) ?? airy

 0: airy_ai  (Funciones y variables para las funciones especiales)
 1: airy_bi  (Funciones y variables para las funciones especiales)
 2: airy_dai  (Funciones y variables para las funciones especiales)
 3: airy_dbi  (Funciones y variables para las funciones especiales)
Enter space-separated numbers, `all' or `none': 0

 -- Función: airy_ai (<x>)
     Función Ai de Airy, tal como la definen Abramowitz y Stegun,
     Handbook of Mathematical Functions, Sección 10.4.

     La ecuación de Airy `diff (y(x), x, 2) - x y(x) = 0' tiene dos
     soluciones linealmente independientes, `y = Ai(x)' y `y = Bi(x)'.
     La derivada `diff (airy_ai(x), x)' es `airy_dai(x)'.

     Si el argumento `x' es un número decimal real o complejo, se
     devolverá el valor numérico de `airy_ai' siempre que sea posible.

     Véanse `airy_bi', `airy_dai' y `airy_dbi'.
\end{Verbatim}

Maxima reconoce los dominios en el plano complejo de las funciones; los siguientes ejemplos lo demuestran:
\begin{Verbatim}
(%i14) sin(%i);
\end{Verbatim}
\[
i\,\sinh 1\leqno{\tt (\%o14)}
\]
\begin{Verbatim}
(%i15) log(-3.0);
\end{Verbatim}
\[
3.141592653589793\,i+1.09861228866811\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) asin(2.0);
\end{Verbatim}
\[
1.570796326794897-1.316957896924817\,i\leqno{\tt (\%o16)}
\]







\section{Límites}

Sin más preámbulos, veamos algunos ejemplos de cómo calcular límites con la asistencia de Maxima. En primer lugar vemos que es posible hacer que la variable se aproxime al infinito ($x \rightarrow \infty$) haciendo uso del símbolo \verb|inf|\index{inf}, o que se aproxime al menos infinito ($x \rightarrow -\infty$) haciendo uso de \verb|minf|\index{minf},
\index{limit}\begin{Verbatim}
(%i1) limit(1/sqrt(x),x,inf);
\end{Verbatim}
\[
0\leqno{\tt (\%o1)}
\]

\begin{Verbatim}
(%i2) limit((exp(x)-exp(-x))/(exp(x)+exp(-x)),x,minf);
\end{Verbatim}
\[
-1\leqno{\tt (\%o2)}
\]
que nos permite calcular $\lim_{x \rightarrow \infty} \frac{1}{\sqrt{x}}$ y 
$\lim_{x \rightarrow -\infty} \frac{e^x-e^{-x}}{e^x+e^{-x}}$, respectivamente.

Los siguientes ejemplos muestran límites en los que la variable $x$ se aproxima a puntos de discontinuidad,
\begin{Verbatim}
(%i3) limit((x^2-x/3-2/3)/(5*x^2-11*x+6),x,1);
\end{Verbatim}
\[
-{{5}\over{3}}\leqno{\tt (\%o3)}
\]
\begin{Verbatim}
(%i4) limit(1/(x-1)^2,x,1);
\end{Verbatim}
\[
\infty \leqno{\tt (\%o4)}
\]
donde hemos obtenido los resultados
\[
\lim_{x \rightarrow 1} \frac{x^2-\frac{x}{3}-\frac{2}{3}}{5x^2-11x+6}=-\frac{5}{3}
\]
y
\[
\lim_{x \rightarrow 1} \frac{1}{(x-1)^2}=\infty.
\]

Sin embargo, ciertos límites no se pueden resolver sin aportar información adicional, tal es el caso de
$\lim_{x \rightarrow 1} \frac{1}{x-1}$, para el que podemos hacer
\begin{Verbatim}
(%i5) limit(1/(x-1),x,1);
\end{Verbatim}
\[
\mbox{infinity}\leqno{\tt (\%o5)}
\]
donde Maxima nos responde con el símbolo \verb|und|\index{und} de \emph{undefined} o indefinido. En tales situaciones podemos indicarle al asistente que la variable $x$ se aproxima a 1 por la derecha ($x \rightarrow 1^+$) o por la izquierda ($x \rightarrow 1^-$),
\index{plus}\index{minus}\begin{Verbatim}
(%i6) limit(1/(x-1),x,1,plus);
\end{Verbatim}
\[
\infty \leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) limit(1/(x-1),x,1,minus);
\end{Verbatim}
\[
 -\infty \leqno{\tt (\%o7)}
\]




\section{Derivadas}

Maxima controla el cálculo de derivadas mediante la instrucción \verb|diff|\index{diff}. A continuación se presentan algunos ejemplos sobre su uso,
\begin{Verbatim}
(%i1) diff(x^log(a*x),x);  /* primera derivada */
\end{Verbatim}
\[
x^{\log \left(a\,x\right)}\,\left({{\log \left(a\,x\right)}\over{x
 }}+{{\log x}\over{x}}\right)\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) diff(x^log(a*x),x,2); /*derivada segunda*/
\end{Verbatim}
\[
x^{\log \left(a\,x\right)}\,\left({{\log \left(a\,x\right)}\over{x
 }}+{{\log x}\over{x}}\right)^2+x^{\log \left(a\,x\right)}\,\left(-{{
 \log \left(a\,x\right)}\over{x^2}}-{{\log x}\over{x^2}}+{{2}\over{x^2
 }}\right)\leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) factor(%); /* ayudamos a Maxima a mejorar el resultado */
\end{Verbatim}
\[
x^{\log \left(a\,x\right)-2}\,\left(\log ^2\left(a\,x\right)+2\,
 \log x\,\log \left(a\,x\right)-\log \left(a\,x\right)+\log ^2x-\log 
 x+2\right)\leqno{\tt (\%o3)}
\]
donde se han calculado la primera y segunda derivadas de la función $y=x^{\ln(ax)}$. Nótese que en la entrada \verb|(%i3)| se le ha pedido al programa que factorizase la salida \verb|(%o2)|.

Pedimos ahora a Maxima que nos calcule el siguiente resultado que implica derivadas parciales,
\[
\frac{\vartheta^{10}}{\vartheta x^3 \vartheta y^5 \vartheta z^2} \left( e^x \sin(y) \tan(z) \right) = 
  2 e^x \cos(y) \sec^2(z) \tan(z).
\]

\begin{Verbatim}
(%i4) diff(exp(x)*sin(y)*tan(z),x,3,y,5,z,2);
\end{Verbatim}
\[
2\,e^{x}\,\cos y\,\sec ^2z\,\tan z\leqno{\tt (\%o4)}
\]

Maxima también nos puede ayudar a la hora de aplicar la regla de la cadena en el cálculo de derivadas de funciones vectoriales con variable también vectorial. Supónganse que cierta variable $z$ depende de otras dos $x$ y $y$, las cuales a su vez dependen de $u$ y $v$. Veamos cómo se aplica la regla de la cadena para obtener
$\frac{\vartheta z}{\vartheta v}$, $\frac{\vartheta z^2}{\vartheta y \vartheta v}$ o $\frac{\vartheta z^2}{\vartheta u \vartheta v}$.
\index{depends}\begin{Verbatim}
(%i5) depends(z,[x,y],[x,y],[u,v]);
\end{Verbatim}
\[
\left[ z\left(x , y\right) , x\left(u , v\right) , y\left(u , v
 \right) \right] \leqno{\tt (\%o5)}
\]
\begin{Verbatim}
(%i6) diff(z,v,1);
\end{Verbatim}
\[
{{d}\over{d\,v}}\,y\,\left({{d}\over{d\,y}}\,z\right)+{{d}\over{d\,
 v}}\,x\,\left({{d}\over{d\,x}}\,z\right)\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) diff(z,y,1,v,1);
\end{Verbatim}
\[
{{d}\over{d\,v}}\,y\,\left({{d^2}\over{d\,y^2}}\,z\right)+{{d
 }\over{d\,v}}\,x\,\left({{d^2}\over{d\,x\,d\,y}}\,z\right)\leqno{\tt (\%o7)}
\]
\begin{Verbatim}
(%i8) diff(z,u,1,v,1);
\end{Verbatim}
\[
\begin{array}{l}
{{d}\over{d\,u}}\,y\,\left({{d}\over{d\,v}}\,y\,\left({{d^2}\over{d
 \,y^2}}\,z\right)+{{d}\over{d\,v}}\,x\,\left({{d^2}\over{d\,x\,d\,y
 }}\,z\right)\right)+{{d^2}\over{d\,u\,d\,v}}\,y\,\left({{d}\over{d\,
 y}}\,z\right)+ \\
{{d}\over{d\,u}}\,x\,\left({{d}\over{d\,v}}\,x\,\left(
 {{d^2}\over{d\,x^2}}\,z\right)+{{d}\over{d\,v}}\,y\,\left({{d^2
 }\over{d\,x\,d\,y}}\,z\right)\right)+{{d^2}\over{d\,u\,d\,v}}\,x\,
 \left({{d}\over{d\,x}}\,z\right) \end{array} \leqno{\tt (\%o8)}
\]

La función \verb|depends| admite un número par de argumentos, los cuales pueden ser variables o listas de variables. Las que ocupan los lugares impares son las variables dependientes y las que están en las posiciones pares las independientes; denominación ésta que tiene aquí un sentido relativo, ya que una misma variable, como la \verb|x| de la entrada \verb|%i5|, puede actuar como independiente respecto de \verb|z| y como dependiente respecto de \verb|u| y \verb|v|.

En cualquier momento podemos solicitarle a Maxima que nos recuerde el cuadro de dependencias,
\index{dependencies}\begin{Verbatim}
(%i9) dependencies;
\end{Verbatim}
\[
\left[ z\left(x , y\right) , x\left(u , v\right) , y\left(u , v
 \right) \right] \leqno{\tt (\%o9)}
\]

También podemos eliminar algunas de la dependencias previamente especificadas,
\index{remove}\begin{Verbatim}
(%i10) remove(x,dependency);
\end{Verbatim}
\[
\mbox{done}\leqno{\tt (\%o10)}
\]
\begin{Verbatim}
(%i11) dependencies;
\end{Verbatim}
\[
\left[ z\left(x , y\right) , y\left(u , v\right) \right] \leqno{\tt (\%o11)}
\]
\begin{Verbatim}
(%i12) diff(z,y,1,v,1);
\end{Verbatim}
\[
{{d}\over{d\,v}}\,y\,\left({{d^2}\over{d\,y^2}}\,z\right)\leqno{\tt (\%o12)}
\]

Veamos cómo deriva Maxima funciones definidas implícitamente. En el siguiente ejemplo, para evitar que \verb|y| sea considerada una constante, le declararemos una dependencia respecto de \verb|x|,
\begin{Verbatim}
(%i13) depends(y,x)$
\end{Verbatim}
\begin{Verbatim}
(%i14) diff(x^2+y^3=2*x*y,x);
\end{Verbatim}
\[
3\,y^2\,\left({{d}\over{d\,x}}\,y\right)+2\,x=2\,x\,\left({{d
 }\over{d\,x}}\,y\right)+2\,y\leqno{\tt (\%o14)}
\]

Cuando se solicita el cálculo de una derivada sin especificar la variable respecto de la cual se deriva, Maxima utilizará el símbolo \verb|del|\index{del} para representar las diferenciales, 
\begin{Verbatim}
(%i15) diff(x^2);
\end{Verbatim}
\[
2\,x\,{\it del}\left(x\right)\leqno{\tt (\%o15)}
\]
lo que se interpretará como $2x dx$. Si en la expresión a derivar hay más de una variable, habrá diferenciales para todas,
\begin{Verbatim}
(%i16) diff(x^2+y^3=2*x*y);
\end{Verbatim}
\[
\left(3\,y^2\,\left({{d}\over{d\,x}}\,y\right)+2\,x\right)\,
 {\it del}\left(x\right)=\left(2\,x\,\left({{d}\over{d\,x}}\,y\right)
 +2\,y\right)\,{\it del}\left(x\right)\leqno{\tt (\%o16)}
\]

Recuérdese que durante este cálculo estaba todavía activa la dependencia declarada en la entrada \verb|(%i13)|.

Finalmente, para acabar esta sección, hagamos referencia al desarrollo de Taylor de tercer grado de la función
\[
y=\frac{x \ln x}{x^2-1}
\]
en el entorno de $x=1$,
\index{taylor}\begin{Verbatim}
(%i17) taylor((x*log(x))/(x^2-1),x,1,3);
\end{Verbatim}
\[
{{1}\over{2}}-{{\left(x-1\right)^2}\over{12}}+{{\left(x-1\right)^3
 }\over{12}}+\cdots \leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) expand(%);
\end{Verbatim}
\[
{{x^3}\over{12}}-{{x^2}\over{3}}+{{5\,x}\over{12}}+{{1}\over{3}}\leqno{\tt (\%o18)}
\]

A continuación un ejemplo de desarrollo multivariante de la función $y=\exp(x^2 \sin(x y))$ alrededor del punto $(2,0)$ hasta grado 2 respecto de cada variable,
\begin{Verbatim}
(%i19) taylor(exp(x^2*sin(x*y)),[x,2,2],[y,0,2]);
\end{Verbatim}
\[
1+8\,y+32\,y^2+\cdots +\left(12\,y+96\,y^2+\cdots \right)\,\left(x-2
 \right)+\left(6\,y+120\,y^2+\cdots \right)\,\left(x-2\right)^2
 +\cdots \leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) expand(%);
\end{Verbatim}
\[
120\,x^2\,y^2-384\,x\,y^2+320\,y^2+6\,x^2\,y-12\,x\,y+8\,y+1\leqno{\tt (\%o20)}
\]

En ocasiones resulta necesario operar con funciones cuyas derivadas son desconocidas, quizás porque la propia función lo es. Esta situación puede llevar a que Maxima devuelva expresiones realmente complicadas de manipular. Un ejemplo es el siguiente, en el que trabajamos con una función $f$ arbitraria

\begin{Verbatim}
(%i21) taylor(f(x + x^2),x,1,1);
\end{Verbatim}
\[
f\left(2\right)+\left(\left.{{d}\over{d\,x}}\,f\left(x^2+x\right)
 \right|_{x=1}\right)\,\left(x-1\right)+\cdots \leqno{\tt (\%o21)}
\]

Podemos facilitar las cosas si le definimos una función derivada a $f$, a la que llamaremos $df$,

\index{gradef}\begin{Verbatim}
(%i22) gradef(f(x),df(x))$
(%i23) taylor(f(x+x^2),x,1,1);
\end{Verbatim}
\[
f\left(2\right)+3\,{\it df}\left(2\right)\,\left(x-1\right)+\cdots \leqno{\tt (\%o23)}
\]

El paquete \verb|pdiff|\index{pdiff}, que se encuentra en la carpeta \verb|share/contrib/|, aporta una solución alternativa a este problema.




\section{Integrales}

La función de Maxima que controla el cálculo de integrales es \verb|integrate|\index{integrate}, tanto para las definidas como indefinidas; empecemos por estas últimas,
\begin{Verbatim}
(%i1) integrate(cos(x)^3/sin(x)^4,x);
\end{Verbatim}
\[
{{3\,\sin ^2x-1}\over{3\,\sin ^3x}}\leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) integrate(a[3]*x^3+a[2]*x^2+a[1]*x+a[0],x);
\end{Verbatim}
\[
{{a_{3}\,x^4}\over{4}}+{{a_{2}\,x^3}\over{3}}+{{a_{1}\,x^2}\over{2
 }}+a_{0}\,x\leqno{\tt (\%o2)}
\]
que nos devuelve, respectivamente, las integrales
\[
\int \frac{\cos^3 x}{\sin^4 x} dx
\]
y
\[
\int (a_3 x^3+a_2 x^2+a_1 x + a_0) dx.
\]

Además, este último ejemplo nos ofrece la oportunidad de ver cómo escribir coeficientes con subíndices.

Ahora un par de ejemplos sobre la integral definida,
\index{positive}\index{negative}\index{zero}\begin{Verbatim}
(%i3) integrate(2*x/((x-1)*(x+2)),x,3,5);
\end{Verbatim}
\[
2\,\left({{2\,\log 7}\over{3}}-{{2\,\log 5}\over{3}}+{{\log 4
 }\over{3}}-{{\log 2}\over{3}}\right)\leqno{\tt (\%o3)}
\]
\begin{Verbatim}
(%i4) float(%);   /*aproximación decimal*/
\end{Verbatim}
\[
0.9107277692015807\leqno{\tt (\%o4)}
\]
\begin{Verbatim}
(%i5) integrate(asin(x),x,0,u);
Is  u  positive, negative, or zero?

positive;
\end{Verbatim}
\[
u\,\arcsin u+\sqrt{1-u^2}-1\leqno{\tt (\%o5)}
\]
esto es,
\[
\int_3^5 \frac{2x}{(x-1)(x+2)} dx \approx 0.91072776920158
\]
y
\[
\int_0^u \arcsin(x) dx = u \arcsin(u) + \sqrt{1-u^2}-1, \forall u>0.
\]
Nótese en este último ejemplo cómo antes de dar el resultado Maxima pregunta si $u$ es positivo, negativo o nulo; tras contestarle escribiendo \verb|positive;| (punto y coma incluido) obtenemos finalmente el resultado. En previsión de situaciones como esta, podemos darle al sistema toda la información relevante sobre los parámetros utilizados antes de pedirle el cálculo de la integral,

\index{assume}\begin{Verbatim}
(%i6) assume(u>0);
\end{Verbatim}
\[
\left[ u>0 \right] \leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) integrate(asin(x),x,0,u);
\end{Verbatim}
\[
u\,\arcsin u+\sqrt{1-u^2}-1\leqno{\tt (\%o7)}
\]

Cuando Maxima no puede resolver la integral, siempre queda el recurso de los métodos numéricos. El paquete \verb|quadpack|\index{quadpack}, escrito inicialmente en Fortran y portado a Lisp para Maxima, es el encargado de estos menesteres; dispone de varias funciones, pero nos detendremos tan sólo en dos de ellas, siendo la primera la utilizada para integrales definidas en intervalos acotados,
\label{pag:quad}
\begin{Verbatim}
(%i8) /* El integrador simbólico no puede con esta integral */
      integrate(exp(sin(x)),x,2,7);
\end{Verbatim}
\[
\int_{2}^{7}{e^{\sin x}\;dx}\leqno{\tt (\%o8)}
\]
\begin{Verbatim}
(%i9) /* Resolvemos numéricamente */
      quad_qag(exp(sin(x)),x,2,7,3);
\end{Verbatim}
\[
\left[ 4.747336298073747 , 5.27060206376023 \times 10^{-14} , 31 , 0
  \right] \leqno{\tt (\%o9)}
\]

La función \verb|quad_qag|\index{quad\_qag} tiene un argumento extra, que debe ser un número entero entre 1 y 6, el cual hace referencia al algoritmo que la función debe utilizar para la cuadratura; la regla heurística a seguir por el usuario es dar un número tanto más alto cuanto más oscile la función en el intervalo de integración. El resultado que obtenemos es una lista con cuatro elementos: el valor aproximado de la integral, la estimación del error, el número de veces que se tuvo que evaluar el integrando y, finalmente, un código de error que será cero si no surgieron problemas.

La otra función de integración numérica a la que hacemos referencia es \verb|quad_qagi|\index{quad\_qagi}, a utilizar en intervalos no acotados. En el siguiente ejemplo se pretende calcular la probabilidad de que una variable aleatoria $\chi^2$ de $n=4$ grados de libertad, sea mayor que la unidad ($\Pr(\chi^2_4 > 1)$),

\begin{Verbatim}
(%i10) n:4$
(%i11) integrate(x^(n/2-1)*exp(-y/2)/2^(n/2)*gamma(n/2),x,1,inf);
Integral is divergent
 -- an error.  To debug this try debugmode(true);
\end{Verbatim}

\begin{Verbatim}
(%i12) quad_qagi(x^(n/2-1)*exp(-x/2)/2^(n/2)*gamma(n/2),x,1,inf);
\end{Verbatim}
\[
\left[ .9097959895689501 , 1.913452127046495 \times 10^{-10} , 165
  , 0 \right] \leqno{\tt (\%o12)}
\]

El integrador simbólico falla emitiendo un mensaje sobre la divergencia de la integral. La función \verb|quad_qagi| ha necesitado 165 evaluaciones del integrando para alcanzar una estimación numérica de la integral, la cual se corresponde aceptablemente con la estimación que hacen los algoritmos del paquete de distribuciones de probabilidad (ver Sección~\ref{probinf}).

Otras funciones de cuadratura numérica son \verb|quad_qags|\index{quad\_qags}, \verb|quad_qawc|\index{quad\_qawc}, \verb|quad_qawf|\index{quad\_qawf}, \verb|quad_qawo|\index{quad\_qawo} y \verb|quad_qaws|\index{quad\_qaws}, cuyas peculiaridades podrá consultar el lector interesado en el manual de referencia.

La transformada de Laplace de una función $f(x)$ se define como la integral
\[
L(p)=\int_0^\infty f(x) e^{-p x} dx,
\]
siendo $p$ un número complejo. Así, la transformada de Laplace de $f(x)=k e^{-k x}$ es
\index{laplace}\begin{Verbatim}
(%i13) laplace(k*exp(-k*x),x,p);
\end{Verbatim}
\[
{{k}\over{p+k}}\leqno{\tt (\%o13)}
\]
y calculando la transformada inversa volvemos al punto de partida,
\index{ilt}\begin{Verbatim}
(%i14) ilt(%,p,x);
\end{Verbatim}
\[
k\,e^ {- k\,x }\leqno{\tt (\%o14)}
\]

La transformada de Fourier de una función se reduce a la de Laplace cuando el argumento $p$ toma el valor $-i t$, siendo $i$ la unidad imaginaria y $t \in \R$,
\[
F(t)=\int_0^\infty f(x) e^{i t x} dx.
\]
De esta manera, la transformada de Fourier de $f(x)=k e^{-k x}$ es
\begin{Verbatim}
(%i15) laplace(k*exp(-k*x),x,-%i*t);
\end{Verbatim}
\[
{{k}\over{k-i\,t}}\leqno{\tt (\%o15)}
\]

Nótese que si $x>0$, la $f(x)$ anterior es precisamente la función de densidad de una variable aleatoria exponencial de parámetro $k$, por lo que este último resultado coincide precisamente con la función característica de esta misma distribución.

Puesto que hablamos de la transformada de Fourier, quizás sea este un buen lugar para mencionar la transformada discreta de Fourier. Su cálculo se hace con el algoritmo de la transformada rápida, implementado en la función \verb|fft|\index{fft}, que admite como argumento una lista o array de datos cuya longitud debe ser una potencia de dos. La función inversa está programada en la función \verb|inverse_fft|\index{inverse\_fft}. Para más información, consúltese la documentación correspondiente a estas funciones.

Como comentario final, queda hacer notar que la función \verb|integrate| admite integrandos matriciales, tal como indica el siguiente ejemplo.

\begin{Verbatim}
(%i16) M: matrix([sin(x), x^2+1],[cos(x), exp(x)]);
\end{Verbatim}
$$\begin{pmatrix}\sin x&x^2+1\cr \cos x&e^{x}\cr \end{pmatrix}\leqno{\tt (\%o16)}$$
\begin{Verbatim}
(%i17) 'integrate(M, x) = integrate(M, x);
\end{Verbatim}
$$\int {\begin{pmatrix}\sin x&x^2+1\cr \cos x&e^{x}\cr \end{pmatrix}}{\;dx}=\begin{pmatrix}-
 \cos x&{{x^3}\over{3}}+x\cr \sin x&e^{x}\cr \end{pmatrix}\leqno{\tt (\%o17)}$$



























\section{Ecuaciones diferenciales}

Con Maxima se pueden resolver analíticamente algunas ecuaciones diferenciales ordinarias de primer y segundo orden mediante la instrucción \verb|ode2|\index{ode2}.

Una ecuación diferencial de primer orden tiene la forma general $F(x,y,y')=0$, donde $y'=\frac{dy}{dx}$. Para expresar una de estas ecuaciones se hace uso de \verb|diff|\index{diff},
\begin{Verbatim}
(%i1) /* ecuación de variables separadas */
      ec:(x-1)*y^3+(y-1)*x^3*'diff(y,x)=0;
\end{Verbatim}
\[
x^3\,\left(y-1\right)\,\left({{d}\over{d\,x}}\,y\right)+\left(x-1
 \right)\,y^3=0\leqno{\tt (\%o1)}
\]
siendo obligatorio el uso de la comilla simple (\verb|'|) antes de \verb|diff| al objeto de evitar el cálculo de la derivada, que por otro lado daría cero al no haberse declarado la variable \verb|y| como dependiente de \verb|x|. Para la resolución de esta ecuación tan solo habrá que hacer
\begin{Verbatim}
(%i2) ode2(ec,y,x);
\end{Verbatim}
\[
{{2\,y-1}\over{2\,y^2}}={\it \%c}-{{2\,x-1}\over{2\,x^2}}\leqno{\tt (\%o2)}
\]
donde \verb|%c| representa una constante, que se ajustará de acuerdo a la condición inicial que se le imponga a la ecuación. Supóngase que se sabe que cuando $x=2$, debe verificarse que $y=-3$, lo cual haremos saber a Maxima a través de la función \verb|ic1|\index{ic1},
\begin{Verbatim}
(%i3) ic1(%o2,x=2,y=-3);
\end{Verbatim}
\[
{{2\,y-1}\over{2\,y^2}}=-{{x^2+72\,x-36}\over{72\,x^2}}\leqno{\tt (\%o3)}
\]

Veamos ejemplos de otros tipos de ecuaciones diferenciales que puede resolver Maxima,
\begin{Verbatim}
(%i4) /* ecuacion homogénea */
      ode2(x^3+y^3+3*x*y^2*'diff(y,x),y,x);
\end{Verbatim}
\[
{{4\,x\,y^3+x^4}\over{4}}={\it \%c}\leqno{\tt (\%o4)}
\]
En este caso, cuando no se incluye el símbolo de igualdad, se da por hecho que la expresión es igual a cero.

\begin{Verbatim}
(%i5) /* reducible a homogénea */
      ode2('diff(y,x)=(x+y-1)/(x-y-1),y,x);
\end{Verbatim}
\[
{{\log \left(y^2+x^2-2\,x+1\right)+2\,\arctan \left({{x-1}\over{y}}
 \right)}\over{4}}={\it \%c}\leqno{\tt (\%o5)}
\]

\begin{Verbatim}
(%i6) /* ecuación exacta */
       ode2((4*x^3+8*y)+(8*x-4*y^3)*'diff(y,x),y,x);
\end{Verbatim}
\[
-y^4+8\,x\,y+x^4={\it \%c}\leqno{\tt (\%o6)}
\]

\begin{Verbatim}
(%i7) /* Bernoulli */
       ode2('diff(y,x)-y+sqrt(y),y,x);
\end{Verbatim}
\[
2\,\log \left(\sqrt{y}-1\right)=x+{\it \%c}\leqno{\tt (\%o7)}
\]

\begin{Verbatim}
(%i8) solve(%,y);
\end{Verbatim}
\[
\left[ y=e^{x+{\it \%c}}+2\,e^{{{x}\over{2}}+{{{\it \%c}}\over{2}}}
 +1 \right] \leqno{\tt (\%o8)}
\]
En este último caso, optamos por obtener la solución en su forma explícita. 

Una ecuación diferencial ordinaria de segundo orden tiene la forma general $F(x,y,y',y'')=0$, siendo $y''$ la segunda derivada de $y$ respecto de $x$. Como ejemplo,
\begin{Verbatim}
(%i9) 'diff(y,x)=x+'diff(y,x,2);
\end{Verbatim}
\[
{{d}\over{d\,x}}\,y={{d^2}\over{d\,x^2}}\,y+x\leqno{\tt (\%o9)}
\]

\begin{Verbatim}
(%i10) ode2(%,y,x);
\end{Verbatim}
\[
y={\it \%k_1}\,e^{x}+{{x^2+2\,x+2}\over{2}}+{\it \%k_2}\leqno{\tt (\%o10)}
\]
Maxima nos devuelve un resultado que depende de dos parámetros, \verb|%k1| y \verb|%k2|, que para ajustarlos necesitaremos proporcionar ciertas condiciones iniciales; si sabemos que cuando $x=1$ entonces $y=-1$ y $y'=\left.\frac{dy}{dx}\right|_{x=1}=2$, haremos uso de la instrucción \verb|ic2|\index{ic2},
\begin{Verbatim}
(%i11) ic2(%,x=1,y=-1,diff(y,x)=2);
\end{Verbatim}
\[
y={{x^2+2\,x+2}\over{2}}-{{7}\over{2}}\leqno{\tt (\%o11)}
\]

En el caso de las ecuaciones de segundo orden, también es posible ajustar los parámetros de la solución especificando condiciones de contorno, esto es, fijando dos puntos del plano por los que pase la solución; así, si la solución obtenida en \verb|(%o10)| debe pasar por los puntos $(-1,3)$ y $(2,\frac{5}{3})$, hacemos
\index{bc2}\begin{Verbatim}
(%i12) bc2(%o10,x=-1,y=3,x=2,y=5/3);
\end{Verbatim}
\[
y=-{{35\,e^{x+1}}\over{6\,e^3-6}}+{{x^2+2\,x+2}\over{2}}+{{15\,e^3+20
 }\over{6\,e^3-6}}\leqno{\tt (\%o12)}
\]
Nótese que este cálculo se le solicita a Maxima con \verb|bc2|.


La resolución de sistemas de ecuaciones diferenciales se hace con llamadas a la función \verb|desolve|\index{desolve}. En este contexto es preciso tener en cuenta que se debe utilizar notación funcional dentro de la expresión \verb|diff|; un ejemplo aclarará este punto, resolviendo el sistema
\[
\left\{
   \begin{array}{lcl}
      \frac{df(x)}{dx} & = & 3 f(x) - 2 g(x)  \\
      \frac{dg(x)}{dx} & = & 2 f(x) - 2 g(x)
   \end{array}
\right.
\]
\begin{Verbatim}
(%i13) desolve(['diff(f(x),x)=3*f(x)-2*g(x),
                'diff(g(x),x)=2*f(x)-2*g(x)],
               [f(x),g(x)]);
\end{Verbatim}
\[
\begin{array}{c}
\left[ f\left(x\right)={{\left(2\,g\left(0\right)-f\left(0\right)
 \right)\,e^ {- x }}\over{3}}-{{\left(2\,g\left(0\right)-4\,f\left(0
 \right)\right)\,e^{2\,x}}\over{3}} , \right. \\ \left. g\left(x\right)={{\left(4\,g
 \left(0\right)-2\,f\left(0\right)\right)\,e^ {- x }}\over{3}}-{{
 \left(g\left(0\right)-2\,f\left(0\right)\right)\,e^{2\,x}}\over{3}}
  \right] \end{array} \leqno{\tt (\%o13)}
\]

Como se ve, las referecias a las funciones deben incluir la variable independiente y las ecuaciones estarán acotadas entre corchetes, así como los nombres de las funciones. Observamos en la respuesta que nos da Maxima la presencia de \verb|f(0)| y \verb|g(0)|, lo cual es debido a que se desconocen las condiciones de contorno del sistema.

En este último ejemplo, supongamos que queremos resolver el sistema de ecuaciones diferenciales
\[
\left\{
   \begin{array}{lcl}
      \frac{df(x)}{dx} & = & f(x) + g(x) + 3 h(x) \\
      \frac{dg(x)}{dx} & = & g(x) - 2 h(x) \\
      \frac{dh(x)}{dx} & = & f(x) + h(x) 
   \end{array}
\right.
\]
bajo las condiciones $f(0)=-1$, $g(0)=3$ y $f(0)=1$. En primer lugar introduciremos estas condiciones con la función \verb|atvalue|\index{atvalue}, para posteriormente solicitar la resolución del sistema,
\begin{Verbatim}
(%i14) atvalue(f(x),x=0,-1)$
(%i15) atvalue(g(x),x=0,3)$
(%i16) atvalue(h(x),x=0,1)$
(%i17) desolve(['diff(f(x),x)=f(x)+g(x)+3*h(x),
                'diff(g(x),x)=g(x)-2*h(x),
                'diff(h(x),x)=f(x)+h(x)], [f(x),g(x),h(x)]);
\end{Verbatim}
\[
\left[ f\left(x\right)=x\,e^{2\,x}+e^{2\,x}-2\,e^ {- x } , g\left(x
 \right)=-2\,x\,e^{2\,x}+2\,e^{2\,x}+e^ {- x } , h\left(x\right)=x\,e
 ^{2\,x}+e^ {- x } \right] \leqno{\tt (\%o17)}
\]

La función \verb|desolve| también nos va a permitir resolver ecuaciones de orden mayor que dos. En el siguiente ejemplo, abordamos la resolución de la ecuación
\[
\frac{d^3 y(x)}{dx^3} + \frac{d^2 y(x)}{dx^2} + \frac{d y(x)}{dx} + y(x)=0
\]
bajo las condiciones que se describen a continuación,

\begin{Verbatim}
(%i18) atvalue('diff(y(x),x,2),x=0,v)$
(%i19) atvalue('diff(y(x),x),x=0,u)$
(%i20) atvalue(y(x),x=0,w)$
\end{Verbatim}

Ahora resolvemos,

\begin{Verbatim}
(%i21) desolve('diff(y(x),x,3)+'diff(y(x),x,2)+'diff(y(x),x)+y(x)=0, y(x));
\end{Verbatim}
\[
y\left(x\right)={{\left(w+v+2\,u\right)\,\sin x}\over{2}}+{{\left(w
 -v\right)\,\cos x}\over{2}}+{{\left(w+v\right)\,e^ {- x }}\over{2}}\leqno{\tt (\%o21)}
\]


El paquete \verb|plotdf|\index{plotdf} permite generar campos de direcciones, bien de ecuaciones diferenciales de primer orden
\[
\frac{dy}{dx} = F(x,y),
\]
bien de sistemas 
\[
\left\{
   \begin{array}{ccc}
      \frac{dx}{dt} $ = $ G(x,y) \\
      \frac{dy}{dt} $ = $ F(x,y)
   \end{array}
\right.
\]

Los argumentos a pasar a la función \verb|plotdf| son la función $F$, en el primer caso, y una lista con las funciones $F$ y $G$ en el segundo. Las variables serán siempre $x$ e $y$. Como ejemplo, pidamos a Maxima que genere el campo de direcciones de la ecuación diferencial $\frac{dy}{dx} = 1 + y + y^2$

\begin{Verbatim}
(%i22) load(plotdf)$
(%i23) plotdf(1 + y + y^2);
\end{Verbatim}

El gráfico que resulta es el de la Figura~\ref{fig:plotdf}~\emph{a)}, en el que además se observan dos trayectorias que se dibujaron de forma interactiva al hacer clic sobre dos puntos del plano.

La función \verb|plotdf| admite varias opciones, algunas de las cuales aprovechamos en el siguiente ejemplo. Supongamos el modelo predador-presa de Lotka-Volterra, dependiente de dos parámetros $h$ y $k$,
\[
\left\{
   \begin{array}{ccc}
      \frac{dx}{dt} $ = $ 2 x + h x y \\
      \frac{dy}{dt} $ = $ -x + k x y
   \end{array}
\right.
\]

El siguiente código permite generar el campo de direcciones correspondiente, dándoles inicialmente a $h$ y $k$ los valores -1.2 y 0.9, respectivamente; además, aparecerán sobre la ventana gráfica dos barras de deslizamiento para alterar de forma interactiva estos dos parámetros y ver los cambios que se producen en el campo.

\begin{Verbatim}
(%i24) plotdf([2*x+k*x*y, -y+h*x*y],
              [parameters,"k=-1.2,h=0.9"],
              [sliders,"k=-2:2,h=-2:2"]);
\end{Verbatim}

En la Figura~\ref{fig:plotdf}~\emph{b)} se observa el gráfico obtenido despúes de pedir trayectorias concretas que pasan por varios puntos del plano (en el archivo gráfico no aparecen las barras de deslizamiento).

\begin{figure}
\begin{center}
\includegraphics[scale=0.35]{sdfplot1.pdf}
\includegraphics[scale=0.35]{sdfplot2.pdf} \\
\emph{a)} \hspace{6.5cm}  \emph{b)} \\
\caption{Campos de direcciones creados con la función 'plotdf': \emph{a)} campo de la ecuación $\frac{dy}{dx} = 1 + y + y^2$; \emph{b)} campo correspondiente al modelo predador-presa.}
\label{fig:plotdf}
\end{center}
\end{figure}


Cuando Maxima no es capaz de resolver la ecuación propuesta, se podrá recurrir al método numérico de Runge-Kutta, el cual se encuentra programado en el paquete \verb|diffeq|\index{diffeq}. Como primer ejemplo, nos planteamos la resolución de la ecuación 
\[
\frac{dy}{dt} = -2 y^2 + \exp(-3 t),
\]
con la condición $y(0)=1$. La función \verb|ode2| es incapaz de resolverla:

\begin{Verbatim}
(%i25) ec: 'diff(y,t)+2*y^2-exp(-3*t)=0;
\end{Verbatim}
\[
{{d}\over{d\,t}}\,y+2\,y^2-e^ {- 3\,t }=0\leqno{\tt (\%o25)}
\]
\begin{Verbatim}
(%i26) ode2(ec,y,t);
\end{Verbatim}
\[
\mathrm{false}\leqno{\tt (\%o26)}
\]

Abordamos ahora el problema con un enfoque numérico, para lo cual definimos la expresión 
\[
f(t,y) = \frac{dy}{dt} = -2 y^2 + \exp(-3 t)
\]
en Maxima,

\begin{Verbatim}
(%i27) load(diffeq)$
(%i28) f(t,y):= -2*y^2+exp(-3*t) $
(%i29) res: runge1(f,0,5,0.5,1);
\end{Verbatim}
\[
\begin{array}{l}
\left[ \left[ 0.0 , 0.5 , 1.0 , 1.5 , 2.0 , 2.5 , 3.0 , 3.5 , 4.0
  , 4.5 , 5.0 \right]  \right. , \\ \left[ 1.0 , .5988014211752297 , .4011473182183033
  , .2915932807721147 \right. ,\\  .2260784415237641 , 0.183860316087325 , .1547912058210609
  , .1336603954558797 ,\\ \left. .1176289334565761 , .1050518038293819 , .09491944625388439
  \right]  ,  \\  \left[ -1.0 , -0.49399612385452 , -.2720512734596094 , -.1589442862446483
  \right. ,\\  -.09974417126696171 , -.06705614729331426 , -.04779722499498942
  , -.03570266617749457 , \\ \left. \left. -.02766698775990988 , -.02207039201652747
  , -.01801909665196759 \right]  \right] \end{array} \leqno{\tt (\%o29)}
\]
\begin{Verbatim}
(%i30) draw2d(
         points_joined = true,
         point_type    = dot,
         points(res[1],res[2]),
         terminal      = eps)$
\end{Verbatim}

La función \verb|runge1|\index{runge1} necesita cinco argumentos: la función derivada $\frac{dy}{dt}$, los valores inicial, $t_0$, y final, $t_1$, de la variable independiente, la amplitud de los subintervalos y el valor que toma $y$ en $t_0$. El resultado es una lista que a su vez contiene tres listas: las abscisas $t$, las ordenadas $y$ y las correspondientes derivadas. Al final del ejemplo anterior, se solicita la representación gráfica de la solución, cuyo aspecto es el mostrado por la Figura~\ref{fig:diffeq} \emph{a)}. (Consúltese la sección \ref{graficos} para una descripción de la función \verb|draw2d|.)


\begin{figure}[t]
\begin{center}
\includegraphics[scale=0.5]{diffeq1.pdf}
\includegraphics[scale=0.5]{diffeq2.pdf} \\
\emph{a)} \hspace{6.5cm}  \emph{b)} \\
\includegraphics[scale=0.5]{diffeq3.pdf}
\includegraphics[scale=0.5]{diffeq4.pdf} \\
\emph{c)} \hspace{6.5cm}  \emph{d)} \\
\caption{Resolución numérica de ecuaciones diferenciales con 'diffeq': \emph{a)}, solución de la ecuación de primer orden $\frac{dy}{dt} = -2 y^2 + \exp(-3 t), y(0)=1$; \emph{b)}, solución de la ecuación de segundo orden $\frac{d^2y}{dt^2} = 0.2 (1-y^2) \frac{dy}{dt} - y$, con las condiciones $y(0)=0.1$ y $y'(0)=1$; \emph{c)}, diagrama $(y,y')$; \emph{d)}, diagrama $(y,y'')$.}
\label{fig:diffeq}
\end{center}
\end{figure}

Nos planteamos ahora la resolución de la ecuación diferencial de segundo orden
\[
\frac{d^2y}{dt^2} = 0.2 (1-y^2) \frac{dy}{dt} - y,
\]
con $y(0)=0.1$ y $y'(0)=1$ para lo cual definimos en Maxima la función
\[
g(t,y,y') = \frac{d^2y}{dt^2} = 0.2 (1-y^2) y' - y,
\]

\begin{Verbatim}
(%i31) g(t,y,yp) := 0.2*(1-y^2)*yp - y $
(%i32) res: runge2(g,0,100,0.1,0.1,1)$
(%i33) midibujo(i,j):= draw2d(points_joined = true,
                              point_type    = dot,
                              points(res[i],res[j]),
                              terminal      = eps)$
(%i34) midibujo(1,2)$
(%i35) midibujo(2,3)$
(%i36) midibujo(2,4)$
\end{Verbatim}

La función \verb|runge2|\index{runge2} necesita seis argumentos: la función derivada $\frac{d^2y}{dt^2}$, los valores inicial, $t_0$, y final, $t_1$, de la variable independiente, la amplitud de los subintervalos y los valores que toman $y$ y su primera derivada en $t_0$. El resultado es una lista que a su vez contiene cuatro listas: las abscisas $t$, las ordenadas $y$, las correspondientes primeras derivadas y, por último, las segundas derivadas. Al final de este último ejemplo se solicitan algunos gráficos asociados a la solución, los formados con los pares $(t,y)$, $(y,y')$ y $(y,y'')$, que son los correspondientes a los apartados \emph{b)}, \emph{c)} y \emph{d)} de la Figura~\ref{fig:diffeq}.

El paquete \verb|dynamics|\index{dynamics} dispone de otra rutina para el método de Runge-Kutta, \verb|rk|\index{rk}, que permite la resolución de sistemas de ecuaciones difereciales. Para resolver el sistema
\[
\left\{
   \begin{array}{ccc}
      \frac{dx}{dt} $ = $ 4-x^2-4 y^2 \\
      \frac{dy}{dt} $ = $ y^2-x^2+1
   \end{array}
\right.
\]
cargamos el paquete y ejecutamos la sentencia correspondiente, junto con el gráfico asociado que no mostramos.

\begin{Verbatim}
(%i37) load(dynamics)$
(%i38) rk([4-x^2-4*y^2,y^2-x^2+1],[x,y],[-1.25,0.75],[t,0,4,0.02])$
(%i39) draw3d(
         points_joined = true,
         point_type    = dot,
         points(%),
         terminal      = eps)$
\end{Verbatim}

Para más información sobre la sintaxis de esta función, ejecútese \verb|? rk|. El paquete \verb|dynamics| contiene otras funciones relacionadas con los sistemas dinámicos y los fractales.









\section{Vectores y campos vectoriales}
\label{vectores}

En Maxima, los vectores se introducen como simples listas (Sección~\ref{listas}), siendo el caso que con ellas se pueden realizar las operaciones de adición, producto por un número y producto escalar de vectores,

\index{14@+}\index{16@*}\index{22@.}\begin{Verbatim}
(%i1) [1,2,3]+[a,b,c];
\end{Verbatim}
\[
\left[ a+1 , b+2 , c+3 \right] \leqno{\tt (\%o1)}
\]
\begin{Verbatim}
(%i2) s*[a,b,c];
\end{Verbatim}
\[
\left[ a\,s , b\,s , c\,s \right] \leqno{\tt (\%o2)}
\]
\begin{Verbatim}
(%i3) [1,2,3].[a,b,c]; /* producto escalar */
\end{Verbatim}
\[
3\,c+2\,b+a\leqno{\tt (\%o3)}
\]

El cálculo del módulo de un vector se puede hacer mediante la definición previa de una función al efecto:

\begin{Verbatim}
(%i4) modulo(v):=
          if listp(v)
             then sqrt(apply("+",v^2))
             else error("Mucho ojito: ", v, " no es un vector !!!!")$
(%i5) xx:[a,b,c,d,e]$
(%i6) yy:[3,4,-6,0,4/5]$
(%i7) modulo(xx-yy);
\end{Verbatim}
\[
\sqrt{\left(e-{{4}\over{5}}\right)^2+d^2+\left(c+6\right)^2+\left(b
 -4\right)^2+\left(a-3\right)^2}\leqno{\tt (\%o7)}
\]

Los operadores diferenciales que son de uso común en el ámbito de los campos vectoriales están programados en el paquete \verb|vect|\index{vect}, lo que implica que debe ser cargado en memoria antes de ser utilizado. Sigue a continuación una sesión de ejemplo sobre cómo usarlo. 

Partamos de los campos escalares $\phi(x,y,z)=-x+y^2+z^2$ y $\psi(x,y,z)=4 x + \log(y^2+z^2)$ y demostremos que sus superficies de nivel son ortogonales probando que $\nabla \phi \cdot \nabla \psi = 0$, siendo $\nabla$ el operador gradiente,

\index{grad}\begin{Verbatim}
(%i8) /* Se carga el paquete */
      load(vect)$
(%i9) /* Se definen los campos escalares */
      phi: y^2+z^2-x$  psi:log(y^2+z^2)+4*x$
(%i11) grad(phi) . grad(psi);
\end{Verbatim}
\[
{\it grad}\left(z^2+y^2-x\right)\cdot {\it grad}\left(\log \left(z^2
 +y^2\right)+4\,x\right)\leqno{\tt (\%o11)}
\]

Como se ve, Maxima se limita a devolvernos la misma expresión que le introducimos; el estilo de trabajo del paquete \verb|vect| requiere el uso de dos funciones: \verb|express|\index{express} y \verb|ev|\index{ev}, la primera para obtener la expresión anterior en términos de derivadas y la segunda para forzar el uso de éstas.

\begin{Verbatim}
(%i12) express(%);
\end{Verbatim}
\[
\begin{array}{c}
{{d}\over{d\,z}}\,\left(z^2+y^2-x\right)\,\left({{d}\over{d\,z}}\,
 \left(\log \left(z^2+y^2\right)+4\,x\right)\right)+ \\ {{d}\over{d\,y}}
 \,\left(z^2+y^2-x\right)\,\left({{d}\over{d\,y}}\,\left(\log \left(z
 ^2+y^2\right)+4\,x\right)\right)+ \\ {{d}\over{d\,x}}\,\left(z^2+y^2-x
 \right)\,\left({{d}\over{d\,x}}\,\left(\log \left(z^2+y^2\right)+4\,
 x\right)\right)  \end{array}  \leqno{\tt (\%o12)}
\]
\begin{Verbatim}
(%i13) ev(%,diff);
\end{Verbatim}
\[
{{4\,z^2}\over{z^2+y^2}}+{{4\,y^2}\over{z^2+y^2}}-4\leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) ratsimp(%);
\end{Verbatim}
\[
0\leqno{\tt (\%o14)}
\]

Al final, hemos tenido que ayudar un poco a Maxima para que terminase de reducir la última expresión.

Sea ahora el campo vectorial definido por
$\mathbf{F}=x y \mathbf{i} + x^2 z \mathbf{j} - e^{x+y} \mathbf{k}$
y pidámosle a Maxima que calcule su divergencia, ($\nabla \cdot \mathbf{F}$), rotacional ($\nabla \times \mathbf{F}$)y laplaciano ($\nabla^2 \mathbf{F}$)

\index{div}\index{curl}\index{laplacian}\begin{Verbatim}
(%i15) F: [x*y,x^2*z,exp(x+y)]$
(%i16) div (F);  /* divergencia */
\end{Verbatim}
\[
{\it div}\left(\left[ x\,y , x^2\,z , e^{y+x} \right] \right)\leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) express (%);
\end{Verbatim}
\[
{{d}\over{d\,y}}\,\left(x^2\,z\right)+{{d}\over{d\,z}}\,e^{y+x}+{{d
 }\over{d\,x}}\,\left(x\,y\right)\leqno{\tt (\%o17)}
\]
\begin{Verbatim}
(%i18) ev (%, diff);
\end{Verbatim}
\[
y\leqno{\tt (\%o18)}
\]
\begin{Verbatim}
(%i19) curl (F);  /* rotacional */
\end{Verbatim}
\[
{\it curl}\left(\left[ x\,y , x^2\,z , e^{y+x} \right] \right)\leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) express (%);
\end{Verbatim}
\[
\left[ {{d}\over{d\,y}}\,e^{y+x}-{{d}\over{d\,z}}\,\left(x^2\,z
 \right) , {{d}\over{d\,z}}\,\left(x\,y\right)-{{d}\over{d\,x}}\,e^{y
 +x} , {{d}\over{d\,x}}\,\left(x^2\,z\right)-{{d}\over{d\,y}}\,\left(
 x\,y\right) \right] \leqno{\tt (\%o20)}
\]
\begin{Verbatim}
(%i21) ev (%, diff);
\end{Verbatim}
\[
\left[ e^{y+x}-x^2 , -e^{y+x} , 2\,x\,z-x \right] \leqno{\tt (\%o21)}
\]
\begin{Verbatim}
(%i22) laplacian (F);  /* laplaciano */
\end{Verbatim}
\[
{\it laplacian}\left(\left[ x\,y , x^2\,z , e^{y+x} \right] \right)\leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i23) express (%);
\end{Verbatim}
\[
{{d^2}\over{d\,z^2}}\,\left[ x\,y , x^2\,z , e^{y+x} \right] +{{d^2
 }\over{d\,y^2}}\,\left[ x\,y , x^2\,z , e^{y+x} \right] +{{d^2
 }\over{d\,x^2}}\,\left[ x\,y , x^2\,z , e^{y+x} \right] \leqno{\tt (\%o23)}
\]
\begin{Verbatim}
(%i24) ev (%, diff);
\end{Verbatim}
\[
\left[ 0 , 2\,z , 2\,e^{y+x} \right] \leqno{\tt (\%o24)}
\]

Nótese en todos los casos el usos de la secuencia \verb|express| - \verb|ev|. Si el usuario encuentra incómoda esta forma de operar, siempre podrá definir una función que automatice el proceso; por ejemplo,

\begin{Verbatim}
(%i25) milaplaciano(v):= ev(express(laplacian(v)), diff) $
(%i26) milaplaciano(F);
\end{Verbatim}
\[
\left[ 0 , 2\,z , 2\,e^{y+x} \right] \leqno{\tt (\%o26)}
\]

Por último, el paquete \verb|vect| incluye también la definición del producto vectorial, al cual le asigna el operador \verb|~|\index{34@\symbol{126}},

\begin{Verbatim}
(%i27) [a, b, c] ~ [x, y, z];
\end{Verbatim}
\[
\left[ a , b , c \right]  \sim \left[ x , y , z \right] \leqno{\tt (\%o27)}
\]
\begin{Verbatim}
(%i28) express(%);
\end{Verbatim}
\[
\left[ b\,z-c\,y , c\,x-a\,z , a\,y-b\,x \right] \leqno{\tt (\%o28)}
\]










\newpage
\chapter{Gráficos}
\label{graficos}


Maxima no está habilitado para realizar él mismo gráficos, por lo que necesitará de un programa externo que realice esta tarea. Nosotros nos limitaremos a ordenar qué tipo de gráfico queremos y Maxima se encargará de comunicárselo a la aplicación gráfica que esté activa en ese momento, que por defecto será Gnuplot. La otra herramienta gráfica es Openmath, un programa Tcl-tk que se distribuye conjuntamente con Maxima.



\section{El módulo ''plot''}

Las funciones \verb|plot2d|\index{plot2d} y \verb|plot3d|\index{plot3d} son las que se utilizan por defecto. Veamos un ejemplo de cada una de ellas.

\begin{Verbatim}
(%i1) xy:[[10,.6], [20,.9], [30,1.1], [40,1.3], [50,1.4]]$
(%i2) plot2d([[discrete,xy], 2*%pi*sqrt(u/980)], [u,0,50],
               [style, [points,5,2,6], [lines,1,1]],
               [legend,"Datos experimentais","Predicion da teoria"],
               [xlabel,"Lonxitude do pendulo (cm)"], [ylabel,"periodo (s)"],
               [gnuplot_preamble,
                 "set terminal postscript eps;set out 'plot2d.eps'"])$
\end{Verbatim}

Se ha definido en el ejemplo una lista de puntos empíricos a representar, junto con su función teórica, pidiendo su representación gráfica en el dominio $[0,50]$. El resto de código hace referencia a diversas opciones: \verb|style|, \verb|legend|, \verb|xlabel|, \verb|ylabel| y \verb|gnuplot_preamble|, esta última permite escribir código de Gnuplot para que éste lo ejecute; aquí se le pide que devuelva el gráfico en formato Postscript. El ejemplo siguiente genera una superficie explícita. Las dos salidas gráficas se representan en la Figura~\ref{fig:plot} 

\begin{Verbatim}
(%i3) plot3d (2^(-u^2 + v^2), [u, -3, 3], [v, -2, 2],
        [gnuplot_preamble,
           "set terminal postscript eps;set out 'plot3d.eps'"])$
\end{Verbatim}

\begin{figure}
\begin{center}
\includegraphics[scale=0.55]{plot2d.pdf} 
\includegraphics[scale=0.55]{plot3d.pdf} \\
\caption{Gráficos generados por las funciones plot2d y plot3d.}
\label{fig:plot}
\end{center}
\end{figure}

El control de las opciones gráficas se consigue manipulando la variable global \verb|plot_options|\index{plot\_options}, cuyo estado por defecto es
\begin{verbatim}
(%i4) plot_options;
(%o4) [[x, - 1.755559702014e+305, 1.755559702014e+305], 
[y, - 1.755559702014e+305, 1.755559702014e+305], 
[t, - 3, 3], [GRID, 30, 30], [VIEW_DIRECTION, 1, 1, 1], 
[COLOUR_Z, FALSE], [TRANSFORM_XY, FALSE], 
[RUN_VIEWER, TRUE], [PLOT_FORMAT, GNUPLOT], 
[GNUPLOT_TERM, DEFAULT], [GNUPLOT_OUT_FILE, FALSE], 
[NTICKS, 10], [ADAPT_DEPTH, 10], [GNUPLOT_PM3D, FALSE], 
[GNUPLOT_PREAMBLE, ], [GNUPLOT_CURVE_TITLES, [DEFAULT]], 
[GNUPLOT_CURVE_STYLES, [with lines 3, with lines 1, 
with lines 2, with lines 5, with lines 4, with lines 6, 
with lines 7]], [GNUPLOT_DEFAULT_TERM_COMMAND, ], 
[GNUPLOT_DUMB_TERM_COMMAND, set term dumb 79 22], 
[GNUPLOT_PS_TERM_COMMAND, set size 1.5, 1.5;set term postsc#
ript eps enhanced color solid 24]]
\end{verbatim}

Para mayor información sobre el significado de cada uno de los elementos de esta lista, así como de las funciones \verb|plot2d| y \verb|plot3d|, consúltese la documentación. 

Por defecto, Maxima invocará al programa Gnuplot para la generación de gráficos, pero quizás prefiramos el programa Openmath, que forma parte de la distribución de Maxima; en tal caso tendríamos que modificar previamente las opciones guardadas en \verb|plot_options| y a continuación solicitar el gráfico deseado, como en este caso en el que se representa la función gamma y su inversa.

\index{set\_plot\_option}\begin{verbatim}
(%i5) set_plot_option([plot_format, openmath])$
(%i6) plot2d([gamma(x),1/gamma(x)],[x,-4.5,5],[y,-10,10])$
\end{verbatim}

El resto de esta sección lo dedicaremos a hacer una somera descripción del paquete \verb|draw|, un proyecto consistente en el desarrollo de un interfaz que permita aprovechar al máximo las habilidades gráficas de Gnuplot.





\section{El módulo ''draw''}

Aquí, las funciones a utilizar son \verb|draw2d|\index{draw2d}, \verb|draw3d|\index{draw3d} y \verb|draw|\index{draw}, para escenas en 2d, 3d y para gráficos múltiples y animaciones, respectivamente. Puesto que se trata de un módulo adicional, será necesario cargarlo en memoria antes de hacer uso de él. Empecemos por un ejemplo comentado.

\begin{Verbatim}
(%i1) load(draw)$
(%i2) draw2d(
         key           = "Cubic poly",
         explicit(%pi*x^3+sqrt(2)*x^2+10,x,0,2),
         color         = blue,
         key           = "Parametric curve",
         line_width    = 3,
         nticks        = 50,
         parametric(2*cos(rrr)+3, rrr, rrr, 0, 6*%pi),
         line_type     = dots,
         points_joined = true,
         point_type    = diamant,
         point_size    = 3,
         color         = red,
         line_width    = 1,
         key           = "Empiric data",
         points(makelist(random(40.0),k,1,5)),
         title         = "DRAWING CURVES",
         terminal      = eps )$
\end{Verbatim}

Los argumentos de \verb|draw2d| se dividen en tres grupos: \emph{objetos gráficos} (en el ejemplo, \verb|explicit|\index{explicit}, \verb|parametric|\index{parametric} y \verb|points|\index{points}), \emph{opciones locales} (que afectan directamente a la representación de los objetos gráficos, como \verb|key|\index{key}, \verb|color|\index{color}, \verb|line_width|\index{line\_width}, \verb|nticks|\index{nticks}, \verb|line_type|\index{line\_type}, \verb|points_joined|\index{points\_joined} y \verb|line_width|\index{line\_width}) y \emph{opciones globales} (que hacen referencia a aspectos generales del gráfico, como \verb|title|\index{title} y \verb|terminal|\index{terminal}). Las opciones se indican como igualdades, escribiendo a la izquierda el nombre de la opción y a la derecha el valor que se le quiera asignar, a la vez que los objetos gráficos tienen el formato igual que las llamadas a funciones, esto es, el nombre del objeto a dibujar seguido, entre paréntesis, de los parámetros que definen al objeto.

Todos estos argumentos se interpretan secuencialmente, de forma que al asignar un cierto valor a una opción local, ésta afectará a todos los objetos gráficos que le sigan. En este ejemplo, \verb|line_width| comienza teniendo valor 1, que es el asignado por defecto, luego se le da el valor 3 para la representación de la curva paramétrica y finalmente se le devuelve el valor original antes de representar los segmentos que unen los puntos aleatoriamente generados. En cambio, las dos opciones globales, \verb|title| y \verb|terminal|, aunque se colocaron al final, podrían haberse ubicado en cualquier otro lugar. 

Siguiendo con los gráficos en dos dimensiones, el siguiente ejemplo muestra una escena en la que intervienen los objetos \verb|ellipse|\index{ellipse}, \verb|image|\index{image}, \verb|label|\index{label}, \verb|vector|\index{vector} y, ya lo conocemos, \verb|explicit|. Antes de ejecutar esta instrucción es necesario leer el fichero gráfico \verb|gatos.xpm|\footnote{El formato gráfico XPM es el único que puede leer Maxima.}

\begin{Verbatim}
(%i3) cats: read_xpm("gatos.xpm")$
(%i4) draw2d(
         terminal    = eps,
         yrange      = [-4,10],
         ellipse(5,3,8,6,0,360),
         image(cats,0,0,10,7),
         line_width  = 2,
         head_length = 0.3,
         color       = blue,
         label(["This is Francisco",-1,-0.5]),
         vector([-1,0],[2,4]),
         color       = green,
         vector([11,7],[-2,-1]),
         label(["This is Manolita",11,8]),
         explicit(sin(x)-2,x,-4,15) )$
\end{Verbatim}

Junto con los objetos gráficos introducidos en los ejemplos, cuyos resultados se pueden ver en los apartados \emph{a)} y \emph{b)} de la Figura~\ref{fig:draw}, también existen \verb|polygon|\index{polygon}, \verb|rectangle|\index{rectangle}, \verb|polar|\index{polar}, \verb|implicit|\index{implicit} y \verb|geomap|\index{geomap}, este último para mapas cartográficos.

Mostramos a continuación algunas escenas tridimensionales. En primer lugar, el valor absoluto de la función $\Gamma$ de Euler, junto con sus líneas de contorno.

\begin{Verbatim}
(%i5) gamma2(x,y):=
        block([re,im,g:gamma(x+%i*y)],
          re:realpart(g),
          im:imagpart(g),
          sqrt(re^2+im^2))$
(%i6) draw3d(
        zrange         = [0,6],
        xu_grid        = 50,
        yv_grid        = 50,
        surface_hide   = true,
        contour        = surface,
        contour_levels = [0,0.5,6], /* de 0 a 6 en saltos de 0.5 */
        color          = cyan,
        terminal       = eps,
        explicit(gamma2(x,y),x,-4,4,y,-2,2))$
\end{Verbatim}

Una superficie paramétrica, que junto con la anterior escena, se pueden ver ambas en la Figura~\ref{fig:draw}, apartados \emph{c)} y \emph{d)}.

\begin{Verbatim}
(%i7) draw3d(
        terminal       = eps,
        title          = "Figure 8 - Klein bottle",
        rot_horizontal = 360,
        xrange         = [-3.4,3.4],
        yrange         = [-3.4,3.4],
        zrange         = [-1.4,1.4],
        xtics          = none,
        ytics          = none,
        ztics          = none,
        axis_3d        = false,
        surface_hide   = true,
        parametric_surface((2+cos(u/2)*sin(v)-sin(u/2)*sin(2*v))*cos(u),
                           (2+cos(u/2)*sin(v)-sin(u/2)*sin(2*v))*sin(u),
                           sin(u/2)*sin(v) + cos(u/2)*sin(2*v),
                           u, -%pi, 360*%pi/180-%pi, v, 0, 2*%pi) )$
\end{Verbatim}

En el gráfico siguiente se combinan varios objetos: una superficie explícita, dos curvas paramétricas y dos etiquetas, cuyo aspecto es el mostrado en el apartado \emph{e)} de la Figura~\ref{fig:draw}.

\begin{Verbatim}
(%i8) draw3d(
        color          = green,
        explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
        color          = blue,
        parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2),
        color          = brown,
        line_width     = 2,
        parametric(t^2,sin(t),2+t,t,0,2),
        surface_hide   = true,
        title          = "Surface & curves",
        color          = red,
        label(["UP",-2,0,3]),
        label(["DOWN",2,0,-3]),
        rot_horizontal = 10,
        rot_vertical   = 84,
        terminal       = eps )$
\end{Verbatim}

En el siguiente ejemplo hacemos una proyección esférica del hemisferio sur, que se ve en el apartado \emph{f)} de la Figura~\ref{fig:draw}. El paquete  \verb|worldmap|\index{worldmap} carga en memoria las coordenadas latitud--longitud de las líneas fronterizas y costeras de todos los países del mundo, así como algunas funciones necesarias para su manipulación y procesamiento,

\begin{Verbatim}
(%i9) load(worldmap)$
(%i10) draw3d(
        surface_hide   = true,
        rot_horizontal = 60,
        rot_vertical   = 131,
        color          = cyan,
        parametric_surface(
               cos(phi)*cos(theta),
               cos(phi)*sin(theta),
               sin(phi),
               theta,-%pi,%pi,
               phi,-%pi/2,%pi/2),
        color          = red,
        geomap([South_America,Africa,Australia],
               [spherical_projection,0,0,0,1]),
        color          = blue,
        geomap([South_America,Africa,Australia],
               [cylindrical_projection,0,0,0,1,2]),
        terminal       = eps)$
\end{Verbatim}



\begin{figure}
\begin{center}
\includegraphics[scale=0.5]{draw1.pdf} 
\includegraphics[scale=0.5]{draw2.pdf} \\
\emph{a)} \hspace{6.5cm}  \emph{b)} \\
\includegraphics[scale=0.5]{draw3.pdf} 
\includegraphics[scale=0.5]{draw4.pdf} \\
\emph{c)} \hspace{6.5cm}  \emph{d)} \\
\includegraphics[scale=0.5]{draw5.pdf} 
\includegraphics[scale=0.5]{draw6.pdf} \\
\emph{e)} \hspace{6.5cm}  \emph{f)} \\
\includegraphics[scale=0.5]{draw7.pdf} \\
\emph{g)} \\
\caption{Gráficos generados con el paquete draw: \emph{a)} y \emph{b)} con draw2d; \emph{c)}, \emph{d)}, \emph{e)} y \emph{f)} con draw3d; \emph{g)}, un gráfico múltiple.}
\label{fig:draw}
\end{center}
\end{figure}

Además de los objetos gráficos tridimensionales ya vistos, también se hayan definidos \verb|points|, \verb|vector| e \verb|implicit|.

También es posible generar múltiples gráficos en un mismo fichero o hacer animaciones en formato GIF o en la ventana gráfica. Para ver más ejemplos de gráficos generados con el paquete \verb|draw|, se recomienda acceder a la dirección
\begin{center}
http://riotorto.users.sourceforge.net/gnuplot
\end{center}
o consultar el sistema de ayuda de Maxima.

Ya como colofón, un ejemplo de gráfico múltiple en el que se muestra también cómo dar sombreado a las superficies tridimensionales. El resultado en el apartado \emph{g)} de la Figura~\ref{fig:draw}.

\begin{Verbatim}
(%i11) escena1:
         gr3d(surface_hide = true,
              enhanced3d   = true,
              palette      = gray,
              explicit(sin(sqrt(x^2+y^2)),x,-5,5,y,-5,5))$
\end{Verbatim}

\begin{Verbatim}
(%i12) escena2:
         gr3d(surface_hide  = true,
              enhanced3d    = true,
              palette       = gray,
              user_preamble = "set pm3d map",
              explicit(sin(sqrt(x^2+y^2)),x,-5,5,y,-5,5))$
\end{Verbatim}

\begin{Verbatim}
(%i13) draw(
        columns    = 2,
        terminal   = eps_color,
        eps_width  = 20,
        eps_height = 8,
        escena1, escena2)$
\end{Verbatim}

Se comienza definiendo las dos escenas a representar, la función explícita y el gráfico de densidades, en sendos objetos \verb|gr3d|, ya que ambos son de naturaleza tridimensional. Estos objetos se pasan luego a la función \verb|draw| como argumentos, junto con algunas opciones globales. La función \verb|draw| es realmente la que ha generado también los gráficos anteriores, siendo \verb|draw2d| y \verb|draw3d| sinónimos de \verb|draw(gr2d(...))| y \verb|draw(gr3d(...))|, respectivamente.









\newpage
\chapter{Probabilidades y estadística}
\label{sec:estad}

\section{Probabilidad}
\label{probinf}

El paquete \emph{distrib}\index{distrib} contiene la definición de las funciones de distribución de probabilidad más comunes, tanto discretas (binomial, de Poisson, de Bernoulli, geométrica, uniforme discreta, hipergeométrica y binomial negativa), como continuas (normal, $t$ de Student, $\chi^2$ de Pearson, $F$ de Snedecor, exponencial, lognormal, gamma, beta, uniforme continua, logística, de Pareto, de Weibull, de Rayleigh, de Laplace, de Cauchy y de Gumbel). Para cada una de ellas se puede calcular la probabilidad acumulada, la función de densidad, los cuantiles, medias, varianzas y los coeficientes de asimetría y curtosis:

\begin{Verbatim}
(%i1) load(distrib)$
\end{Verbatim}

\index{assume}\begin{Verbatim}
(%i2) assume(s>0)$
\end{Verbatim}

\index{cdf\_normal}\begin{Verbatim}
(%i3) cdf_normal(x,mu,s);
\end{Verbatim}
\[
{{\mathrm{erf}\left({{x-\mu}\over{\sqrt{2}\,s}}\right)}\over{2}}+{{1
 }\over{2}}\leqno{\tt (\%o3)}
\]

\index{pdf\_poisson}\begin{Verbatim}
(%i4) pdf_poisson(5,1/s);
\end{Verbatim}
\[
{{e^ {- {{1}\over{s}} }}\over{120\,s^5}}\leqno{\tt (\%o4)}
\]

\index{quantile\_student\_t}\begin{Verbatim}
(%i5) quantile_student_t(0.05,25);
\end{Verbatim}
\[
-1.708140543186975\leqno{\tt (\%o5)}
\]

\index{mean\_weibull}\begin{Verbatim}
(%i6) mean_weibull(3,67);
\end{Verbatim}
\[
{{67\,\Gamma\left({{1}\over{3}}\right)}\over{3}}\leqno{\tt (\%o6)}
\]

\index{var\_binomial}\begin{Verbatim}
(%i7) var_binomial(34,1/8);
\end{Verbatim}
\[
{{119}\over{32}}\leqno{\tt (\%o7)}
\]

\index{skewness\_rayleigh}\begin{Verbatim}
(%i8) skewness_rayleigh(1/5);
\end{Verbatim}
\[
{{{{\pi^{{{3}\over{2}}}}\over{4}}-{{3\,\sqrt{\pi}}\over{4}}}\over{
 \left(1-{{\pi}\over{4}}\right)^{{{3}\over{2}}}}}\leqno{\tt (\%o8)}
\]

\index{kurtosis\_gumbel}\begin{Verbatim}
(%i9) kurtosis_gumbel (2,3);
\end{Verbatim}
\[
{{12}\over{5}}\leqno{\tt (\%o9)}
\]

Si su argumento es un número entero positivo, la función \verb|random(n)|\index{random} genera un número seudoaleatorio con distribución uniforme discreta entre $0$ y $n-1$, ambos inclusive; así, una simulación del lanzamiento de un dado sería
\begin{Verbatim}
(%i10) random(6)+1;
\end{Verbatim}
\[
3\leqno{\tt (\%o10)}
\]
y una serie de 100 lanzamientos de una moneda,
\index{makelist}\begin{Verbatim}
(%i11) makelist(random(2),i,1,100);
\end{Verbatim}
\[
\begin{array}{c}
\left[ 0 , 0 , 1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 1 , 0 , 0 , 1 , 0 , 1 
  , 0 , 1 , 0 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 1 , 1 , 0 , \right. \\ \left.
   0 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 0 
  , 1 , 0 , 0 , 0 , 0 , 0 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , \right. \\ \left.
   1 , 1 , 1 , 0 , 1 , 1 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 
  , 1 , 0 , 1 , 0 , 1 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 0 , 0 , 1 
  \right]   \end{array}  \leqno{\tt (\%o11)}
\]

Cuando el argumento es un número decimal positivo, la variable aleatoria que se simula es la uniforme continua, dando como resultado un número real perteneciente al intervalo $[0,r)$,
\begin{Verbatim}
(%i12) random(6.0);
\end{Verbatim}
\[
0.373047098775396\leqno{\tt (\%o12)}
\]

El algoritmo generador de los números seudoaleatorios es determinista, de manera que partiendo de una misma semilla o valor inicial, se generará la misma secuencia de números. Para controlar el valor de esta semilla disponemos de las funciones \verb|make_random_state|\index{make\_random\_state} y \verb|set_random_state|\index{set\_random\_state}; por ejemplo, para definir una semilla que se genere a partir del estado actual del reloj del sistema haremos
\begin{Verbatim}
(%i13) nueva_semilla: make_random_state(true)$
\end{Verbatim}

Sin embargo, para que tal semilla se active en el generador, debemos indicarlos expresamente haciendo
\begin{Verbatim}
(%i14) set_random_state(nueva_semilla)$
\end{Verbatim}

El argumento de la función \verb|make_random_state| puede ser también un número entero, como se hace en el ejemplo de más abajo.

Veamos un caso de aplicación de todo esto. Supongamos que queremos simular diferentes series estocásticas, pero que todas ellas sean iguales. Si hacemos
\begin{Verbatim}
(%i15) makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 3 , 0 , 0 , 5 , 0 , 5 , 1 , 4 , 4 , 5 \right] \leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 0 , 4 , 0 , 0 , 5 , 4 , 0 , 0 , 1 , 5 \right] \leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 3 , 3 , 3 , 1 , 3 , 2 , 1 , 5 , 2 , 4 \right] \leqno{\tt (\%o17)}
\]
lo más probable es que obtengamos tres secuencias distintas, como en el ejemplo. Pero si hacemos
\begin{Verbatim}
(%i18) semilla: make_random_state(123456789)$
(%i19) set_random_state(semilla)$ makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 4 , 4 , 0 , 1 , 0 , 3 , 2 , 5 , 4 , 4 \right] \leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) set_random_state(semilla)$ makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 4 , 4 , 0 , 1 , 0 , 3 , 2 , 5 , 4 , 4 \right] \leqno{\tt (\%o20)}
\]
\begin{Verbatim}
(%i21) set_random_state(semilla)$ makelist(random(6),i,1,10);
\end{Verbatim}
\[
\left[ 4 , 4 , 0 , 1 , 0 , 3 , 2 , 5 , 4 , 4 \right] \leqno{\tt (\%o21)}
\]
se verá que las tres secuencias son iguales, ya que antes de generar cada muestra aleatoria reiniciamos el estado del generador. La función \verb|random| y las otras funciones relacionadas con ella discutidas hasta aquí están disponibles sin necesidad de cargar el paquete \verb|distrib|.

Sin embargo, el paquete adicional \verb|distrib|\index{distrib} también permite simular muchas otras variables aleatorias, tanto discretas como continuas. A modo de ejemplo, pedimos sendas muestra de tamaño 5 de las variables aleatorias binomial $B(5,\frac{1}{3})$, Poisson $P(7)$, hipergeométrica $HP(15,20,7)$, exponencial $Exp(12.5)$ y Weibull $Wei(7,\frac{23}{3})$; puesto que ya se ha cargado más arriba el paquete, no es necesario ejecutar nuevamente \verb|load(distrib)|.

\index{random\_binomial}\index{random\_poisson}\index{random\_hypergeometric}\index{random\_exp}\index{random\_weibull}
\begin{Verbatim}
(%i22) random_binomial(5,1/3,5);
\end{Verbatim}
\[
\left[ 3 , 1 , 2 , 3 , 2 \right] \leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i23) random_poisson(7,5);
\end{Verbatim}
\[
\left[ 8 , 3 , 10 , 5 , 6 \right] \leqno{\tt (\%o23)}
\]
\begin{Verbatim}
(%i24) random_hypergeometric(15,20,7,5);
\end{Verbatim}
\[
\left[ 4 , 2 , 4 , 3 , 2 \right] \leqno{\tt (\%o24)}
\]
\begin{Verbatim}
(%i25) random_exp(12.5,5);
\end{Verbatim}
\[
\begin{array}{c}
\left[ .05865376074017901 , .2604319923173137 , .07552948674579418 ,\right. \\ \left.
  .02948508382731128 , .2117111885482312 \right]   \end{array} \leqno{\tt (\%o25)}
\]
\begin{Verbatim}
(%i26) random_weibull(7,23/3,5);
\end{Verbatim}
\[
\begin{array}{c}
\left[ 6.35737206358163 , 7.436207845095266 , 8.101343432607079 , \right. \\ \left.
  7.835164678709573 , 6.350884234996046 \right]   \end{array} \leqno{\tt (\%o26)}
\]

Para más información sobre estas y otras funciones de simulación estocástica, tecléese \verb|? distrib|.





\section{Estadística descriptiva}

Maxima es capaz de realizar ciertos tipos de procesamiento de datos. El paquete \verb|descriptive|\index{descriptive}, junto con otros, es el que nos puede ayudar en este tipo de tareas.

Durante la instalación de Maxima se almacenan junto al fichero \verb|descriptive.mac| tres muestras de datos: \verb|pidigits.data|, \verb|wind.data| y \verb|biomed.data|, los cuales cargaremos en memoria con las funciones \verb|read_list|\index{read\_list} y \verb|read_matrix|\index{read\_matrix}.

Las muestras univariantes deben guardarse en listas, tal como se muestra a continuación
\begin{Verbatim}
(%i1) s1:[3,1,4,1,5,9,2,6,5,3,5];
\end{Verbatim}
\[
\left[ 3 , 1 , 4 , 1 , 5 , 9 , 2 , 6 , 5 , 3 , 5 \right] \leqno{\tt (\%o1)}
\]
y muestras multivariantes en matrices, como en
\begin{Verbatim}
(%i2) s2:matrix([13.17, 9.29],[14.71, 16.88],[18.50, 16.88],
                [10.58,  6.63],[13.33, 13.25],[13.21, 8.12]);
\end{Verbatim}
\[
\begin{pmatrix}13.17&9.29\cr 14.71&16.88\cr 18.5&16.88\cr 10.58&6.63\cr 13.33
 &13.25\cr 13.21&8.12\cr \end{pmatrix} \leqno{\tt (\%o2)}
\]

En este caso, el número de columnas es igual a la dimensión de la variable aleatoria y el número de filas al tamaño muestral.

Los datos se pueden introducir manualmente, pero las muestras grandes se suelen guardar en ficheros de texto. Por ejemplo, el fichero \verb|pidigits.data| contiene los 100 primeros dígitos del n'umero $\pi$:
\begin{Verbatim}
      3
      1
      4
      1
      5
      9
      2
      6
      5
      3 ...
\end{Verbatim}

Para cargar estos dígitos en Maxima,
\index{file\_search}\begin{Verbatim}
(%i3) s1 : read_list (file_search ("pidigits.data"))$
(%i4) length(s1);
\end{Verbatim}
\[
100\leqno{\tt (\%o4)}
\]

El fichero \verb|wind.data| contiene las velocidades medias del viento registradas diariamente en 5 estaciones meteorológicas de Irlanda. Lo que sigue carga los datos,
\begin{Verbatim}
(%i5) s2:read_matrix(file_search ("wind.data"))$
(%i6) length(s2);
\end{Verbatim}
\[
100\leqno{\tt (\%o6)}
\]
\begin{Verbatim}
(%i7) s2[%]; /* último registro */
\end{Verbatim}
\[
\left[ 3.58 , 6.0 , 4.58 , 7.62 , 11.25 \right] \leqno{\tt (\%o7)}
\]

Algunas muestras incluyen datos no numéricos. Como ejemplo, el fichero \verb|biomed.data| contiene cuatro medidas sanguíneas tomadas en dos grupos de pacientes, \verb|A| y \verb|B|, de edades diferentes,
\begin{Verbatim}
(%i8) s3:read_matrix(file_search ("biomed.data"))$
(%i9) length(s3);
\end{Verbatim}
\[
100\leqno{\tt (\%o9)}
\]
\begin{Verbatim}
(%i10) s3[1]; /* primer registro */
\end{Verbatim}
\[
\left[ A , 30 , 167.0 , 89.0 , 25.6 , 364 \right] \leqno{\tt (\%o10)}
\]

El primer individuo pertenece al grupo \verb|A|, tiene 30 años de edad y sus cuatro medidas sanguíneas fueron 167.0, 89.0, 25.6 y 364.

El paquete \verb|descriptive| incluye dos funciones que permiten hacer recuentos de datos: \verb|continuous_freq|\index{continuous\_freq} y 
\verb|discrete_freq|\index{discrete\_freq}; la primera de ellas agrupa en intervalos los valores de una lista de datos y hace el recuento de cuántos hay dentro de cada una de las clases,
\begin{Verbatim}
(%i11) load("descriptive")$
(%i12) continuous_freq(s1,5);
\end{Verbatim}
\[
\left[ \left[ 0 , 1.8 , 3.6 , 5.4 , 7.2 , 9.0 \right]  , \left[ 16
  , 24 , 18 , 17 , 25 \right]  \right] \leqno{\tt (\%o12)}
\]

La primera lista contiene los límites de los intervalos de clase y la segunda los recuentos correspondientes: hay 16 dígitos dentro del intervalo $[0, 1.8]$, eso es ceros y unos, 24 dígitos en $(1.8, 3.6]$, es decir, doses y treses, etc. El segundo parámetro indica el número de clases deseadas, que por defecto es 10.

La función \verb|discrete_freq| hace el recuento de las frecuencias absolutas en muestras discretas, tanto numéricas como categóricas. Su único argumento es una lista,
\begin{Verbatim}
(%i13) discrete_freq(s1);
\end{Verbatim}
\[
\left[ \left[ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 \right]  , 
 \left[ 8 , 8 , 12 , 12 , 10 , 8 , 9 , 8 , 12 , 13 \right]  \right] \leqno{\tt (\%o13)}
\]
\begin{Verbatim}
(%i14) discrete_freq(transpose(col(s3,1))[1]);
\end{Verbatim}
\[
\left[ \left[ A , B \right]  , \left[ 35 , 65 \right]  \right] \leqno{\tt (\%o14)}
\]

La primera lista contiene los valores muestrales y la segunda sus frecuencias absolutas. Las instrucciones \verb|? col| y \verb|? transpose| ayudarán a comprender la última entrada.

En cuanto al cálculo de parámetros muestrales, el paquete \verb|descriptive| incluye, tanto para muestras univariantes como multivariantes, medias (\verb|mean|\index{mean}), varianzas (\verb|var|\index{var}), desviaciones típicas (\verb|std|\index{std}), momentos centrales (\verb|central_moment|\index{central\_moment}) y no centrales (\verb|noncentral_moment|\index{noncentral\_moment}), coeficientes de variación (\verb|cv|\index{cv}), rangos (\verb|range|\index{range}), medianas (\verb|median|\index{median}), cuantiles (\verb|quantile|\index{quantile}), coeficientes de curtosis (\verb|kurtosis|\index{kurtosis}) y de asimetría (\verb|skewness|\index{skewness}), y otros. En los siguientes ejemplos, \verb|s1| es una muestra univariante y \verb|s2| multivariante:

\begin{Verbatim}
(%i15) mean(s1);
\end{Verbatim}
\[
{{471}\over{100}}\leqno{\tt (\%o15)}
\]
\begin{Verbatim}
(%i16) float(%);
\end{Verbatim}
\[
4.71\leqno{\tt (\%o16)}
\]
\begin{Verbatim}
(%i17) mean(s2);  /* vector de medias */
\end{Verbatim}
\[
\left[ 9.9485 , 10.1607 , 10.8685 , 15.7166 , 14.8441 \right] \leqno{\tt (\%o17)}
\]

Cuando la muestra contiene datos en formato decimal, los resultados serán también en este formato, pero si la muestra contiene tan solo datos enteros, los resultados serán devueltos en formato racional. En caso de querer forzar que los resultados sean devueltos siempre en formato decimal, podemos jugar con la variable global \verb|numer|\index{numer}.

\begin{Verbatim}
(%i18) numer: true$
(%i19) var(s1);
\end{Verbatim}
\[
8.425899999999999\leqno{\tt (\%o19)}
\]
\begin{Verbatim}
(%i20) var(s2);  /* vector de varianzas */
\end{Verbatim}
\[
\left[ 17.22190675000001 , 14.98773651 , 15.47572875 , 32.17651044000001
  , 24.42307619000001 \right] \leqno{\tt (\%o20)}
\]
\begin{Verbatim}
(%i21) /* 1er y 3er cuartiles */
       [quantile(s1,1/4),quantile(s1,3/4)];
\end{Verbatim}
\[
\left[ 2.0 , 7.25 \right] \leqno{\tt (\%o21)}
\]
\begin{Verbatim}
(%i22) range(s1);
\end{Verbatim}
\[
9\leqno{\tt (\%o22)}
\]
\begin{Verbatim}
(%i25) range(s2);  /* vector de rangos */
\end{Verbatim}
\[
\left[ 19.67 , 20.96 , 17.37 , 24.38 , 22.46 \right] \leqno{\tt (\%o25)}
\]
\begin{Verbatim}
(%i26) kurtosis(s1);
\end{Verbatim}
\[
-1.273247946514421\leqno{\tt (\%o26)}
\]
\begin{Verbatim}
(%i27) kurtosis(s2); /* vector de coef. curtosis */
\end{Verbatim}
\[
\begin{array}{c}
\left[ -.2715445622195385 , 0.119998784429451 , -.4275233490482866 , \right. \\ \left.
  -.6405361979019522 , -.4952382132352935 \right] \end{array} \leqno{\tt (\%o27)}
\]

Un aspecto crucial en el análisis estadístico multivariante es la dependencia estocástica entre variables, para lo cual Maxima permite el cálculo de matrices de covarianzas (\verb|cov|\index{cov}) y correlaciones (\verb|cor|\index{cor}), así como de otras medidas de variabilidad global. La variable global \verb|fpprintprec|\index{fpprintprec} es utilizada para limitar el número de decimales a imprimir; lo cual no afecta a la precisión de los cálculos.

\begin{Verbatim}
(%i28) fpprintprec:7$ /* número de dígitos deseados en la salida */
(%i29) cov(s2); /* matriz de covarianzas */
\end{Verbatim}
\[
\begin{pmatrix}17.22191&13.61811&14.37217&19.39624&15.42162\cr 13.61811&14.98774
 &13.30448&15.15834&14.9711\cr 14.37217&13.30448&15.47573&17.32544&16.18171
 \cr 19.39624&15.15834&17.32544&32.17651&20.44685\cr 15.42162&14.9711
 &16.18171&20.44685&24.42308\cr \end{pmatrix} \leqno{\tt (\%o29)}
\]
\begin{Verbatim}
(%i30) cor(s2); /* matriz de correlaciones */
\end{Verbatim}
\[
\begin{pmatrix}1.0&.8476339&.8803515&.8239624&.7519506\cr .8476339&1.0&.8735834
 &.6902622&0.782502\cr .8803515&.8735834&1.0&.7764065&.8323358\cr .8239624
 &.6902622&.7764065&1.0&.7293848\cr .7519506&0.782502&.8323358&.7293848
 &1.0\cr \end{pmatrix} \leqno{\tt (\%o30)}
\]

Las funciones \verb|global_variances|\index{global\_variances} y \verb|list_correlations|\index{list\_correlations} calculan, respectivamente, ciertas medidas globales de variación y correlación; para más información, pídase ayuda a Maxima con el comando \verb|describe| o con \verb|?|.

Hay varios tipos de diagramas estadísticos programados en el paquete \verb|descriptive|: \verb|scatterplot|\index{scatterplot} para gráficos de dispersión, \verb|histogram|\index{histogram}, \verb|barsplot|\index{barsplot}, \verb|piechart|\index{piechart} y \verb|boxplot|\index{boxplot} para el análisis homocedástico. A continuación se presentan un par de ejemplos cuyos salidas se presentan en la Figura~\ref{fig:multivar}.

\begin{Verbatim}
(%i31) /* Comparando variabilidades */
       boxplot(
          s2,
          terminal = eps,
          title    = "Velocidades del viento")$
\end{Verbatim}

\begin{Verbatim}
(%i32) /* Diagramas de dispersión para las
          tres últimas estaciones meteorológicas */
       scatterplot(
          submatrix(s2,1,2),
          point_type = circle,
          terminal   = eps)$
\end{Verbatim}

\begin{figure}
\begin{center}
\includegraphics[scale=1.0]{viento1.pdf} \\
\includegraphics[scale=1.0]{viento2.pdf}
\caption{Gráficos para muestras multivariantes: \emph{a)} diagramas de cajas; \emph{b)} diagramas de dispersión para tres variables.}
\label{fig:multivar}
\end{center}
\end{figure}


\section{Estadística inferencial}

El paquete \verb|stats|\index{stats} contiene algunos procedimientos clásicos de estadística inferencial. Cada uno de estos procedimientos devuelve un objeto de tipo \verb|inference_result|\index{inference\_result}, el cual guarda todos los resultados obtenidos, aunque sólo muestre una selección de ellos por defecto, los que se consideran de más relevancia; el resto permanecen ocultos y sólo serán visibles a petición del usuario. Los siguientes ejemplos aclararán su uso.

Partamos de una muestra de tamaño 20 y tratemos de contrastar la hipótesis nula de que la media de la población de la cual procede es igual a 32, frente a la alternativa de que la media es diferente a este valor. Para aplicar el test de Student nos interesa saber si podemos considerar la población normal; la función \verb|test_normality|\index{test\_normality} nos puede ser de ayuda,

\begin{Verbatim}
(%i1) load(stats)$
(%i2) x: [28.9,35.0,30.6,31.3,31.9,31.7,29.3,37.8,29.9,36.8,
          28.0,25.3,39.6,30.4,23.3,24.7,38.6,31.3,29.8,31.9]$
(%i3) test_normality(x);
\end{Verbatim}
\[
\left|
  \begin{array}{c}
     \mbox{{}SHAPIRO - WILK TEST{}}   \\
     {\it statistic} = 0.9508091      \\
     {\it p\_value}  = 0.3795395
  \end{array}
\right. \leqno{\tt (\%o3)}
\]

Según este resultado, no hay evidencias suficientes para rechazar la hipótesis de normalidad. Hagamos ahora el contraste sobre la media,

\begin{Verbatim}
(%i4) z: test_mean(x,mean=32);
\end{Verbatim}
\[
\left|
  \begin{array}{c}
     \mbox{{}MEAN TEST{}}   \\
     {\it mean\_estimate} = 31.305 \\
     {\it conf\_level} = 0.95 \\
     {\it conf\_interval} = \left[ 29.21482 , 33.39518 \right]  \\
     {\it method} = \mbox{{}Exact t-test. Unknown variance.{}}  \\
     {\it hypotheses} = \mbox{{}H0: mean = 32 , H1: mean} \neq \mbox{32{}} \\
     {\it statistic} = 0.6959443 \\
     {\it distribution} = \left[ {\it student\_t} , 19 \right]  \\
     {\it p\_value} = 0.4948895
  \end{array}
\right. \leqno{\tt (\%o4)}
\]

En la llamada a la función \verb|test_mean|\index{test\_mean} se ha indicado mediante la opción \verb|mean| el valor de la media en la hipótesis nula. El objeto devuelto por la función consta, como se ve, de varios elementos: el título del objeto, la media muestral, el nivel de confianza, el intervalo de confianza, información sobre el método utilizado, hipótesis a contrastar, estadístico de contraste, su distribución y el $p$-valor correspondiente. Si ahora quisiésemos extraer la media muestral para utilizar en otros cálculos,

\index{take\_inference}\begin{Verbatim}
(%i5) take_inference(mean_estimate,z);
\end{Verbatim}
\[
31.305\leqno{\tt (\%o5)}
\]

En caso de querer extraer más de un resultado,

\begin{Verbatim}
(%i6) take_inference([p_value,statistic],z);
\end{Verbatim}
\[
\left[ 0.4948895 , 0.6959443 \right] \leqno{\tt (\%o6)}
\]

Para saber con certeza qué resultados guarda el objeto devuelto haremos uso de la función \verb|items_inference|\index{items\_inference}, con lo que comprobamos que la función \verb|test_mean| no oculta ninguno de sus resultados,

\begin{Verbatim}
(%i7) items_inference(z);
\end{Verbatim}
\[
\left[ {\it mean\_estimate} , {\it conf\_level} , 
 {\it conf\_interval} , {\it method} , {\it hypotheses} , 
 {\it statistic} , {\it distribution} , {\it p\_value} \right] \leqno{\tt (\%o7)}
\]

En caso de que la muestra no procediese de una población normal, y si el tamaño muestral fuese suficientemente grande, se podría hacer uso de la opción \verb|asymptotic=true|, si la desviación típica de la población fuese conocida, por ejemplo $\sigma=4.5$, podría añadirse la opción \verb|dev=4.5|. En fin, las opciones que admite esta función permiten al usuario tener cierto control sobre el procedimiento; para más información consúltese el manual.

Si la población de referencia no es normal y la muestra es pequeña, siempre se puede acudir a un test no paramétrico para realizar un contraste sobre la mediana,

\index{test\_signed\_rank}\begin{Verbatim}
(%i8) signed_rank_test(x,median=32);
\end{Verbatim}
\[
\left|
  \begin{array}{c}
     \mbox{{}SIGNED RANK TEST{}}   \\
     {\it med\_estimate} = 30.95 \\
     {\it method} = \mbox{{}Asymptotic test. Ties{}} \\
     {\it hypotheses} = \mbox{{}H0: med = 32 , H1: med} \neq \mbox{32{}} \\
     {\it statistic} = 75  \\
     {\it distribution} = \left[ {\it normal} , 104.5 , 26.78152 \right] \\
     {\it p\_value} = 0.2706766
  \end{array}
\right. \leqno{\tt (\%o8)}
\]

Consúltese el manual de referencia de Maxima para ver qué otros tests están programados en el paquete \verb|stats|, así como las opciones que se pueden utilizar en cada caso.









\newpage
\chapter{Otros métodos numéricos}
\label{sec:numericos}



\section{Interpolación}

El paquete \verb|interpol|\index{interpol} permite abordar el problema de la interpolación desde tres enfoques: lineal, polinomio de Lagrange y \emph{splines} cúbicos.

A lo largo de esta sección vamos a suponer que disponemos de los valores empíricos de la siguiente tabla:

\begin{center}
\begin{tabular}{|c||c|c|c|c|c|} \hline
x & 7 & 8 & 1 & 3 & 6   \\ \hline
y & 2 & 2 & 5 & 2 & 7   \\ \hline
\end{tabular}
\end{center}

Nos planteamos en primer lugar el cálculo de la función de interpolación lineal, para lo cual haremos uso de la función \verb|linearinterpol|,

\begin{Verbatim}
(%i1) load(interpol)$
\end{Verbatim}

\begin{Verbatim}
(%i2) datos: [[7,2],[8,2],[1,5],[3,2],[6,7]]$
\end{Verbatim}

\index{linearinterpol}\begin{Verbatim}
(%i3) linearinterpol(datos);
\end{Verbatim}
\[
\begin{array}{c}
\left({{13}\over{2}}-{{3\,x}\over{2}}\right)\,{\it charfun_2}\left(
 x ,  -\infty  , 3\right)+2\,{\it charfun_2}\left(x , 7 , \infty 
 \right)+  \\   \left(37-5\,x\right)\,{\it charfun_2}\left(x , 6 , 7\right)+
 \left({{5\,x}\over{3}}-3\right)\,{\it charfun_2}\left(x , 3 , 6
 \right)  \end{array}  \leqno{\tt (\%o3)}
\]

\begin{Verbatim}
(%i4) f(x):=''%$
\end{Verbatim}

Empezamos cargando el paquete que define las funciones de interpolación y a continuación introducimos los pares de datos en forma de lista. La función \verb|linearinterpol| devuelve una expresión definida a trozos, en la que \verb|charfun2(x,a,b)|\index{charfun2} devuelve 1 si el primer argumento pertence al intervalo $[a, b)$ y 0 en caso contrario. Por último, definimos cierta función \verb|f| previa evaluación (dos comillas simples) de la expresión devuelta por \verb|linearinterpol|. Esta función la podemos utilizar ahora tanto para interpolar como para extrapolar:

\begin{Verbatim}
(%i5) map(f,[7.3,25/7,%pi]);
\end{Verbatim}
\[
\left[ 2 , {{62}\over{21}} , {{5\,\pi}\over{3}}-3 \right] \leqno{\tt (\%o5)}
\]

\begin{Verbatim}
(%i6) float(%);
\end{Verbatim}
\[
\left[ 2.0 , 2.952380952380953 , 2.235987755982989 \right] \leqno{\tt (\%o6)}
\]

Unos comentarios antes de continuar. Los datos los hemos introducido como una lista de pares de números, pero también la función admite una matriz de dos columnas o una lista de números, asignándole en este último caso las abscisas secuencialmente a partir de la unidad; además, la lista de pares de la variable \verb|datos| no ha sido necesario ordenarla respecto de la primera coordenada, asunto del que ya se encarga Maxima por cuenta propia.

El polinomio de interpolación de Lagrange se calcula con la función \verb|lagrange|; en el siguiente ejemplo le daremos a los datos un formato matricial y le indicaremos a Maxima que nos devuelva el polinomio con variable independiente \verb|w|,

\begin{Verbatim}
(%i7) datos2: matrix([7,2],[8,2],[1,5],[3,2],[6,7]);
\end{Verbatim}
\[
\begin{pmatrix}7&2\cr 8&2\cr 1&5\cr 3&2\cr 6&7\cr \end{pmatrix} \leqno{\tt (\%o7)}
\]

\index{lagrange}\begin{Verbatim}
(%i8) lagrange(datos2,varname='w);
\end{Verbatim}
\[
{{73\,w^4}\over{420}}-{{701\,w^3}\over{210}}+{{8957\,w^2}\over{420
 }}-{{5288\,w}\over{105}}+{{186}\over{5}}\leqno{\tt (\%o8)}
\]

\begin{Verbatim}
(%i9) g(w):=''%$
\end{Verbatim}

\begin{Verbatim}
(%i10) map(g,[7.3,25/7,%pi]), numer;
\end{Verbatim}
\[
\left[ 1.043464999999799 , 5.567941928958199 , 2.89319655125692
  \right] \leqno{\tt (\%o10)}
\]

Disponemos en este punto de dos funciones de interpolación; representémoslas gráficamente junto con los datos empíricos,

\begin{Verbatim}
(%i11) load(draw)$
\end{Verbatim}

\begin{Verbatim}
(%i12) draw2d(
         key       = "Interpolador lineal",
         explicit(f(x),x,0,10),
         line_type = dots,
         key       = "Interpolador de Lagrange",
         explicit(g(x),x,0,10),
         key       = "Datos empiricos",
         points(datos),
         terminal  = eps)$
\end{Verbatim}
cuyo resultado se ve en el apartado \emph{a)} de la Figura~\ref{fig:int}.


El método de los \emph{splines} cúbicos consiste en calcular polinomios interpoladores de tercer grado entre dos puntos de referencia consecutivos, de manera que sus derivadas cumplan ciertas condiciones que aseguren una curva sin cambios bruscos de dirección. La función que ahora necesitamos es \verb|cspline|,

\index{cspline}\begin{Verbatim}
(%i13) cspline(datos);
\end{Verbatim}
\[
\begin{array}{c}
\left({{1159\,x^3}\over{3288}}-{{1159\,x^2}\over{1096}}-{{6091\,x
 }\over{3288}}+{{8283}\over{1096}}\right)\,{\it charfun_2}\left(x , 
  -\infty  , 3\right)+ \\ \left(-{{2587\,x^3}\over{1644}}+{{5174\,x^2
 }\over{137}}-{{494117\,x}\over{1644}}+{{108928}\over{137}}\right)\,
 {\it charfun_2}\left(x , 7 , \infty \right)+ \\ \left({{4715\,x^3}\over{1644
 }}-{{15209\,x^2}\over{274}}+{{579277\,x}\over{1644}}-{{199575}\over{274
 }}\right)\,{\it charfun_2}\left(x , 6 , 7\right)+  \\ \left(-{{3287\,x^3
 }\over{4932}}+{{2223\,x^2}\over{274}}-{{48275\,x}\over{1644}}+{{9609
 }\over{274}}\right)\,{\it charfun_2}\left(x , 3 , 6\right) \end{array} \leqno{\tt (\%o13)}
\]

\begin{Verbatim}
(%i14) s1(x):=''%$
\end{Verbatim}

\begin{Verbatim}
(%i15) map(s1,[7.3,25/7,%pi]), numer;
\end{Verbatim}
\[
\left[ 1.438224452554664 , 3.320503453379974 , 2.227405312429507
  \right] \leqno{\tt (\%o15)}
\]

La función \verb|cspline| admite, además de la opción \verb|'varname| que ya se vió anteriormente, otras dos a las que se hace referencia con los símbolos \verb|'d1| y \verb|'dn|, que indican las primeras derivadas en las abscisas de los extremos; estos valores establecen las condiciones de contorno y con ellas Maxima calculará los valores de las segundas derivadas en estos mismos puntos extremos; en caso de no suministrarse, como en el anterior ejemplo, las segundas derivadas se igualan a cero. En el siguiente ejemplo hacemos uso de estas opciones,

\begin{Verbatim}
(%i16) cspline(datos,'varname='z,d1=1,dn=0);
\end{Verbatim}
\[
\begin{array}{c}
\left({{2339\,z^3}\over{2256}}-{{14515\,z^2}\over{2256}}+{{24269\,z
 }\over{2256}}-{{271}\over{752}}\right)\,{\it charfun_2}\left(z , 
  -\infty  , 3\right)+ \\  \left(-{{1553\,z^3}\over{564}}+{{35719\,z^2
 }\over{564}}-{{68332\,z}\over{141}}+{{174218}\over{141}}\right)\,
 {\it charfun_2}\left(z , 7 , \infty \right)+ \\ \left({{613\,z^3}\over{188
 }}-{{35513\,z^2}\over{564}}+{{56324\,z}\over{141}}-{{38882}\over{47
 }}\right)\,{\it charfun_2}\left(z , 6 , 7\right)+ \\ \left(-{{4045\,z^3
 }\over{5076}}+{{1893\,z^2}\over{188}}-{{5464\,z}\over{141}}+{{2310
 }\over{47}}\right)\,{\it charfun_2}\left(z , 3 , 6\right) \end{array} \leqno{\tt (\%o16)}
\]

\begin{Verbatim}
(%i17) s2(z):=''%$
\end{Verbatim}

\begin{Verbatim}
(%i18) map(s2,[7.3,25/7,%pi]), numer;
\end{Verbatim}
\[
\left[ 1.595228723404261 , 2.88141531519733 , 2.076658794432369
  \right] \leqno{\tt (\%o18)}
\]


\begin{figure}
\begin{center}
\includegraphics[scale=0.55]{interpol1.pdf} 
\includegraphics[scale=0.55]{interpol2.pdf} \\
\emph{a)} \hspace{6.5cm}  \emph{b)} \\
\caption{Interpolación: \emph{a)} lineal y de Lagrange; \emph{b)} \emph{Splines} cúbicos.}
\label{fig:int}
\end{center}
\end{figure}

Con esto hemos obtenido dos interpoladores distintos por el método de los \emph{splines} cúbicos; con el siguiente código pedimos su representación gráfica, cuyo resultado se observa en el apartado \emph{b)} de la Figura~\ref{fig:int}.

\begin{Verbatim}
(%i19) draw2d(
         key       = "s1",
         explicit(s1(x),x,0,10),
         line_type = dots,
         key       = "s2",
         explicit(s2(x),x,0,10),
         key       = "Datos empiricos",
         points(datos),
         terminal  = eps)$
\end{Verbatim}






\section{Ajuste por mínimos cuadrados}


Existe en Maxima la posibilidad de ajustar por mínimos cuadrados a datos empíricos los parámetros de curvas arbitrarias mediante las funciones del paquete \verb|lsquares|\index{lsquares}. Vamos a simular una muestra de tamaño 100 de valores $x$ en el intervalo $[0,10]$. Con estas abscisas calculamos después las ordenadas a partir de la suma de una señal determinista ($f$) más un ruido gaussiano. Para hacer la simulación necesitamos cargar en primer lugar al paquete \verb|distrib|.

\index{random\_continuous\_uniform}\begin{Verbatim}
(%i1) load(distrib)$
(%i2) abs: makelist(random_continuous_uniform(0,10),k,1,100)$
(%i3) f(x):=3*(x-5)^2$
(%i4) data: apply(matrix,makelist([x, f(x)+random_normal(0,1)],x,abs))$
\end{Verbatim}

Aunque la señal determinista obedece a una función polinómica de segundo grado, si no lo sabemos a priori intentamos ajustar un polinomio cúbico:

\index{lsquares\_estimates}\begin{Verbatim}
(%i5) load(lsquares)$
(%i6) param: lsquares_estimates(data,[x,y],
                                y=a*x^3+b*x^2+c*x+d,[a,b,c,d]), numer;
\end{Verbatim}
\[
\begin{array}{c}
\left[ \left[ a=-0.002705800223881305 , b=3.018798873646606 \right. \right.
  , \\  \left. \left. c=-29.94151342602112 , d=74.78603431944423 \right]  \right] \end{array} \leqno{\tt (\%o6)}
\]

Vemos claramente que el término de tercer grado es supérfluo, por lo que reajustamos al de segundo grado,

\begin{Verbatim}
(%i7) param: lsquares_estimates(data,[x,y],
                                y=b*x^2+c*x+d,[b,c,d]), numer;
\end{Verbatim}
\[
\left[ \left[ b=2.979110687882263 , c=-29.78353057922009 , d=74.64523259993118
  \right]  \right] \leqno{\tt (\%o7)}
\]

Ahora estamos en disposición de estudiar los residuos para valorar el ajuste. En primer lugar calculamos el error cuadrático medio del residuo, definido como

\[
\mbox{MSE} =  \frac{1}{n} \sum_{i=1}^{n} \left( \mbox{rhs}(e_i) -  \mbox{lhs}(e_i) \right)^2,
\]
siendo $n$ el tamaño de la muestra y $\mbox{rhs}(e_i)$ y $\mbox{lhs}(e_i)$ los miembros derecho e izquierdo, respectivamente, de la expresión a ajustar. Para el caso que nos ocupa, el valor calculado es

\index{lsquares\_residual\_mse}\begin{Verbatim}
(%i8) lsquares_residual_mse(data, [x,y], y=b*x^2+c*x+d, first(param));
\end{Verbatim}
\[
1.144872557335554\leqno{\tt (\%o8)}
\]

\index{lsquares\_residuals}También podemos calcular el vector de los residuos, definidos como $\mbox{lhs}(e_i) - \mbox{rhs}(e_i)$, $\forall i$, para a continuación representarlos gráficamente junto con los datos y la curva ajustada, tal como se aprecia en la Figura~\ref{fig:lsquares}.

\index{draw}\begin{Verbatim}
(%i9) res: lsquares_residuals(data, [x,y],
                              y=b*x^2+c*x+d, first(param))$
(%i10) load(draw)$ /* necesitaremos las rutinas gráficas */
(%i10) scene1: gr2d(points(data),
                    explicit(ev(b*x^2+c*x+d,first(param)),x,0,10))$
(%i12) scene2: gr2d(points_joined = true,
                    points(res))$
(%i13) draw(terminal = eps, scene1, scene2)$
\end{Verbatim}

\begin{figure}
\begin{center}
\includegraphics[scale=1.0]{lsquares.pdf}
\caption{Resultados gráficos del ajuste por mínimos cuadrados.}
\label{fig:lsquares}
\end{center}
\end{figure}

Nosotros ya sabemos que el ruido del proceso simulado es gaussiano de esperanza nula. En una situación real, este dato lo desconoceremos y nos interesará contrastar la hipótesis de normalidad y la de la nulidad de la media de los residuos. El paquete \verb|stats| tiene algunos procedimientos inferenciales, entre los cuales están las funciones \verb|test_normality| y \verb|test_mean|; primero cargamos el paquete y contrastamos la hipótesis de normalidad,

\index{test\_normality}\begin{Verbatim}
(%i14) load(stats)$
(%i15) test_normality(res);
\end{Verbatim}
\[
\left|
  \begin{array}{c}
    \mbox{{}SHAPIRO - WILK TEST{}}   \\
       {\it statistic} = 0.986785359052448  \\
       {\it p\_value} = 0.423354600782769
  \end{array}
\right. \leqno{\tt (\%o15)}
\]

El $p$-valor es lo suficientemente alto como para no rechazar la hipótesis nula de normalidad; ahora contrastamos la nulidad de la esperanza del ruido,

\index{test\_mean}\begin{Verbatim}
(%i16) test_mean(res);
\end{Verbatim}
\[
\left|
  \begin{array}{c}
       \mbox{{}MEAN TEST{}}  \\
       {\it mean\_estimate} = -1.002451472320587 \times 10^{-7}  \\
       {\it conf\_level} = 0.95 \\
       {\it conf\_interval} = \left[ -.2133782738324136 , .2133780733421191 \right] \\
       {\it method} = \mbox{{}Exact t-test. Unknown variance.{}} \\
       {\it hypotheses} = \mbox{{}H0: mean = 0 , H1: mean} \neq \mbox{{}0{}} \\
       {\it statistic} = 9.321855844715968 \times 10^{-7} \\
       {\it distribution} = \left[ {\it student\_t} , 99 \right] \\
       {\it p\_value} = .9999992583830712
  \end{array}
\right. \leqno{\tt (\%o16)}
\]

Sin duda admitiríamos la hipótesis nula como válida.








\section{Optimización con restricciones}

El paquete \verb|augmented_lagrangian|\index{augmented\_lagrangian} permite minimizar funciones bajo restricciones expresables en forma de igualdades. Concretamente, si queremos obtener el valor mínimo de la función $f(x,y) = x^2 + 2 y^2$, entre aquellos puntos que cumplen la condición $x+y=1$, podemos hacer uso de la función 
\verb|augmented_lagrangian_method|\index{augmented\_lagrangian\_method}.

En primer lugar debemos cargar en memoria el programa correspondiente,

\begin{Verbatim}
(%i1) load ("augmented_lagrangian")$
\end{Verbatim}

Introducimos la función objetivo y la restricción, la cual guardamos en una lista, dando por sentado que la expresión que la define está igualada a cero,

\begin{Verbatim}
(%i2) f(x,y) := x^2 + 2*y^2 $
(%i3) c: [x + y - 1] $
\end{Verbatim}

A continuación hacemos la llamada a la función correspondiente, en la que introducimos la función, la lista de variables independientes, las restricciones, un vector con una solución inicial aproximada y una opción que controla la salida de resultados intermedios. El valor que nos devuelve la función es una lista con dos elementos, siendo el primero la solución y el segundo el valor de un parámetro del algoritmo.

\begin{Verbatim}
(%i4) sol: augmented_lagrangian_method(
                f(x,y), [x, y], c, [1, 1], iprint=[-1,0]);
\end{Verbatim}
$$\left[ \left[ x=.6666598410800233 , y=.3333402724554476 \right]  , 
 {\it \%lambda}=\left[ -1.333337940892538 \right]  \right] \leqno{\tt (\%o4)}$$

Podemos asignar la solución a las variables \verb|x0| y \verb|y0| y a continuación \verb|z0|, el valor mínimo alcanzado,

\begin{Verbatim}
(%i5) [x0,y0]: map(rhs, first(sol)) $
(%i6) z0: f(x0,y0);
\end{Verbatim}
$$0.666666818190186\leqno{\tt (\%o6)}$$

Para facilitar la visualización del problema, podemos plantearnos la realización de un gráfico, Figura~\ref{fig:lagran},

\begin{Verbatim}
(%i7) load("draw") $
(%i8) draw3d(
        terminal = eps,
        view = [93, 143],
        enhanced3d = [z,x,z],
        explicit(x^2 + 2*y^2, x, -2, 2, y, -2, 2),

        color = red,
        enhanced3d = [-z,x,z],
        parametric_surface(x, -x+1, z, x, -2, 2, z, -1, 5),

        enhanced3d = false,
        color = black,
        point_size = 2,
        points([[x0,y0,z0]]))$
\end{Verbatim}

\begin{figure}
\begin{center}
\includegraphics[scale=1.6]{lagran.pdf}
\caption{Minimización con restricciones.}
\label{fig:lagran}
\end{center}
\end{figure}







\section{Programación lineal}

El paquete \verb|simplex|\index{simplex} dispone de las funciones \verb|minimize_lp|\index{minimize\_lp} y \verb|maximize_lp|\index{maximize\_lp} para la resolución de problemas de programación lineal. Nos planteamos el siguiente problema:

\begin{eqnarray*}
\mbox{Max.}      & F(x_1, x_2, x_3, x_4)  & =    2 x_1 + 4 x_2 + x_3 + x_4 \\
\mbox{sujeto a } & x_1 + 3 x_2 + x_4      & \leq 4 \\
                  & 2 x_1 + x_2           & \leq 3 \\
                  & x_2 + 4 x_3 + x_4     & \leq 3 \\
                  & x_1, x_2, x_3, x_4    & \in  \R^+
\end{eqnarray*}
que seguidamente pasamos a resolver cargando previamente en memoria el programa y definiendo la función objetivo y las restricciones asociadas al problema,

\begin{Verbatim}
(%i1) load("simplex") $
(%i2) F : 2*x1 + 4*x2 + x3 + x4 $
(%i3) r1 : x1 + 3*x2 + x4 <= 4 $
(%i4) r2 : 2*x1 + x2 <= 3 $
(%i5) r3 : x2 + 4*x3 + x4 <= 3 $
(%i6) r4 : x1 >= 0 $
(%i7) r5 : x2 >= 0 $
(%i8) r6 : x3 >= 0 $
(%i9) r7 : x4 >= 0 $
\end{Verbatim}

A continuación resolvemos el problema invocando la función \verb|maximize_lp|,

\begin{Verbatim}
(%i10) maximize_lp(F, [r1, r2, r3, r4, r5, r6, r7]);
\end{Verbatim}
$$\left[ {{13}\over{2}} , \left[ {\it x_3}={{1}\over{2}} , {\it x_4}=
 0 , {\it x_2}=1 , {\it x_1}=1 \right]  \right] \leqno{\tt (\%o10)}$$

El primer elemento de la lista es el valor máximo que alcanza la función objetivo y el segundo es la lista que contiene la solución.








\newpage
\chapter{Programando en Maxima}


\section{Programación a nivel de Maxima}


Esencialmente, programar consiste en escribir secuencialmente un grupo de sentencias sintácticamente correctas que el intérprete pueda leer y luego ejecutar; la manera más sencilla de empaquetar varias sentencias es mediante paréntesis, siendo el resultado del programa la salida de la última sentencia:

\begin{Verbatim}
(%i1) (a:3, b:6, a+b);
\end{Verbatim}
\[
9\leqno{\tt (\%o1)}
\]

\begin{Verbatim}
(%i2) a;
\end{Verbatim}
\[
3\leqno{\tt (\%o2)}
\]

\begin{Verbatim}
(%i3) b;
\end{Verbatim}
\[
6\leqno{\tt (\%o3)}
\]


Como se ve en las salidas \verb|%o2| y \verb|%o3|, este método conlleva un peligro, que consiste en que podemos alterar desapercibidamente valores de variables que quizás se estén utilizando en otras partes de la sesión actual. La solución pasa por declarar variables localmente, cuya existencia no se extiende más allá de la duración del programa, mediante el uso de bloques; el siguiente ejemplo muestra el mismo cálculo anterior declarando \verb|c| y \verb|d| locales, además se ve cómo es posible asignarles valores a las variables en el momento de crearlas:

\index{block}\begin{Verbatim}
(%i4) block([c,d:6],
        c:3,
        c+d );
\end{Verbatim}
\[
9\leqno{\tt (\%o4)}
\]

\begin{Verbatim}
(%i5) c;
\end{Verbatim}
\[
c\leqno{\tt (\%o5)}
\]

\begin{Verbatim}
(%i6) d;
\end{Verbatim}
\[
d\leqno{\tt (\%o6)}
\]

A la hora de hacer un programa, lo habitual es empaquetarlo como cuerpo de una función, de forma que sea sencillo utilizar el código escrito tantas veces como sea necesario sin más que escribir el nombre de la función con los argumentos necesarios; la estructura de la definición de una función necesita el uso del operador \verb|:=|

\begin{Verbatim}
                  f(<arg1>,<arg2>,...):=<expr>
\end{Verbatim}

donde \verb|<expr>| es una única sentencia o un bloque con variables locales; véanse los siguientes ejemplos:

\begin{Verbatim}
(%i7) loga(x,a):= float(log(x) / log(a)) $
\end{Verbatim}

\begin{Verbatim}
(%i8) loga(7, 4);
\end{Verbatim}
\[
1.403677461028802\leqno{\tt (\%o8)}
\]

\begin{Verbatim}
(%i9) fact(n):=block([prod:1],
          for k:1 thru n do prod:prod*k,
          prod )$
\end{Verbatim}

\begin{Verbatim}
(%i10) fact(45);
\end{Verbatim}
\[
119622220865480194561963161495657715064383733760000000000\leqno{\tt (\%o10)}
\]


En el primer caso (\verb|loga|) se definen los logaritmos en base arbitraria (Maxima sólo tiene definidos los naturales); además, previendo que sólo los vamos a necesitar en su forma numérica, solicitamos que nos los evalúe siempre en formato decimal. En el segundo caso (\verb|fact|) hacemos uso de un bucle para calcular factoriales. Esta última función podría haberse escrito recursivamente mediante un sencillo condicional,

\begin{Verbatim}
(%i11) fact2(n):= if n=1 then 1
                         else n*fact2(n-1) $
\end{Verbatim}

\begin{Verbatim}
(%i12) fact2(45);
\end{Verbatim}
\[
119622220865480194561963161495657715064383733760000000000\leqno{\tt (\%o12)}
\]

O más fácil todavía,

\begin{Verbatim}
(%i13) 45!;
\end{Verbatim}
\[
119622220865480194561963161495657715064383733760000000000\leqno{\tt (\%o13)}
\]

Acabamos de ver dos estructuras de control de flujo comunes a todos los lenguajes de programación, las sentencias \verb|if-then-else| y los bucles \verb|for|. En cuanto a las primeras, puede ser de utilidad la siguiente tabla de operadores relacionales

\index{22@=}\index{23@\#}\index{24@$>$}\index{25@$<$}\index{26@$>=$}\index{27@$=<$}\begin{center}
\begin{tabular}{|c|c|} \hline
\verb|=|  &  ...igual que...         \\ \hline
\verb|#| &  ...diferente de...     \\ \hline
\verb|>|  &  ...mayor que...         \\ \hline
\verb|<|  &  ...menor que...         \\ \hline
\verb|>=| &  ...mayor o igual que... \\ \hline
\verb|<=| &  ...menor o igual que... \\ \hline
\end{tabular}
\end{center}

He aquí un ejemplo de uso.

\begin{Verbatim}
(%i14) makelist(is(log(x)<x-1), x, [0.9,1,1.1]);
\end{Verbatim}
\[
\left[ \mbox{true} , \mbox{false} , \mbox{true} \right] \leqno{\tt (\%o14)}
\]

Los operadores lógicos que frecuentemente se utilizarán con las relaciones anteriores son \verb|and|\index{and}, \verb|or|\index{or} y \verb|not|\index{not}, con sus significados obvios

\begin{center}
\begin{tabular}{|c|c||c|c|c|} \hline
     p       &       q      & p \verb|and| q & p \verb|or| q & \verb|not| p  \\ \hline
\verb|false| & \verb|false| & \verb|false|   & \verb|false|  & \verb|true|  \\
\verb|false| & \verb|true|  & \verb|false|   & \verb|true|   & \verb|true|  \\
\verb|true|  & \verb|false| & \verb|false|   & \verb|true|   & \verb|false|  \\
\verb|true|  & \verb|true|  & \verb|true|    & \verb|true|   & \verb|false|  \\ \hline
\end{tabular}
\end{center}

\begin{Verbatim}
(%i15) if sin(4)< 9/10  and 2^2 = 4 then 1 else -1 ;
\end{Verbatim}
\[
1\leqno{\tt (\%o15)}
\]

\begin{Verbatim}
(%i16) if sin(4)< -9/10  and 2^2 = 4 then 1 else -1 ;
\end{Verbatim}
\[
-1\leqno{\tt (\%o16)}
\]

Se ilustra en el ejemplo anterior (\verb|%i14|) cómo se evalúa con la función \verb|is|\index{is} el valor de verdad de una expresión relacional ante la ausencia de un condicional o de un operador lógico; la siguiente secuencia aclara algo más las cosas:

\begin{Verbatim}
(%i17) sin(4)< 9/10 ;
\end{Verbatim}
\[
\sin 4<{{9}\over{10}}\leqno{\tt (\%o17)}
\]

\begin{Verbatim}
(%i18) is(sin(4)< 9/10);
\end{Verbatim}
\[
\mbox{true}\leqno{\tt (\%o18)}
\]

Pero ante la presencia de un operador lógico o una sentencia condicional, \verb|is| ya no es necesario:

\begin{Verbatim}
(%i19) sin(4)< 9/10  and 2^2 = 4;
\end{Verbatim}
\[
\mbox{true}\leqno{\tt (\%o19)}
\]

\index{if}\begin{Verbatim}
(%i20) if sin(4)< 9/10 then 1;
\end{Verbatim}
\[
1\leqno{\tt (\%o20)}
\]

En cuanto a los bucles, \verb|for|\index{for} es muy versátil; tiene las siguientes variantes:

\begin{Verbatim}
         for <var>:<val1> step <val2> thru <val3> do <expr>
         for <var>:<val1> step <val2> while <cond> do <expr>
         for <var>:<val1> step <val2> unless <cond> do <expr>
\end{Verbatim}

Cuando el incremento de la variable es la unidad, se puede obviar la parte de la sentencia relativa a \verb|step|\index{step}, dando lugar a los esquemas

\index{thru}\index{while}\index{unless}\begin{Verbatim}
              for <var>:<val1> thru <val3> do <expr>
              for <var>:<val1> while <cond> do <expr>
              for <var>:<val1> unless <cond> do <expr>
\end{Verbatim}

Cuando no sea necesaria la presencia de una variable de recuento de iteraciones, también se podrá prescindir de los \verb|for|, como en

\begin{Verbatim}
                          while <cond> do <expr>
                          unless <cond> do <expr>
\end{Verbatim}

Algunos ejemplos que se explican por sí solos:

\begin{Verbatim}
(%i21) for z:-5 while z+2<0 do print(z) ;
- 5
- 4
- 3
\end{Verbatim}
\[
\mbox{done}\leqno{\tt (\%o21)}
\]

\begin{Verbatim}
(%i22) for z:-5 unless z+2>0 do print(z) ;
- 5
- 4
- 3
- 2
\end{Verbatim}
\[
\mbox{done}\leqno{\tt (\%o22)}
\]

\begin{Verbatim}
(%i23) for cont:1 thru 3 step 0.5 do (var: cont^3, print(var)) ;
1
3.375
8.0
15.625
27.0
\end{Verbatim}
\[
\mbox{done}\leqno{\tt (\%o23)}
\]

\begin{Verbatim}
(%i24) [z, cont, var];
\end{Verbatim}
\[
\left[ z , {\it cont} , 27.0 \right] \leqno{\tt (\%o24)}
\]

\begin{Verbatim}
(%i25) while random(20) < 15 do print("qqq") ;
qqq 
qqq 
qqq 
\end{Verbatim}
\[
\mbox{done}\leqno{\tt (\%o25)}
\]

Véase en el resultado \verb|%o24| cómo las variables \verb|z| y \verb|cont| no quedan con valor asignado, mientras que \verb|var| sí; la razón es que tanto \verb|z| como \verb|cont| son locales en sus respectivos bucles, expirando cuando éste termina; esto significa, por ejemplo, que no sería necesario declararlas locales dentro de un bloque.

Otra variante de \verb|for|, sin duda inspirada en la propia sintaxis de Lisp, es cuando el contador recorre los valores de una lista; su forma es

\begin{Verbatim}
                          for <var> in <lista> do <expr>
\end{Verbatim}

y un ejemplo:

\index{in}\begin{Verbatim}
(%i26) for z in [sin(x), exp(x), x^(3/4)] do print(diff(z,x)) $

cos(x)

  x
%e

  3
------
   1/4
4 x
\end{Verbatim}

Cuando una función debe admitir un número indeterminado de argumentos, se colocarán primero los que tengan carácter obligatorio, encerrando el último entre corchetes para indicar que a partir de ahí el número de argumentos puede ser arbitrario. La siguiente función suma y resta alternativamente las potencias $n$-ésimas de sus argumentos, siendo el exponente su primer argumento,

\begin{Verbatim}
(%i27) sumdif(n,[x]):= x^n . makelist((-1)^(k+1), k, 1, length(x)) $
\end{Verbatim}

\begin{Verbatim}
(%i28) sumdif(7,a,b,c,d,e,f,g);
\end{Verbatim}
\[
g^7-f^7+e^7-d^7+c^7-b^7+a^7\leqno{\tt (\%o28)}
\]

\begin{Verbatim}
(%i29) sumdif(%pi,u+v);
\end{Verbatim}
\[
\left(v+u\right)^{\pi}\leqno{\tt (\%o29)}
\]

En la entrada \verb|%i27|, dentro del cuerpo de la función, la variable \verb|x| es la lista de los argumentos que podríamos llamar \emph{restantes}; como tal lista, la función \verb|length| devuelve el número de elementos que contiene. Recuérdese también que una lista elevada a un exponente devuelve otra lista con los elementos de la anterior elevados a ese mismo exponente. Por último, el operador \verb|.| calcula el producto escalar.

En otras ocasiones, puede ser de interés pasar como argumento una función, en lugar de un valor numérico o una expresión. Esto no tiene problema para Maxima, pero debe hacerse con cierto cuidado. A continuación se define una función de Maxima que toma como argumento una función y la aplica a los cinco primeros números enteros positivos,

\begin{Verbatim}
(%i30) fun_a(G):= map(G, [1,2,3,4,5]) $
\end{Verbatim}

Pretendemos ahora aplicar a estos cinco elementos la función seno, lo cual no da ningún problema, 

\begin{Verbatim}
(%i31) fun_a(sin);
\end{Verbatim}
\[
\left[ \sin 1 , \sin 2 , \sin 3 , \sin 4 , \sin 5 \right] \leqno{\tt (\%o31)}
\]

Pero el problema lo vamos a tener cuando queramos aplicar una función algo más compleja,

\begin{Verbatim}
(%i32) fun_a(sin(x)+cos(x));
Improper name or value in functional position:
sin(x) + cos(x)
#0: fun_a(g=sin(x)+cos(x))
 -- an error.  To debug this try debugmode(true);
\end{Verbatim}
lo cual se debe al hecho de que la función \verb|map| no reconoce el argumento como función. En tal caso lo apropiado es definir la función objetivo separadamente, lo cual podemos hacer como función ordinaria o como función lambda:

\begin{Verbatim}
(%i33) sc(z):= sin(z) + cos(z) $
\end{Verbatim}

\begin{Verbatim}
(%i34) fun_a(sc);
\end{Verbatim}
\[
\left[ \sin 1+\cos 1 , \sin 2+\cos 2 , \sin 3+\cos 3 , \sin 4+\cos 4
  , \sin 5+\cos 5 \right] \leqno{\tt (\%o34)}
\]

\begin{Verbatim}
(%i35) fun_a( lambda([z], sin(z)+cos(z)) );
\end{Verbatim}
\[
\left[ \sin 1+\cos 1 , \sin 2+\cos 2 , \sin 3+\cos 3 , \sin 4+\cos 4
  , \sin 5+\cos 5 \right] \leqno{\tt (\%o35)}
\]

Cuando se hace un programa, lo habitual es escribir el código con un editor de texto y almacenarlo en un archivo con extensión \verb|mac|. Una vez dentro de Maxima, la instrucción

\begin{Verbatim}
                    load("ruta/fichero.mac")$
\end{Verbatim}
leerá las funciones escritas en él y las cargará en la memoria, listas para ser utilizadas.

Si alguna de las funciones definidas en el fichero \verb|fichero.mac| contiene algún error, devolviéndonos un resultado incorrecto, Maxima dispone del modo de ejecución de depurado (\verb|debugmode|\index{debugmode}), que ejecuta el código paso a paso, pudiendo el programador chequear interactivamente el estado de las variables o asignarles valores arbitrariamente. Supongamos el siguiente contenido de cierto fichero \verb|prueba.mac|

\begin{Verbatim}[frame=single]
foo(y) := 
  block ([u:y^2],
    u: u+3,
    u: u^2,
    u);
\end{Verbatim}

Ahora, la siguiente sesión nos permite analizar los valores de las variables en cierto punto de la ejecución de la función:

\begin{Verbatim}
(%i26) load("prueba.mac"); /* cargamos fichero */
\end{Verbatim}
\[
\mbox{{}prueba.mac{}}\leqno{\tt (\%o26)}
\]

\begin{Verbatim}
(%i27) :break foo 3        /* declaro punto de ruptura al final de línea 3*/
Turning on debugging debugmode(true)
Bkpt 0 for foo (in prueba.mac line 4)
\end{Verbatim}

\begin{Verbatim}
(%i27) foo(2);             /* llamada a función */
Bkpt 0:(prueba.mac 4)
prueba.mac:4::             /* se detiene al comienzo de la línea 4 */
(dbm:1) u;                 /* ¿valor de u? */
7
(dbm:1) y;                 /* ¿valor de y? */
2
(dbm:1) u: 1000;           /* cambio valor de u */
1000
(dbm:1) :continue          /* continúa ejecución */
\end{Verbatim}
\[
1000000\leqno{\tt (\%o27)}
\]




\section{Programación a nivel de Lisp}


A veces se presentan circunstancias en las que es mejor hacer programas para Maxima directamente en Lisp\index{lisp}; tal es el caso de las funciones que no requieran de mucho procesamiento simbólico, como funciones de cálculo numérico o la creación de nuevas estructuras de datos.

Sin dar por hecho que el lector conoce el lenguaje de programación Lisp, nos limitaremos a dar unos breves esbozos. Empecemos por ver cómo almacena Maxima internamente algunas expresiones:

\begin{Verbatim}
(%i1) 3/4;
\end{Verbatim}
\[
{{3}\over{4}}\leqno{\tt (\%o1)}
\]

\begin{Verbatim}
(%i2) :lisp $%o1
((RAT SIMP) 3 4)
\end{Verbatim}

\begin{Verbatim}
(%i2) :lisp ($num $%o1)
3
\end{Verbatim}

La expresión $\frac{3}{4}$ se almacena internamente como la lista \verb|((RAT SIMP) 3 4)|. Una vez se ha entrado en modo Lisp mediante \verb|:lisp|, le hemos pedido a Maxima que nos devuelva la expresión \verb|%o1|; la razón por la que se antepone el símbolo de dólar es que desde Lisp, los objetos de Maxima, tanto variables como nombres de funciones, llevan este prefijo. En la segunda instrucción que introducimos a nivel Lisp, le indicamos que aplique a la fracción la función de Maxima \verb|num|, que devuelve el numerador de una fracción.

Del mismo modo que desde el nivel de Lisp ejecutamos una instrucción de Maxima, al nivel de Maxima también se pueden ejecutar funciones de Lisp. Como ejemplo, veamos el comportamiento de las dos funciones de redondeo, la definida para Maxima y la propia del lenguaje Lisp:

\begin{Verbatim}
(%i3) round(%pi);
\end{Verbatim}
\[
3\leqno{\tt (\%o3)}
\]

\begin{Verbatim}
(%i4) ?round(%pi);
Maxima encountered a Lisp error:

 
ROUND: $%PI is not a real number

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
\end{Verbatim}

En el primer caso llamamos a la función de redondeo de Maxima y nos devuelve un resultado que reconocemos como correcto. En el segundo caso, al utilizar el prefijo \verb|?|, estamos haciendo una llamada a la función \verb|round| de Lisp y obtenemos un error; la razón es que esta función de Lisp sólo reconoce números como argumentos. En otras palabras, a nivel de Maxima se ha redefinido \verb|round| para que reconozca expresiones simbólicas.

A efectos de saciar nuestra curiosidad, veamos cómo se almacenan internamente otras expresiones:

\begin{Verbatim}
(%i5) x+y*2;
\end{Verbatim}
\[
2\,y+x\leqno{\tt (\%o5)}
\]

\begin{Verbatim}
(%i6) [1,2];
\end{Verbatim}
\[
\left[ 1 , 2 \right] \leqno{\tt (\%o6)}
\]

\begin{Verbatim}
(%i7) :lisp $%o5
((MPLUS SIMP) $X ((MTIMES SIMP) 2 $Y))
\end{Verbatim}

\begin{Verbatim}
(%i7) :lisp $%o6
((MLIST SIMP) 1 2)
\end{Verbatim}

Otra forma de mostrar la representación interna de expresiones de Maxima es invocando la función \verb|print| de Lisp. El siguiente ejemplo nos muestra que Maxima almacena internamente una expresión negativa como un producto por -1.

\begin{Verbatim}
(%i8) ?print(-a)$

((MTIMES SIMP) -1 $A)
\end{Verbatim}

Para terminar, un ejemplo de cómo definir a nivel de Lisp una función que cambia de signo una expresión cualquiera que le pasemos como argumento:

\begin{Verbatim}
(%i8) :lisp (defun $opuesto (x) (list '(mtimes) -1  x))
$OPUESTO
\end{Verbatim}

\begin{Verbatim}
(%i9) opuesto(a+b);
\end{Verbatim}
\[
-b-a\leqno{\tt (\%o9)}
\]

Se ha hecho un gran esfuerzo para que Maxima sea lo más universal posible en cuanto a entornos \emph{Common Lisp}, de tal manera que en la actualidad Maxima funciona perfectamente con los entornos libres \verb|clisp|, \verb|gcl|, \verb|cmucl| o \verb|sbcl|.

También es posible llamar desde el nivel de Lisp funciones que previamente hayan sido definidas en Maxima, para lo cual será necesario utilizar la función Lisp \verb|mfuncall|.

\begin{Verbatim}
(%i10) cubo(x):= x^3$
(%i11) :lisp (mfuncall '$cubo 3)
27
\end{Verbatim}

Con \verb|:lisp| sólo podemos ejecutar una única sentencia Lisp; pero si lo que queremos es abrir una sesión Lisp completa, haremos uso de la función \verb|to_lisp|\index{to\_lisp}, terminada la cual volveremos a Maxima ejecutando \verb|(to-maxima)|.

\begin{Verbatim}
(%i12) to_lisp()$
Type (to-maxima) to restart, ($quit) to quit Maxima.

MAXIMA> (+ #c(3 4) #c(5 6/8)) ; suma complejos
#C(8 19/4)
MAXIMA> (if (< 2 0) 
            "2 es negativo"
            "2 no es negativo") ; ejemplo de condicional
"2 no es negativo"
MAXIMA> (to-maxima)
Returning to Maxima
(%i13)
\end{Verbatim}







\newpage

\printindex

\end{document}