This is maxima.info, produced by makeinfo version 6.5 from maxima.texi.

Este es el Manual de Maxima en versión Texinfo

Copyright 1994, 2001 William F. Schelter

START-INFO-DIR-ENTRY
* Maxima: (maxima).  Un sistema de cálculo simbólico
END-INFO-DIR-ENTRY


File: maxima.info,  Node: Funciones y variables para picture,  Next: Funciones y variables para worldmap,  Prev: Funciones y variables para draw,  Up: draw

47.3 Funciones y variables para picture
=======================================

 -- Función: get_pixel (<pic>,<x>,<y>)
     Devuelve el pixel de la imagen <pic>.  Las coordenadas <x> e <y>
     van desde 0 hasta ‘ancho-1’ y ‘alto-1’, respectivamente.

 -- Función: make_level_picture (<data>)
 -- Función: make_level_picture (<data>,<width>,<height>)
     Devuelve un objeto ‘picture’ consistente en una imagen de niveles.
     ‘make_level_picture (<data>)’ construye el objeto ‘picture’ a
     partir de la matriz <data>.  ‘make_level_picture
     (<data>,<width>,<height>)’ construye el objeto a partir de una
     lista de números, en cuyo caso deben indicarse el ancho <width> y
     la altura <height> en píxeles.

     El objeto ‘picture’ devuelto contiene los siguientes cuatro
     elemento:

       1. el símbolo ‘level’
       2. anchura de la imagen
       3. altura de la imagen
       4. un array de enteros con los valores de los píxeles entre 0 y
          255.  El argumento <data> debe contener sólo números entre 0 y
          255; los cantidades negativas se transforman en ceros y las
          que son mayores de 255 se igualan a este número.

     Ejemplo:

     Imagen de niveles a partir de una matriz.
          (%i1) load("draw")$
          (%i2) make_level_picture(matrix([3,2,5],[7,-9,3000]));
          (%o2)         picture(level, 3, 2, {Array:  #(3 2 5 7 0 255)})

     Imagen de niveles a partir de una lista numérica.
          (%i1) load("draw")$
          (%i2) make_level_picture([-2,0,54,%pi],2,2);
          (%o2)            picture(level, 2, 2, {Array:  #(0 0 54 3)})

 -- Función: make_rgb_picture (<redlevel>,<greenlevel>,<bluelevel>)
     Devuelve un objeto <picture> conteniendo una imagen en color (RGB).
     Los tres argumentos deben ser imágenes de niveles, para el rojo
     (R), verde (G) y azul (B).

     El objeto <picture> devuelto contiene los siguientes cuatro
     elemento:

       1. el símbolo ‘rgb’
       2. anchura de la imagen
       3. altura de la imagen
       4. un array de enteros de <3*ancho*alto> con los valores de los
          píxeles entre 0 y 255.  Cada valor de pixel se representa en
          el array con tres números consecutivos (rojo, verde, azul).

     Ejemplo:

          (%i1) load("draw")$
          (%i2) red: make_level_picture(matrix([3,2],[7,260]));
          (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
          (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
          (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
          (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
          (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
          (%i5) make_rgb_picture(red,green,blue);
          (%o5) picture(rgb, 2, 2,
                        {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})

 -- Función: negative_picture (<pic>)
     Devuelve el negativo de la imagen, sea ésta de tipo nivel (<level>)
     o color (<rgb>).

 -- Función: picture_equalp (<x>,<y>)
     Devuelve ‘true’ si los dos argumentos son imágenes idénticas, o
     ‘false’ en caso contrario.

 -- Función: picturep (<x>)
     Devuelve ‘true’ si el argumento es una imagen bien formada, o
     ‘false’ en caso contrario.

 -- Función: read_xpm (<xpm_file>)
     Lee el fichero gráfico en formato xpm y devuelve un objeto
     ‘picture’.

 -- Función: rgb2level (<pic>)
     Transforma una imagen en color <rgb> a otra de niveles <level>
     promediando los niveles.

 -- Función: take_channel (<im>,<color>)
     Si el argumento <color> es ‘red’, ‘green’ o ‘blue’, la función
     ‘take_channel’ devuelve el canal de color correspondiente de la
     imagen <im>.

     Ejemplo:

          (%i1) load("draw")$
          (%i2) red: make_level_picture(matrix([3,2],[7,260]));
          (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
          (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
          (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
          (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
          (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
          (%i5) make_rgb_picture(red,green,blue);
          (%o5) picture(rgb, 2, 2,
                        {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})
          (%i6) take_channel(%,'green);  /* simple quote!!! */
          (%o6)           picture(level, 2, 2, {Array:  #(54 23 73 0)})


File: maxima.info,  Node: Funciones y variables para worldmap,  Prev: Funciones y variables para picture,  Up: draw

47.4 Funciones y variables para worldmap
========================================

Este paquete carga automáticamente el paquete ‘draw’.

47.4.1 Variables y Funciones
----------------------------

 -- Global variable: boundaries_array
     Valor por defecto: ‘false’

     ‘boundaries_array’ es donde el objeto gráfico ‘geomap’ lee las
     coordenadas de las líneas fronterizas.

     Cada componente de ‘boundaries_array’ es un array de números
     decimales en coma flotante representando las coordenadas que
     definen un segmento poligonal o línea fronteriza.

     Véase también ‘geomap’.

 -- Función: numbered_boundaries (<nlist>)
     Dibuja una lista de segmentos poligonales (líneas fronterizas),
     etiquetadas con sus números correspondientes (coordenadas de
     ‘boundaries_array’).  Esta función es de mucha ayuda a la hora de
     definir nuevas entidades geográficas.

     Ejemplo:

     Mapa de Europa con las fronteras y costas etiquetadas con su
     componente numérica de ‘boundaries_array’.
          (%i1) load("worldmap")$
          (%i2) european_borders:
                     region_boundaries(-31.81,74.92,49.84,32.06)$
          (%i3) numbered_boundaries(european_borders)$

 -- Función: make_poly_continent (<continent_name>)
 -- Función: make_poly_continent (<country_list>)
     Construye los polígonos necesarios para dibujar un continente o
     lista de países coloreados.

     Ejemplo:

          (%i1) load("worldmap")$
          (%i2) /* A continent */
                make_poly_continent(Africa)$
          (%i3) apply(draw2d, %)$
          (%i4) /* A list of countries */
                make_poly_continent([Germany,Denmark,Poland])$
          (%i5) apply(draw2d, %)$

 -- Función: make_poly_country (<country_name>)
     Construye los polígonos necesarios para dibujar un país coloreado.
     En caso de contener islas, un país tendrá asociados varios
     polígonos.

     Ejemplo:

          (%i1) load("worldmap")$
          (%i2) make_poly_country(India)$
          (%i3) apply(draw2d, %)$

 -- Función: make_polygon (<nlist>)
     Devuelve un objeto ‘polygon’ a partie de una lista de líneas
     fronterizas y de costas.  El argumento <nlist> debe ser una lista
     de componentes de ‘boundaries_array’.

     Ejemplo:

     La variable Bhutan (Bután) está definida con los números
     fronterizos 171, 173 y 1143, de manera que
     ‘make_polygon([171,173,1143])’ concatena los arrays
     ‘boundaries_array[171]’, ‘boundaries_array[173]’ y
     ‘boundaries_array[1143]’ y devuelve un objeto ‘polygon’ apto para
     ser dibujado por ‘draw’.  A fin de evitar mensajes de errores, los
     arrays deben ser compatibles en el sentido de que dos de ellos
     consecutivos deben tener dos coordenadas comunes en los extremos.
     En este ejemplo, las dos primeras componentes de
     ‘boundaries_array[171]’ son iguales a las dos últimas de
     ‘boundaries_array[173]’, y las dos primeras de
     ‘boundaries_array[173]’ coinciden con las dos primeras de
     ‘boundaries_array[1143]’; en conclusión, los números de segmentos
     poligonales171, 173 y 1143 (en este orden) son compatibles y el
     polígono coloreado se podrá dibujar.
          (%i1) load("worldmap")$
          (%i2) Bhutan;
          (%o2)                        [[171, 173, 1143]]
          (%i3) boundaries_array[171];
          (%o3) {Array:
                 #(88.750549 27.14727 88.806351 27.25305 88.901367 27.282221
                   88.917877 27.321039)}
          (%i4) boundaries_array[173];
          (%o4) {Array:
                 #(91.659554 27.76511 91.6008 27.66666 91.598022 27.62499
                   91.631348 27.536381 91.765533 27.45694 91.775253 27.4161
                   92.007751 27.471939 92.11441 27.28583 92.015259 27.168051
                   92.015533 27.08083 92.083313 27.02277 92.112183 26.920271
                   92.069977 26.86194 91.997192 26.85194 91.915253 26.893881
                   91.916924 26.85416 91.8358 26.863331 91.712479 26.799999
                   91.542191 26.80444 91.492188 26.87472 91.418854 26.873329
                   91.371353 26.800831 91.307457 26.778049 90.682457 26.77417
                   90.392197 26.903601 90.344131 26.894159 90.143044 26.75333
                   89.98996 26.73583 89.841919 26.70138 89.618301 26.72694
                   89.636093 26.771111 89.360786 26.859989 89.22081 26.81472
                   89.110237 26.829161 88.921631 26.98777 88.873016 26.95499
                   88.867737 27.080549 88.843307 27.108601 88.750549
                   27.14727)}
          (%i5) boundaries_array[1143];
          (%o5) {Array:
                 #(91.659554 27.76511 91.666924 27.88888 91.65831 27.94805
                   91.338028 28.05249 91.314972 28.096661 91.108856 27.971109
                   91.015808 27.97777 90.896927 28.05055 90.382462 28.07972
                   90.396088 28.23555 90.366074 28.257771 89.996353 28.32333
                   89.83165 28.24888 89.58609 28.139999 89.35997 27.87166
                   89.225517 27.795 89.125793 27.56749 88.971077 27.47361
                   88.917877 27.321039)}
          (%i6) Bhutan_polygon: make_polygon([171,173,1143])$
          (%i7) draw2d(Bhutan_polygon)$

 -- Función: region_boundaries (<x1>,<y1>,<x2>,<y2>)
     Detecta los segmentos poligonales almacenados en la variable global
     ‘boundaries_array’ totalmente contenidos en el rectángulo de
     vértices (<x1>,<y1>) -superior izquierdo- y (<x2>,<y2>) -inferior
     derecho-.

     Ejemplo:

     Devuelve los números de los segmentos necesarios para dibujar el
     sur de Italia.
          (%i1) load("worldmap")$
          (%i2) region_boundaries(10.4,41.5,20.7,35.4);
          (%o2)                [1846, 1863, 1864, 1881, 1888, 1894]
          (%i3) draw2d(geomap(%))$

 -- Función: region_boundaries_plus (<x1>,<y1>,<x2>,<y2>)
     Detecta los segmentos poligonales almacenados en la variable global
     ‘boundaries_array’ con al menos un vértice dentro del rectángulo
     definido por los extremos (<x1>,<y1>) -superior izquierdo- y
     (<x2>,<y2>) -inferior derecho-.

     Ejemplo:

          (%i1) load("worldmap")$
          (%i2) region_boundaries_plus(10.4,41.5,20.7,35.4);
          (%o2) [1060, 1062, 1076, 1835, 1839, 1844, 1846, 1858,
                 1861, 1863, 1864, 1871, 1881, 1888, 1894, 1897]
          (%i3) draw2d(geomap(%))$

47.4.2 Objetos gráficos
-----------------------

 -- Objeto gráfico: geomap (<numlist>)
 -- Objeto gráfico: geomap (<numlist>,<3Dprojection>)
     Dibuja mapas cartográficos en 2D y 3D.

     2D

     Esta función trabaja junto con la variable global
     ‘boundaries_array’.

     El argumento <numlist> es una lista de números o de listas de
     números.  Todos estos números deben ser enteros mayores o iguales
     que cero, representando las componentes del array global
     ‘boundaries_array’.

     Cada componente de ‘boundaries_array’ es un array de decimales en
     coma flotante, las coordenadas de un segmento poligonal o línea
     fronteriza.

     ‘geomap (<numlist>)’ toma los enteros de sus argumentos y dibuja
     los segmentos poligonales asociados de ‘boundaries_array’.

     Este objeto se ve afectado por las siguientes opciones gráficas:
     ‘line_width’, ‘line_type’ y ‘color’.

     Ejemplos:

     Un sencillo mapa hecho a mano:
          (%i1) load("worldmap")$
          (%i2) /* Vertices of boundary #0: {(1,1),(2,5),(4,3)} */
             ( bnd0: make_array(flonum,6),
               bnd0[0]:1.0, bnd0[1]:1.0, bnd0[2]:2.0,
               bnd0[3]:5.0, bnd0[4]:4.0, bnd0[5]:3.0 )$
          (%i3) /* Vertices of boundary #1: {(4,3),(5,4),(6,4),(5,1)} */
             ( bnd1: make_array(flonum,8),
               bnd1[0]:4.0, bnd1[1]:3.0, bnd1[2]:5.0, bnd1[3]:4.0,
               bnd1[4]:6.0, bnd1[5]:4.0, bnd1[6]:5.0, bnd1[7]:1.0)$
          (%i4) /* Vertices of boundary #2: {(5,1), (3,0), (1,1)} */
             ( bnd2: make_array(flonum,6),
               bnd2[0]:5.0, bnd2[1]:1.0, bnd2[2]:3.0,
               bnd2[3]:0.0, bnd2[4]:1.0, bnd2[5]:1.0 )$
          (%i5) /* Vertices of boundary #3: {(1,1), (4,3)} */
             ( bnd3: make_array(flonum,4),
               bnd3[0]:1.0, bnd3[1]:1.0, bnd3[2]:4.0, bnd3[3]:3.0)$
          (%i6) /* Vertices of boundary #4: {(4,3), (5,1)} */
             ( bnd4: make_array(flonum,4),
               bnd4[0]:4.0, bnd4[1]:3.0, bnd4[2]:5.0, bnd4[3]:1.0)$
          (%i7) /* Pack all together in boundaries_array */
             ( boundaries_array: make_array(any,5),
               boundaries_array[0]: bnd0, boundaries_array[1]: bnd1,
               boundaries_array[2]: bnd2, boundaries_array[3]: bnd3,
               boundaries_array[4]: bnd4 )$
          (%i8) draw2d(geomap([0,1,2,3,4]))$

     El paquete auxiliar ‘worldmap’ asigna al array global
     ‘boundaries_array’ líneas fronterizas reales en coordenadas
     (longitud, latitud).  Estos datos son de dominio público y proceden
     de <http://www-cger.nies.go.jp/grid-e/gridtxt/grid19.html>.  El
     paquete ‘worldmap’ también define fronteras de países, continentes
     y líneas costeras a partir de las componentes de ‘boundaries_array’
     (véase el fichero ‘share/draw/worldmap.mac’ para más información).
     El paquete ‘worldmap’ carga automáticamente el paquete ‘draw’.
          (%i1) load("worldmap")$
          (%i2) c1: gr2d(geomap([Canada,United_States,
                                 Mexico,Cuba]))$
          (%i3) c2: gr2d(geomap(Africa))$
          (%i4) c3: gr2d(geomap([Oceania,China,Japan]))$
          (%i5) c4: gr2d(geomap([France,Portugal,Spain,
                                 Morocco,Western_Sahara]))$
          (%i6) draw(columns  = 2,
                     c1,c2,c3,c4)$

     ‘worldmap’ se puede utilizar para dibujar países como polígonos.
     En este caso, ya no será necesario hacer uso del objeto gráfico
     ‘geomap’, pero sí de ‘polygon’.  Puesto que en este caso se
     utilizan listas en lugar de arrays, los mapas se reproducirán de
     forma más lenta.  Véanse también ‘make_poly_country’ y
     ‘make_poly_continent’ para comprender el siguiente código.
          (%i1) load("worldmap")$
          (%i2) mymap: append(
             [color      = white],  /* borders are white */
             [fill_color = red],             make_poly_country(Bolivia),
             [fill_color = cyan],            make_poly_country(Paraguay),
             [fill_color = green],           make_poly_country(Colombia),
             [fill_color = blue],            make_poly_country(Chile),
             [fill_color = "#23ab0f"],       make_poly_country(Brazil),
             [fill_color = goldenrod],       make_poly_country(Argentina),
             [fill_color = "midnight-blue"], make_poly_country(Uruguay))$
          (%i3) apply(draw2d, mymap)$

     3D

     ‘geomap (<numlist>)’ proyecta los mapas sobre la esfera de radio 1
     y centro (0,0,0).  Es posible cambiar la esfera o el tipo de
     proyección haciendo uso de ‘geomap (<numlist>,<3Dprojection>)’.

     Proyecciones 3D disponibles:

        • ‘[spherical_projection,<x>,<y>,<z>,<r>]’: proyecta los mapas
          sobre la esfera de radio <r> y centro (<x>,<y>,<z>).
               (%i1) load("worldmap")$
               (%i2) draw3d(geomap(Australia), /* default projection */
                            geomap(Australia,
                                   [spherical_projection,2,2,2,3]))$

        • ‘[cylindrical_projection,<x>,<y>,<z>,<r>,<rc>]’: re-proyecta
          mapas esféricos sobre el cilindro de radio <rc> cuyo eje pasa
          a través de los polos del globo de radio <r> y centro
          (<x>,<y>,<z>).
               (%i1) load("worldmap")$
               (%i2) draw3d(geomap([America_coastlines,Eurasia_coastlines],
                                   [cylindrical_projection,2,2,2,3,4]))$

        • ‘[conic_projection,<x>,<y>,<z>,<r>,<alpha>]’: re-proyecta
          mapas esféricos sobre los conos de ángulo <alpha>, cuyos ejes
          pasan a través de los polos del globo de radio <r> y centro
          (<x>,<y>,<z>).  Ambos conos, norte y sur, son tangentes a la
          esfera.
               (%i1) load("worldmap")$
               (%i2) draw3d(geomap(World_coastlines,
                                   [conic_projection,0,0,0,1,90]))$

     En <https://riotorto.users.sourceforge.net/Maxima/gnuplot/geomap/>
     hay ejemplos más elaborados.


File: maxima.info,  Node: drawdf,  Next: dynamics,  Prev: draw,  Up: Top

48 drawdf
*********

* Menu:

* Introducción a drawdf::
* Funciones y variables para drawdf::


File: maxima.info,  Node: Introducción a drawdf,  Next: Funciones y variables para drawdf,  Prev: drawdf,  Up: drawdf

48.1 Introducción a drawdf
==========================

La función ‘drawdf’ dibuja el campo de direcciones de una ecuación
diferencial ordinaria de primer orden (EDO) o de un sistema de dos
ecuaciones autónomas de primer orden.

Puesto que ‘drawdf’ es un paquete adicional, es necesario cargarlo en
memoria ejecutando previamente la instrucción ‘load("drawdf")’.
‘drawdf’ utiliza el paquete ‘draw’, que necesita como mínimo la versión
4.2 de Gnuplot.

Para dibujar el campo de direcciones de una EDO, ésta debe escribirse de
la forma
            dy
            -- = F(x,y)
            dx

y ser la función <F> la que se pase a ‘drawdf’ como argumento.  Si las
variables independiente y dependiente no son <x> e <y>, como en la
ecuación anterior, entonces deben nombrarse de forma explícita en una
lista que se pasará a ‘drawdf’ (ver ejemplos más abajo).

Para dibujar el campo de direcciones de un conjunto de dos EDOs
autónomas, deben escribirse de la forma
            dx             dy
            -- = G(x,y)    -- = F(x,y)
            dt             dt

y será una lista con las dos funciones <G> y <F> la que se pase a
‘drawdf’ como argumento.  El orden de las funciones es importante; la
primera será la derivada de la abscisa respecto del tiempo y la segunda
la derivada de la ordenada respecto del tiempo.  Si las variables no son
las <x> e <y> habituales, el segundo argumento que se pase a la función
‘drawdf’ será una lista con los nombres de ambas variables, primero la
correspondiente a las abscisas, seguida de la asociada a las ordenadas.

Si sólo se trata de una EDO, ‘drawdf’ admitirá por defecto que ‘x=t’ y
‘G(x,y)=1’, transformanado la ecuación no autónoma en un sistema de dos
ecuaciones autónomas.


File: maxima.info,  Node: Funciones y variables para drawdf,  Prev: Introducción a drawdf,  Up: drawdf

48.2 Funciones y variables para drawdf
======================================

48.2.1 Funciones
----------------

 -- Función: drawdf (<dydx>, ...options and objects...)
 -- Función: drawdf (<dvdu>, ‘[’<u>,<v>‘]’, ...opciones y objetos...)
 -- Función: drawdf (<dvdu>, ‘[’<u>,<umin>,<umax>‘]’,
          ‘[’<v>,<vmin>,<vmax>‘]’, ...opciones y objetos...)
 -- Función: drawdf (‘[’<dxdt>,<dydt>‘]’, ...opciones y objetos...)
 -- Función: drawdf (‘[’<dudt>,<dvdt>‘]’, ‘[’<u>,<v>‘]’, ...opciones y
          objetos...)
 -- Función: drawdf (‘[’<dudt>,<dvdt>‘]’, ‘[’<u>,<umin>,<umax>‘]’,
          ‘[’<v>,<vmin>,<vmax>‘]’, ...opciones y objetos...)

     La función ‘drawdf’ dibuja un campo de direcciones 2D, incluyendo
     opcionalmente curvas asociadas a soluciones particulares, así como
     otros objeto gráficos del paquete ‘draw’.

     El primer argumento especifica la(s) derivada(s), el cual debe
     estar formado por una expresión o una lista de dos expresiones.
     <dydx>, <dxdt> y <dydt> son expresiones que dependen de <x> y <y>.
     <dvdu>, <dudt> y <dvdt> son expresiones que dependen de <u> y <v>.

     Si las variables independiente y dependiente no son <x> e <y>, sus
     nombres deben especificarse a continuación de las derivadas, bien
     como una lista de dos nombres, ‘[’<u>,<v>‘]’, o como dos listas de
     la forma ‘[’<u>,<umin>,<umax>‘]’ y ‘[’<v>,<vmin>,<vmax>‘]’.

     El resto de argumentos son opciones gráficas, objetos gráficos, o
     listas conteniendo elementos de ambos tipos.  El conjunto de
     opciones y objetos gráficos soportados por ‘drawdf’ incluye los
     soportados por ‘draw2d’ y ‘gr2d’ del paquete ‘draw’.

     Los argumentos se iterpretan secuencialmente: las opciones gráficas
     afectan a todos los objetos gráficos que le siguen.  Además, los
     objetos gráficos se dibujan en el orden en el que se especifican,
     pudiendo tapar otros gráficos dibujados con anterioridad.  Algunas
     opciones gráficas afectan al aspecto general de la escena.

     Los nuevos objetos gráficos que se definen en ‘drawdf’ son:
     ‘solns_at’, ‘points_at’, ‘saddles_at’, ‘soln_at’, ‘point_at’ y
     ‘saddle_at’.

     Las nuevas opciones gráficas que se definen en ‘drawdf’ son:
     ‘field_degree’, ‘soln_arrows’, ‘field_arrows’, ‘field_grid’,
     ‘field_color’, ‘show_field’, ‘tstep’, ‘nsteps’, ‘duration’,
     ‘direction’, ‘field_tstep’, ‘field_nsteps’ y ‘field_duration’.

     Objetos gráficos que se heredan del paquete ‘draw’ incluyen:
     ‘explicit’, ‘implicit’, ‘parametric’, ‘polygon’, ‘points’,
     ‘vector’, ‘label’ y cualesquiera otros soportados por ‘draw2d’ y
     ‘gr2d’.

     Opciones gráficas que se heredan del paquete ‘draw’ incluyen:
     ‘points_joined’, ‘color’, ‘point_type’, ‘point_size’, ‘line_width’,
     ‘line_type’, ‘key’, ‘title’, ‘xlabel’, ‘ylabel’, ‘user_preamble’,
     ‘terminal’, ‘dimensions’, ‘file_name’ y cualesquiera otros
     soportados por ‘draw2d’ y ‘gr2d’.

     Véase también ‘draw2d’.

     Los usuarios de wxMaxima y Imaxima pueden hacer uso también
     ‘wxdrawdf’, que es idéntica a ‘drawdf’, pero que inserta el gráfico
     en el propio documento utilizando la función ‘wxdraw’.

     Para hacer uso de esta función, ejecútese primero ‘load("drawdf")’.

     Ejemplos:

          (%i1) load("drawdf")$
          (%i2) drawdf(exp(-x)+y)$        /* default vars: x,y */
          (%i3) drawdf(exp(-t)+y, [t,y])$ /* default range: [-10,10] */
          (%i4) drawdf([y,-9*sin(x)-y/5], [x,1,5], [y,-2,2])$

     A efectos de compatibilidad, ‘drawdf’ acepta la mayor parte de
     parámetros soportados por ‘plotdf’.

          (%i5) drawdf(2*cos(t)-1+y, [t,y], [t,-5,10], [y,-4,9],
                       [trajectory_at,0,0])$

     ‘soln_at’ y ‘solns_at’ dibujan soluciones particulares que pasen
     por los puntos especificados, utilizando el integrador numérico de
     Runge Kutta de cuarto orden.

          (%i6) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                       solns_at([0,0.1],[0,-0.1]),
                       color=blue, soln_at(0,0))$

     ‘field_degree=2’ hace que el campo se componga de splines
     cuadráticos basados en las derivadas de primer y segundo orden en
     cada punto de la malla.  ‘field_grid=[’<COLS>,<ROWS>‘]’ especifica
     el número de columnas y filas a utilizar en la malla.

          (%i7) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                       field_degree=2, field_grid=[20,15],
                       solns_at([0,0.1],[0,-0.1]),
                       color=blue, soln_at(0,0))$

     ‘soln_arrows=true’ añade flechas a las soluciones particulares y,
     por defecto, las borra.  También cambia los colores por defecto
     para destacar las curvas de las soluciones particulares.

          (%i8) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                       soln_arrows=true,
                       solns_at([0,0.1],[0,-0.1],[0,0]))$

     ‘duration=40’ especifica el intervalo temporal de la integración
     numérica, cuyo valor por defecto es 10.  La integración se detendrá
     automáticamente si la solución se aparta mucho de la región a
     dibujar, o si la derivada se vuelve compleja o infinita.  Aquí
     también hacemos ‘field_degree=2’ para dibujar splines cuadráticos.
     Las ecuaciones de este ejemplo modelizan un sistema
     depredador-presa.

          (%i9) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
                       field_degree=2, duration=40,
                       soln_arrows=true, point_at(1/2,1/2),
                       solns_at([0.1,0.2], [0.2,0.1], [1,0.8], [0.8,1],
                                [0.1,0.1], [0.6,0.05], [0.05,0.4],
                                [1,0.01], [0.01,0.75]))$

     ‘field_degree='solns’ hace que el campo se componga de muchas
     pequeñas soluciones calculadas a partir del Runge Kutta de cuarto
     orden.

          (%i10) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
                        field_degree='solns, duration=40,
                        soln_arrows=true, point_at(1/2,1/2),
                        solns_at([0.1,0.2], [0.2,0.1], [1,0.8],
                                 [0.8,1], [0.1,0.1], [0.6,0.05],
                                 [0.05,0.4], [1,0.01], [0.01,0.75]))$

     ‘saddles_at’ trata de linearizar automáticamente la ecuación en
     cada punto de silla y dibujar la solución numérica correspondiente
     a cada vector propio, incluyendo las separatrices.  ‘tstep=0.05’
     establece el salto temporal máximo para el integrador numérico,
     cuyo valor por defecto es 0.1.  Las siguientes ecuaciones modelizan
     un péndulo amortiguado.

          (%i11) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
                        soln_arrows=true, point_size=0.5,
                        points_at([0,0], [2*%pi,0], [-2*%pi,0]),
                        field_degree='solns,
                        saddles_at([%pi,0], [-%pi,0]))$

     ‘show_field=false’ elimina el campo completamente.

          (%i12) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
                        show_field=false, soln_arrows=true,
                        point_size=0.5,
                        points_at([0,0], [2*%pi,0], [-2*%pi,0]),
                        saddles_at([3*%pi,0], [-3*%pi,0],
                                   [%pi,0], [-%pi,0]))$

     ‘drawdf’ pasa todos los parámetros que no reconoce a ‘draw2d’ o
     ‘gr2d’, permitiendo combinar la potencia del paquete ‘draw’ con
     ‘drawdf’.

          (%i13) drawdf(x^2+y^2, [x,-2,2], [y,-2,2], field_color=gray,
                        key="soln 1", color=black, soln_at(0,0),
                        key="soln 2", color=red, soln_at(0,1),
                        key="isocline", color=green, line_width=2,
                        nticks=100, parametric(cos(t),sin(t),t,0,2*%pi))$

     ‘drawdf’ acepta listas anidadas de opciones y objetos gráficos,
     permitiendo el uso de ‘makelist’ y otras funciones de forma más
     flexible para generar gráficos.

          (%i14) colors : ['red,'blue,'purple,'orange,'green]$
          (%i15) drawdf([x-x*y/2, (x*y - 3*y)/4],
                        [x,2.5,3.5], [y,1.5,2.5],
                        field_color = gray,
                        makelist([ key   = concat("soln",k),
                                   color = colors[k],
                                   soln_at(3, 2 + k/20) ],
                                 k,1,5))$


File: maxima.info,  Node: dynamics,  Next: ezunits,  Prev: drawdf,  Up: Top

49 dynamics
***********

* Menu:

* El paquete dynamics::
* Análisis gráfico de sistemas dinámicos discretos::
* Visualización usando VTK::


File: maxima.info,  Node: El paquete dynamics,  Next: Análisis gráfico de sistemas dinámicos discretos,  Prev: dynamics,  Up: dynamics

49.1 El paquete dynamics
========================

El paquete adicional ‘dynamics’ incluye funciones para visualización 3D,
animaciones, análisis gráfico de ecuaciones diferenciales y ecuaciones
de diferencias y para resolución numérica de ecuaciones diferenciales.
Las funciones para ecuaciones diferenciales se describen en la sección
sobre ‘Métodos numéricos’ y las funciones para representar las gráficas
de los conjuntos de Mandelbrot y de Julia se describen en la sección
sobre ‘Gráficos’.

Todas las funciones en este paquete se cargan automáticamente la primera
vez que se usan.


File: maxima.info,  Node: Análisis gráfico de sistemas dinámicos discretos,  Next: Visualización usando VTK,  Prev: El paquete dynamics,  Up: dynamics

49.2 Análisis gráfico de sistemas dinámicos discretos
=====================================================

 -- Función: chaosgame ([[<x1>, <y1>]...[<xm>, <ym>]], [<x0>, <y0>],
          <b>, <n>, <opciones>, ...);

     Usa el método llamado juego del caos, para producir fractales: se
     dibuja un punto inicial (<x0>, <y0>) y luego se elije
     aleatoriamente uno de los <m> puntos ‘[’<x1>, <y1>‘]’...‘[’<xm>,
     <ym>‘]’.  Después se dibuja un nuevo punto que estará en el
     segmento entre el último punto dibujado y el punto que se acabó de
     elegir aleatoriamente, a una distancia del punto elegido que será
     <b> veces la longitud del segmento.  El proceso se repite <n>
     veces.  Este programa acepta las mismas opciones de ‘plot2d’.

     *Ejemplo*.  Gráfico del triángulo de Sierpinsky:

          (%i1) chaosgame([[0, 0], [1, 0], [0.5, sqrt(3)/2]], [0.1, 0.1], 1/2,
                           30000, [style, dots]);

 -- Función: evolution evolution (<F>, <y0>, <n>, ..., <opciones>, ...);

     Dibuja <n+1> puntos en una gráfica bidimensional (serie de tiempo),
     en que las coordenadas horizontales de los puntos son los números
     enteros 0, 1, 2, ..., <n>, y las coordenadas verticales son los
     valores <y(n)> correspondientes, obtenidos a partir de la relación
     de recurrencia
                  y(n+1) = F(y(n))

     Con valor inicial <y(0)> igual a <y0>.  <F> deberá ser una
     expresión que dependa únicamente de la variable <y> (y no de <n>),
     <y0> deberá ser un número real y <n> un número entero positivo.
     Esta función acepta las mismas opciones que ‘plot2d’.

     *Ejemplo*.

          (%i1) evolution(cos(y), 2, 11);

 -- Función: evolution2d ([<F>, <G>], [<u>, <v>], [<u0>, <y0>], <n>,
          <opciones>, ...);

     Muestra, en una gráfica bidimensional, los primeros <n+1> puntos de
     la sucesión definida a partir del sistema dinámico discreto con
     relaciones de recurrencia:
                  x(n+1) = F(x(n), y(n))    y(n+1) = G(x(n), y(n))

     Con valores iniciales <x0> y <y0>.  <F> y <G> deben ser dos
     expresiones que dependan únicamente de <x> y <y>.  Esta función
     acepta las mismas opciones que ‘plot2d’.

     *Ejemplo*.  Evolución de un sistema dinámico discreto en dos
     dimensiones:

          (%i1) f: 0.6*x*(1+2*x)+0.8*y*(x-1)-y^2-0.9$
          (%i2) g: 0.1*x*(1-6*x+4*y)+0.1*y*(1+9*y)-0.4$
          (%i3) evolution2d([f,g], [x,y], [-0.5,0], 50000, [style,dots]);

     Y un acercamiento de una pequeña región en ese fractal:

          (%i9) evolution2d([f,g], [x,y], [-0.5,0], 300000, [x,-0.8,-0.6],
                            [y,-0.4,-0.2], [style, dots]);

 -- Función: ifs ([<r1>, ..., <rm>], [<A1>,..., <Am>], [[<x1>, <y1>],
          ..., [<xm>, <ym>]], [<x0>, <y0>], <n>, <opciones>, ...);

     Usa el método del Sistema de Funciones Iteradas (IFS, en inglés
     Iterated Function System).  Ese método es semejante al método
     descrito en la función ‘chaosgame’.  pero en vez de aproximar el
     último punto al punto elegido aleatoriamente, las dos coordenadas
     del último punto se multiplican por una matriz 2 por 2 <Ai>
     correspondiente al punto que fue elegido aleatoriamente.

     La selección aleatoria de uno de los <m> puntos atractivos puede
     ser realizada con una función de probabilidad no uniforme, definida
     con los pesos <r1>,...,<rm>.  Esos pesos deben ser dados en forma
     acumulada; por ejemplo, si se quieren 3 puntos con probabilidades
     0.2, 0.5 y 0.3, los pesos <r1>, <r2> y <r3> podrían ser 2, 7 y 10,
     o cualquier otro grupo de números que tengan la misma proporción.
     Esta función acepta las mismas opciones que ‘plot2d’.

     *Ejemplo*.  El helecho de Barnsley, creado con 4 matrices y 4
     puntos:

          (%i1) a1: matrix([0.85,0.04],[-0.04,0.85])$
          (%i2) a2: matrix([0.2,-0.26],[0.23,0.22])$
          (%i3) a3: matrix([-0.15,0.28],[0.26,0.24])$
          (%i4) a4: matrix([0,0],[0,0.16])$
          (%i5) p1: [0,1.6]$
          (%i6) p2: [0,1.6]$
          (%i7) p3: [0,0.44]$
          (%i8) p4: [0,0]$
          (%i9) w: [85,92,99,100]$
          (%i10) ifs(w, [a1,a2,a3,a4], [p1,p2,p3,p4], [5,0], 50000, [style,dots]);

 -- Función: orbits (<F>, <y0>, <n1>, <n2>, [<x>, <x0>, <xf>, <xstep>],
          <opciones>, ...);

     Dibuja el diagrama de órbitas de una familia de sistemas dinámicos
     discretos unidimensionales, con un parámetro <x>; ese tipo de
     diagrama se usa para mostrar las bifurcaciones de un sistema
     discreto unidimensional.

     La función <F(y)> define una secuencia que comienza con un valor
     inicial <y0>, igual que en el caso de la función ‘evolution’, pero
     en este caso la función también dependerá del parámetro <x>, el
     cual tomará valores comprendidos en el intervalo de <x0> a <xf>,
     con incrementos <xstep>.  Cada valor usado para el parámetro <x> se
     muestra en el eje horizontal.  En el eje vertical se mostrarán <n2>
     valores de la sucesión <y(n1+1)>,..., <y(n1+n2+1)>, obtenidos
     después de dejarla evolucionar durante <n1> iteraciones iniciales.

     *Ejemplo*.  Diagrama de órbitas para el mapa cuadrático

          (%i1) orbits(x^2+a, 0, 50, 200, [a, -2, 0.25], [style, dots]);

     Para ampliar la región alrededor de la bifurcación en la parte de
     abajo, cerca de x ‘=’ -1.25, se usa el comando:
          (%i2) orbits(x^2+a, 0, 100, 400, [a,-1,-1.53], [x,-1.6,-0.8],
                       [nticks, 400], [style,dots]);

 -- Función: staircase (<F>, <y0>, <n>,<opciones>,...);

     Dibuja un diagrama de escalera (o diagrama de red) para la sucesión
     definida por la ecuación de recurrencia
                  y(n+1) = F(y(n))

     La interpretación y valores permitidos de los parámetros de entrada
     es la misma que para la función ‘evolution’.  Un diagrama de
     escalera consiste en una gráfica de la función <F(y)>, junto con la
     recta <G(y)> ‘=’ <y>.  Se comienza por dibujar un segmento vertical
     desde el punto (<y0>, <y0>) en la recta, hasta el punto de
     intersección con la función <F>.  En seguida, desde ese punto se
     dibuja un segmento horizontal hasta el punto de intersección con la
     recta, (<y1>, <y1>); el procedimiento se repite <n> veces hasta
     alcanzar el punto (<yn>, <yn>).  Esta función acepta las mismas
     opciones que ‘plot2d’.

     *Ejemplo*.

          (%i1) staircase(cos(y), 1, 11, [y, 0, 1.2]);


File: maxima.info,  Node: Visualización usando VTK,  Prev: Análisis gráfico de sistemas dinámicos discretos,  Up: dynamics

49.3 Visualización usando VTK
=============================

La función scene crea imágenes tridimensionales y animaciones usando el
software _Visualization ToolKit_ (VTK). Para poder usar esa función es
necesario tener Xmaxima y VTK instalados en el sistema (incluyendo la
biblioteca para usar VTK desde TCL que en algunos sistemas viene en un
paquete separado).

 -- Función: scene (<objetos>, ..., <opciones>, ...);

     Acepta una lista vacía o una lista de varios ‘objetos’ y
     ‘opciones’.  El programa ejecuta Xmaxima, que abre una ventana
     donde se representan los objetos dados, en un espacio
     tridimensional y aplicando las opciones dadas.  Cada objeto debe
     pertenecer una de las 4 clases: sphere, cube, cylinder o cone (ver
     ‘Objetos de scene’).  Los objetos se identifican dando el nombre de
     su clase, o una lista en que el primer elemento es el nombre de la
     clase y los restantes elementos son opciones para ese objeto.

     *Ejemplo*.  Una pirámide hexagonal con fondo azul:
          (%i1) scene(cone, [background,"#9980e5"])$

     Presionando el botón izquierdo del ratón mientras se mueve dentro
     de la ventana gráfica, se puede rotar la cámara, mostrando
     diferentes vistas de la pirámide.  Las dos opciones ‘elevation’ y
     ‘azimuth’ se pueden usar también para cambiar la orientación de la
     cámara.  La cámara se puede mover presionando el botón del medio y
     moviendo el ratón y el botón del lado derecho se usa para aumentar
     o disminuir el zoom, moviendo el ratón para arriba y para bajo.

     Cada opción de un objeto deberá ser una lista comenzando con el
     nombre de la opción, seguido por su valor.  La lista de posibles
     opciones se encuentra en la sección ‘Opciones de objetos de scene’.

     *Ejemplo*.  Este ejemplo mostrará una esfera cayendo para el piso y
     rebotando sin perder energía.  Para comenzar o poner en pausa la
     animación se debe oprimir el botón de play/pausa.

          (%i1) p: makelist ([0,0,2.1- 9.8*t^2/2], t, 0, 0.64, 0.01)$

          (%i2) p: append (p, reverse(p))$

          (%i3) bola: [sphere, [radius,0.1], [thetaresolution,20],
            [phiresolution,20], [position,0,0,2.1], [color,red],
            [animate,position,p]]$

          (%i4) piso: [cube, [xlength,2], [ylength,2], [zlength,0.2],
            [position,0,0,-0.1],[color,violet]]$

          (%i5) scene (bola, piso, restart)$

     La opción <restart> fue usada para hacer que la animación
     recomienze cada vez que se llega al último punto en la lista.  Los
     valores permitidos para los colores son los mismo que para la
     opción ‘color’ de plot2d.

49.3.1 Opciones de scene
------------------------

 -- Opción de scene: azimuth [azimuth, <ángulo>]
     Valor predefinido: ‘135’

     La rotación de la cámara en el plano horizontal (x, y).  <ángulo>
     debe ser un número real; un ángulo de 0 significa que la cámara
     apunta en la dirección del eje y, haciendo que el eje x aparezca a
     la derecha.

 -- Opción de scene: background [background, <color>]
     Valor predefinido: ‘black’

     El color del fondo de la ventana gráfica.  Acepta nombres de
     colores o secuencias de caracteres hexadecimales para
     rojo-verde-azul (ver la opción ‘color’ de plot2d).

 -- Opción de scene: elevation [elevation, <ángulo>]
     Valor predefinido: ‘30’

     La rotación vertical de la cámara.  El <ángulo> debe ser un número
     real; un ángulo de 0 significa que la cámara apunta en la
     horizontal y el valor predefinido de 30 significa que la cámara
     apunta 30 grados para abajo de la horizontal.

 -- Opción de scene: height [height, <pixels>]
     Valor predefinido: ‘500’

     La altura, en pixels, de la ventana gráfica.  <pixels> debe ser un
     número entero positivo.

 -- Opción de scene: restart [restart, <valor>]
     Valor predefinido: ‘false’

     Un valor ’true’ significa que la animación recomenzará
     automáticamente cuando llegue al final.  Escribir simplemente
     “restart” es equivalente a escribir [restart, <true>].

 -- Opción de scene: tstep [tstep, <tiempo>]
     Valor predefinido: ‘10’

     El intervalo de tiempo, en milisegundos, entre iteraciones
     consecutivas de las partes de una animación.  <tiempo> debe ser un
     número real.

 -- Opción de scene: width [width, <pixels>]
     Valor predefinido: ‘500’

     El ancho, en pixels, de la ventana gráfica.  <pixels> deberá ser un
     número entero positivo.

 -- Opción de scene: windowname [windowtitle, <nombre>]
     Valor predefinido: ‘.scene’

     <nombre> deberá ser una secuencia de caracteres que pueda ser usada
     para el nombre de una ventana de Tk, creada por Xmaxima para los
     gráficos de ‘scene’.  El valor predefinido ‘.scene’ implica que
     será creada una nueva ventana.

 -- Opción de scene: windowtitle [windowtitle, <nombre>]
     Valor predefinido: ‘Xmaxima: scene’

     <nombre> debe ser una secuencia de caracteres que serán escritos en
     el encabezado de la ventana creada por ‘scene’.

49.3.2 Objetos de scene
-----------------------

 -- Objeto de scene: cone [cone, <opciones>]

     Crea una pirámide regular con altura 1 unidad y base hexagonal con
     vértices a 0.5 unidades del eje.  Las opciones ‘height’ y ‘radius’
     se pueden usar para alterar esos valores predefinidos y la opción
     ‘resolution’ se usa para alterar el número de aristas de la base;
     valores mayores harán que la pirámide parezca un cono.  Por
     omisión, el eje estará a lo largo del eje x, el punto medio de la
     altura estará en el origen y el vértice en el lado positivo del eje
     x; las opciones ‘orientation’ y ‘center’ permiten alterar eso.

     *Ejemplo*.  El siguiente comando muestra una pirámide que comienza
     a dar vueltas cuando se oprime el botón de animación.

          (%i1) scene([cone, [orientation,0,30,0], [tstep,100],
             [animate,orientation,makelist([0,30,i],i,5,360,5)]], restart)$

 -- Objeto de scene: cube [cube, <opciones>]

     Un cubo con aristas de 1 unidad y caras paralelas al los planos xy,
     xz y yz.  Las longitudes de las 3 aristas se pueden modificar con
     las opciones ‘xlength’, ‘ylength’ y ‘zlength’, convirtiéndolo en un
     paralelepípedo y las caras se pueden hacer rotar con la opción
     ‘orientation’.

 -- Objeto de scene: cylinder [cylinder, <opciones>]

     Crea un prisma regular con altura de 1 unidad y base hexagonal con
     los vértices a 0.5 unidades del eje.  Las opciones ‘height’ y
     ‘radius’ permiten modificar esos valores predefinidos y la opción
     ‘resolution’ se puede usar para modificar el número de aristas de
     la base; valores mayores tornan el prisma más parecido a un
     cilindro.  La altura predefinida se puede alterar con la opción
     ‘height’.  Por omisión el eje estará orientado a lo largo del eje
     x, y el punto medio de la altura estará en el origen; se pueden
     cambiar esas propiedades con las opciones ‘orientation’ y ‘center’.

 -- Objeto de scene: sphere [sphere, <opciones>]

     Una esfera de radio igual a 0.5 unidades y centro en el origen.

49.3.3 Opciones de objetos de scene
-----------------------------------

 -- Opción de objeto: animation [animation, <propiedad>, <posiciones>]

     <propiedad> deberá ser una de las 4 siguientes propiedades del
     objeto: ‘origin’, ‘scale’, ‘position’ o ‘orientation’ y
     <posiciones> deberá ser una lista de puntos.  Cuando se oprime el
     botón “play”, esa propiedad tomará sucesivamente los valores en la
     lista, en intervalos regulares de tiempo definidos por la opción
     ‘tstep’.  El botón de volver al comienzo puede usarse para
     recomenzar desde el principio de la lista, haciendo que la
     animación comience nuevamente cuando se presione otra vez el botón
     de play.

     Consulte también ‘track’.

 -- Opción de objeto: capping [capping, <número>]
     Valor predefinido: ‘1’

     En un objeto “cone” o “cylinder”, determina si la base (o bases) se
     muestran o no.  Un valor de 1 para <número> torna la base visible y
     un valor de 0 la hace invisible.

 -- Opción de objeto: center [center, <punto>]
     Valor predefinido: ‘[0, 0, 0]’

     Coordenadas del centro geométrico del objeto, en relación a su
     posición (‘position’); <punto> puede ser una lista de 3 números
     reales o 3 números separados por comas.  En objetos de clase
     “cylinder”,”cone” o “cube” estará localizado en el punto medio de
     la altura y en objetos de clase “sphere” estará en su centro.

 -- Opción de objeto: color [color, <nombre>]
     Valor predefinido: ‘white’

     El color del objeto.  Acepta nombres de colores conocidos o
     secuencias de 6 dígitos (rojo-verde-azul) precedidos por # (ver la
     opción ‘color’ de plot2d).

 -- Opción de objeto: endphi [endphi, <ángulo>]
     Valor predefinido: ‘180’

     En una esfera, phi es el ángulo en el plano vertical que pasa por
     el eje z, medido a partir de la parte positiva del eje z.  <ángulo>
     debe ser un múmero entre 0 y 180 que determina el valor final de
     phi hasta donde se mostrará la superficie.  Valores menores que 180
     eliminan una parte de la superficie.

     Consulte también ‘startphi’ y ‘phiresolution’.

 -- Opción de objeto: endtheta [endtheta, <ángulo>]
     Valor predefinido: ‘360’

     En una esfera, theta es el ángulo en el plano horizontal
     (longitud), medido desde la parte positiva del eje x.  <ángulo>
     debe ser un número entre 0 y 360 que determina el valor final donde
     la superficie terminará.  Valores menores que 360 hacen que se
     elimine una parte de la superficie de la esfera.

     Consulte también ‘starttheta’ y ‘thetaresolution’.

 -- Opción de objeto: height [height, <valor>]
     Valor predefinido: ‘1’

     <valor> debe ser un número positivo que define la altura de un cono
     o cilindro.

 -- Opción de objeto: linewidth [linewidth, <valor>]
     Valor predefinido: ‘1’

     El ancho de las líneas cuando se usa la opción ‘wireframe’.
     <valor> debe ser un número positivo.

 -- Opción de objeto: opacity [opacity, <valor>]
     Valor predefinido: ‘1’

     <valor> debe se un número entre 0 y 1.  Cuanto menor sea el número,
     mas transparente será el objeto.  El valor predefinido de 1 implica
     un objeto completamente opaco.

 -- Opción de objeto: orientation [orientation, <ángulos>]
     Valor predefinido: ‘[0, 0, 0]’

     Tres ángulos que de rotaciones que serán realizadas en el objeto,
     alrededor de los tres ejes.<ángulos> puede ser una lista con tres
     números reales o tres números separados por comas.  *Ejemplo*: ‘[0,
     0, 90]’ rota el eje x del objeto hasta el eje y del sistema de
     referencia.

 -- Opción de objeto: origin [origin, <punto>]
     Valor predefinido: ‘[0, 0, 0]’

     Coordenadas del origen del objeto, en relación al cual las otras
     dimensiones serán definidas.  <punto> pueden ser tres números
     separados por comas, o una lista de tres números.

 -- Opción de objeto: phiresolution [phiresolution, <num>]
     Valor predefinido: ‘’

     Número de sub-intervalos en que se divide el intervalo de valores
     del ángulo phi, que comienza en ‘startphi’ y termina en ‘endphi’.
     <num> debe ser un número entero positivo.

     Consulte también ‘startphi’ y ‘endphi’.

 -- Opción de objeto: points [points]

     Esta opción hace que en vez de que se muestre la superficie, se
     muestren únicamente los vértices en la triangulación usada para
     construir la superficie.  *Ejemplo*: ‘[sphere, [points]]’

     Consulte también ‘surface’ y ‘wireframe’.

 -- Opción de objeto: pointsize [pointsize, <valor>]
     Valor predefinido: ‘1’

     Tamaño de los puntos, cuando se usa la opción ‘points’.  <valor>
     debe ser un número positivo.

 -- Opción de objeto: position [position, <punto>]
     Valor predefinido: ‘[0, 0, 0]’

     Coordenadas de la posición del objeto.  <punto> puede ser tres
     números separados por comas o una lista de tres números.

 -- Opción de objeto: radius [radius, <valor>]
     Valor predefinido: ‘0.5’

     El radio de una esfera o la distancia desde el eje hasta los
     vértices de la base en cilindros o conos.  <valor> debe ser un
     número positivo.

 -- Opción de objeto: resolution [resolution, <número>]
     Valor predefinido: ‘6’

     <número> debe ser un número entero mayor que 2, que define el
     número de aristas de la base en objetos de clase “cone” o
     “cylinder”.

 -- Opción de objeto: scale [scale, <factores>]
     Valor predefinido: ‘[1, 1, 1]’

     Tres factores de escala en que serán deformadas las dimensiones del
     objeto en relación a los tres ejes.  <factors> pueden ser tres
     número separados por comas o una lista con tres números.
     *Ejemplo*: ‘[2, 0.5, 1]’ estira el objeto suplicando sus
     dimensiones paralelas la eje x, reduce a mitad las dimensiones
     paralelas al eje y, dejando iguales las dimensiones paralelas al
     eje z.

 -- Opción de objeto: startphi [startphi, <ángulo>]
     Valor predefinido: ‘0’

     En una esfera, phi es el ángulo en el plano vertical que pasa por
     el eje z, medido a partir de la parte positiva del eje z.  <ángulo>
     debe ser un múmero entre 0 y 180 que determina el valor inicial de
     phi desde donde se mostrará la superficie.  Valores superiores a 0
     eliminan una parte de la superficie.

     Consulte también ‘endphi’ y ‘phiresolution’.

 -- Opción de objeto: starttheta [starttheta, <ángulo>]
     Valor predefinido: ‘0’

     En una esfera, theta es el ángulo en el plano horizontal
     (longitud), medido desde la parte positiva del eje x.  <ángulo>
     debe ser un número entre 0 y 360 que determina el valor inicial
     donde la superficie comienza.  Valores mayores que 0 hacen que se
     elimine una parte de la superficie de la esfera.

     Consulte también ‘endtheta’ y ‘thetaresolution’.

 -- Opción de objeto: surface [surface]

     Hace que se muestre la superficie del objeto y no los las líneas ni
     los vértices de la triangulación usada para construirlo.  Ese es el
     comportamiento habitual que se puede alterar con las opciones
     ‘points’ o ‘wireframe’.

 -- Opción de objeto: thetaresolution [thetaresolution, <num>]
     Valor predefinido: ‘’

     Número de sub-intervalos en que se divide el intervalo de valores
     del ángulo theta, que comienza en ‘starttheta’ y termina en
     ‘endtheta’.  <num> debe ser un número entero positivo.  Consulte
     también ‘starttheta’ y ‘endtheta’.

 -- Opción de objeto: track [track, <posiciones>]

     <posiciones> deberá ser una lista de puntos.  Cuando se oprime el
     botón de “play”, la posición del objeto tomara secuencialmente los
     valores en la lista, a intervalos regulares de tiempo definidos por
     la opción ‘tstep’, dejando un rastro de la trayectoria del objeto.
     El botón de volver al comienzo puede usarse para recomenzar desde
     el principio de la lista, haciendo que la animación comience
     nuevamente cuando se presione otra vez el botón de play.

     *Ejemplo*.  Estos comandos muestran la trayectoria de una bola
     lanzada con velocidad inicial de 5 m/s, a un ángulo de 45 grados,
     cuando se puede ignorar la resistencia del aire:

          (%i1) p: makelist ([0,4*t,4*t- 9.8*t^2/2], t, 0, 0.82, 0.01)$

          (%i2) bola: [sphere, [radius,0.1], [color,red], [track,p]]$

          (%i3) piso: [cube, [xlength,2], [ylength,4], [zlength,0.2],
                [position,0,1.5,-0.2],[color,green]]$

          (%i4) scene (bola, piso)$

     Consulte también ‘animation’.

 -- Opción de objeto: xlength [xlength, <altura>]
     Valor predefinido: ‘1’

     Altura de un objeto de clase “cube”, en la dirección x.  <altura>
     debe ser un número positivo.  Consulte también ‘ylength’ y
     ‘zlength’.

 -- Opción de objeto: ylength [ylength, <altura>]
     Valor predefinido: ‘1’

     Altura de un objeto de clase “cube”, en la dirección y.  <altura>
     debe ser un número positivo.  Consulte también ‘xlength’ y
     ‘zlength’.

 -- Opción de objeto: zlength [zlength, <altura>]
     Valor predefinido: ‘1’

     Altura de un objeto de clase “cube”, en la dirección z.  <altura>
     debe ser un número positivo.  Consulte también ‘xlength’ y
     ‘ylength’.

 -- Opción de objeto: wireframe [wireframe]

     Esta opción hace que en vez de que se muestre la superficie, se
     muestren únicamente las aristas de la triangulación usada para
     construir la superficie.  *Ejemplo*: ‘[cube, [wireframe]]’

     Consulte también ‘surface’ y ‘points’.


File: maxima.info,  Node: ezunits,  Next: f90,  Prev: dynamics,  Up: Top

50 ezunits
**********

* Menu:

* Introducción a ezunits::
* Introducción a physical_constants::
* Funciones y variables para ezunits::


File: maxima.info,  Node: Introducción a ezunits,  Next: Introducción a physical_constants,  Prev: ezunits,  Up: ezunits

50.1 Introducción a ezunits
===========================

‘ezunits’ es un paquete para trabajar con magnitudes dimensionales,
incluyendo algunas funciones para realizar análisis dimensional.
‘ezunits’ puede hacer operaciones aritméticas con magnitudes
dimensionales y efectuar conversiones entre unidades.  Las unidades que
se definen son las del Sistema Internacional (SI) y otras comunes en los
Estados Unidos, siendo posible declarar otras nuevas.

Véase también ‘physical_constants’, una colección de constantes físicas.

Es necesario ejecutar primero ‘load("ezunits")’ para utilizar este
paquete.  Con ‘demo(ezunits)’ se podrán ver algunos ejemplos de
utilización.  La función ‘known_units’ devuelve una lista con todas las
unidades que están definidas y ‘display_known_unit_conversions’ muestra
las conversiones conocidas por el sistema en un formato de lectura
sencilla.

Una expresión tal como a ` b representa una magnitud dimensional, siendo
‘a’ una magnitud adimensional y ‘b’ las unidades.  Se puede utilizar un
símbolo como unidad, sin necesidad de declararlo como tal ni de que deba
cumplir propiedades especiales.  Tanto la magnitud como la unidad de una
expresión de la forma a ` b pueden extraerse invocando las funciones
‘qty’ y ‘units’, respectivamente.

Una expresión tal como ‘a ` b `` c’ convierte las unidades ‘b’ en ‘c’.
El paquete ‘ezunits’ contiene funciones conversoras para unidades
fundamentales del SI, unidades derivadas, así como algunas otras
unidades ajenas al SI. Las conversiones entre unidades que no estén
programadas en ‘ezunits’ podrán declararse a posteriori.  Las
conversiones conocidas por ‘ezunits’ están especificadas en la variable
global ‘known_unit_conversions’, incluyendo tanto las ya declaradas por
defecto como aquéllas introducidas por el usuario.  Las conversiones
para los productos, cocientes y potencias de unidades se derivan del
conjunto de conversiones ya conocidas.

En general, Maxima prefiere números exactos (enteros o racionales) a
inexactos (decimales en coma flotante), por lo que ‘ezunits’ respetará
los exactos cuando aparezcan en expresiones de magnitudes dimensionales.
Todas las conversiones del paquete se han definido en términos de
números exactos.

No hay un sistema de representación de unidades que se considere
preferible, razón por la cual las unidades no se convierten a otras a
menos que se indique de forma explícita.  ‘ezunits’ reconoce los
prefijos m-, k-, M y G- para mili-, kilo-, mega- y giga-,
respectivamente, tal como se utilizan en el SI; estos prefijos sólo se
utilizan cuando así se indica de forma explícita.

Las operaciones aritméticas con magnitudes dimensionales se realizan de
la forma convencional.

   • ‘(x ` a) * (y ` b)’ es igual a (x * y) ` (a * b).
   • ‘(x ` a) + (y ` a)’ es igual a (x + y) ` a.
   • ‘(x ` a)^y’ es igual a x^y ` a^y si ‘y’ es adimensional.

‘ezunits’ no necesita que las unidades en una suma tengan las mismas
dimensiones; estos términos serán sumados sin emitirse mensaje de error.

‘ezunits’ incluye funciones para el análisis dimensional elemental, como
las dimensiones fundamentales, las unidades fundamentales de una
magnitud dimensional o el cálculo de magnitudes adimensionales y
unidades naturales.  Las funciones de análisis dimensional son
adaptaciones de funciones semejantes escritas por Barton Willis en otro
paquete.

Con el fin de poder llevar a cabo análisis dimensionales, se mantiene
una lista de dimensiones fundamentales y otra lista asociada de unidades
fundamentales; por defecto, las dimensiones fundamentales son longitud,
masa, tiempo, carga, temperatura y cantidad de materia, siendo las
unidades fundamentales las propias del Sistema Internacional.  En
cualquier caso, es posible declarar otras dimensiones y unidades
fundamentales.


File: maxima.info,  Node: Introducción a physical_constants,  Next: Funciones y variables para ezunits,  Prev: Introducción a ezunits,  Up: ezunits

50.2 Introducción a physical_constants
======================================

‘physical_constants’ contiene constantes físicas recomendadas por el
CODATA 2006 (<http://physics.nist.gov/constants>).  La instrucción
‘load("physical_constants")’ carga este paquete en memoria junto con el
propio ‘ezunits’, si éste no estaba previamente cargado.

Una constante física se representa por un símbolo con la propiedad de
ser un valor constante.  El valor constante es una magnitud dimensional
en la sintaxis de ‘ezunits’.  La función ‘constvalue’ extrae el valor
constante, el cual no es el valor ordinario del símbolo, por lo que las
constantes físicas se mantienen inalteradas en las expresiones evaluadas
hasta que sus valores sea extraído con la función ‘constvalue’.

‘physical_constants’ incluye cierta información adicional, como la
descripción de cada constante, una estimación del error de su valor
numérico y una propiedad para ser representada en TeX. Para identificar
constantes físicas, cada símbolo tiene la propiedad ‘physical_constant’,
de forma que ‘propvars(physical_constant)’ muestra la lista de todas las
constantes físicas.

‘physical_constants’ contiene las siguientes constantes:

‘%c’
     velocidad de la luz en el vacío
‘%mu_0’
     constante magnética
‘%e_0’
     constante eléctrica
‘%Z_0’
     impedancia característica del vacío
‘%G’
     constante gravitatoria de Newton
‘%h’
     constante de Planck
‘%h_bar’
     constante de Planck
‘%m_P’
     masa de Planck
‘%T_P’
     temperature de Planck
‘%l_P’
     longitud de Planck
‘%t_P’
     tiempo de Planck
‘%%e’
     carga elemental
‘%Phi_0’
     flujo magnético cuántico
‘%G_0’
     conductancia cuántica
‘%K_J’
     constante de Josephson
‘%R_K’
     constante de von Klitzing
‘%mu_B’
     magnetón de Bohr
‘%mu_N’
     magnetón nuclear
‘%alpha’
     constante de estructura fina
‘%R_inf’
     constante de Rydberg
‘%a_0’
     radio de Bohr
‘%E_h’
     energía de Hartree
‘%ratio_h_me’
     cuanto de circulación
‘%m_e’
     masa del electrón
‘%N_A’
     número de Avogadro
‘%m_u’
     constante de masa atómica atomic mass constant
‘%F’
     constante de Faraday
‘%R’
     constante molar de los gases
‘%%k’
     constante de Boltzmann
‘%V_m’
     volumen molar del gas ideal
‘%n_0’
     constante de Loschmidt
‘%ratio_S0_R’
     constante de Sackur-Tetrode (constante de entropía absoluta)
‘%sigma’
     constante de Stefan-Boltzmann
‘%c_1’
     primera constante de radiación
‘%c_1L’
     primera constante de radiación para radiancia espectral
‘%c_2’
     segunda constante de radiación
‘%b’
     Constante de la ley del desplazamiento de Wien
‘%b_prime’
     Constante de la ley del desplazamiento de Wien

Ejemplos:

Lista de todos los símbolos que tienen la propiedad ‘physical_constant’.

     (%i1) load ("physical_constants")$
     (%i2) propvars (physical_constant);
     (%o2) [%c, %mu_0, %e_0, %Z_0, %G, %h, %h_bar, %m_P, %T_P, %l_P,
     %t_P, %%e, %Phi_0, %G_0, %K_J, %R_K, %mu_B, %mu_N, %alpha,
     %R_inf, %a_0, %E_h, %ratio_h_me, %m_e, %N_A, %m_u, %F, %R, %%k,
     %V_m, %n_0, %ratio_S0_R, %sigma, %c_1, %c_1L, %c_2, %b, %b_prime]

Propiedades de la constante física ‘%c’.

     (%i1) load ("physical_constants")$
     (%i2) constantp (%c);
     (%o2)                         true
     (%i3) get (%c, description);
     (%o3)               speed of light in vacuum
     (%i4) constvalue (%c);
                                           m
     (%o4)                     299792458 ` -
                                           s
     (%i5) get (%c, RSU);
     (%o5)                           0
     (%i6) tex (%c);
     $$c$$
     (%o6)                         false

Energía equivalente de una libra-masa.  El símbolo ‘%c’ se mantiene
hasta que su valor es extraído con la llamada a la función ‘constvalue’.

     (%i1) load ("physical_constants")$
     (%i2) m * %c^2;
                                     2
     (%o2)                         %c  m
     (%i3) %, m = 1 ` lbm;
                                   2
     (%o3)                       %c  ` lbm
     (%i4) constvalue (%);
                                                 2
                                            lbm m
     (%o4)              89875517873681764 ` ------
                                               2
                                              s
     (%i5) E : % `` J;
     Computing conversions to base units; may take a moment.
                          366838848464007200
     (%o5)                ------------------ ` J
                                  9
     (%i6) E `` GJ;
                           458548560580009
     (%o6)                 --------------- ` GJ
                              11250000
     (%i7) float (%);
     (%o7)              4.0759872051556356e+7 ` GJ


File: maxima.info,  Node: Funciones y variables para ezunits,  Prev: Introducción a physical_constants,  Up: ezunits

50.3 Funciones y variables para ezunits
=======================================

 -- Operador: `

     Operador de magnitud dimensional.  Una expresión tal como a ` b
     representa una magnitud dimensional, siendo ‘a’ una magnitud
     adimensional y ‘b’ las unidades.  Se puede utilizar un símbolo como
     unidad, sin necesidad de declararlo como tal ni de que deba cumplir
     propiedades especiales.  Tanto la magnitud como la unidad de una
     expresión de la forma a ` b pueden extraerse invocando las
     funciones ‘qty’ y ‘units’, respectivamente.

     Las operaciones aritméticas con magnitudes dimensionales se
     realizan de la forma convencional.

        • ‘(x ` a) * (y ` b)’ es igual a (x * y) ` (a * b).
        • ‘(x ` a) + (y ` a)’ es igual a (x + y) ` a.
        • ‘(x ` a)^y’ es igual a x^y ` a^y si ‘y’ es adimensional.

     ‘ezunits’ no necesita que las unidades en una suma tengan las
     mismas dimensiones; estos términos serán sumados sin emitirse
     mensaje de error.

     Para utilizar este operador ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     Unidades del Sistema Internacional.

          (%i1) load ("ezunits")$
          (%i2) foo : 10 ` m;
          (%o2)                        10 ` m
          (%i3) qty (foo);
          (%o3)                          10
          (%i4) units (foo);
          (%o4)                           m
          (%i5) dimensions (foo);
          (%o5)                        length

     Unidades definidas por el usuario.

          (%i1) load ("ezunits")$
          (%i2) bar : x ` acre;
          (%o2)                       x ` acre
          (%i3) dimensions (bar);
                                             2
          (%o3)                        length
          (%i4) fundamental_units (bar);
                                          2
          (%o4)                          m

     Unidades ad hoc.

          (%i1) load ("ezunits")$
          (%i2) baz : 3 ` sheep + 8 ` goat + 1 ` horse;
          (%o2)           8 ` goat + 3 ` sheep + 1 ` horse
          (%i3) subst ([sheep = 3*goat, horse = 10*goat], baz);
          (%o3)                       27 ` goat
          (%i4) baz2 : 1000`gallon/fortnight;
                                          gallon
          (%o4)                   1000 ` ---------
                                         fortnight
          (%i5) subst (fortnight = 14*day, baz2);
                                    500   gallon
          (%o5)                     --- ` ------
                                     7     day

     Operaciones aritméticas y magnitudes dimensionales.

          (%i1) load ("ezunits")$
          (%i2) 100 ` kg + 200 ` kg;
          (%o2)                       300 ` kg
          (%i3) 100 ` m^3 - 100 ` m^3;
                                            3
          (%o3)                        0 ` m
          (%i4) (10 ` kg) * (17 ` m/s^2);
                                           kg m
          (%o4)                      170 ` ----
                                             2
                                            s
          (%i5) (x ` m) / (y ` s);
                                        x   m
          (%o5)                         - ` -
                                        y   s
          (%i6) (a ` m)^2;
                                        2    2
          (%o6)                        a  ` m

 -- Operador: ``

     Operador de conversión de unidades.  Una expresión tal como a ` b
     `` c convierte las unidades ‘b’ en ‘c’.  El paquete ‘ezunits’
     contiene funciones conversoras para unidades fundamentales del SI,
     unidades derivadas, así como algunas otras unidades ajenas al SI.
     Las conversiones entre unidades que no estén programadas en
     ‘ezunits’ podrán declararse a posteriori.  Las conversiones
     conocidas por ‘ezunits’ están especificadas en la variable global
     ‘known_unit_conversions’, incluyendo tanto las ya declaradas por
     defecto como aquéllas introducidas por el usuario.  Las
     conversiones para los productos, cocientes y potencias de unidades
     se derivan del conjunto de conversiones ya conocidas.

     No hay un sistema de representación de unidades que se considere
     preferible, razón por la cual las unidades no se convierten a otras
     a menos que se indique de forma explícita.  Del mismo modo,
     ‘ezunits’ no transforma prefijos (milli-, centi-, deci-, etc) a
     menos que se le indique.

     Para utilizar este operador ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     Conjunto de conversiones conocidas.

          (%i1) load ("ezunits")$
          (%i2) display2d : false$
          (%i3) known_unit_conversions;
          (%o3) {acre = 4840*yard^2,Btu = 1055*J,cfm = feet^3/minute,
                 cm = m/100,day = 86400*s,feet = 381*m/1250,ft = feet,
                 g = kg/1000,gallon = 757*l/200,GHz = 1000000000*Hz,
                 GOhm = 1000000000*Ohm,GPa = 1000000000*Pa,
                 GWb = 1000000000*Wb,Gg = 1000000*kg,Gm = 1000000000*m,
                 Gmol = 1000000*mol,Gs = 1000000000*s,ha = hectare,
                 hectare = 100*m^2,hour = 3600*s,Hz = 1/s,inch = feet/12,
                 km = 1000*m,kmol = 1000*mol,ks = 1000*s,l = liter,
                 lbf = pound_force,lbm = pound_mass,liter = m^3/1000,
                 metric_ton = Mg,mg = kg/1000000,MHz = 1000000*Hz,
                 microgram = kg/1000000000,micrometer = m/1000000,
                 micron = micrometer,microsecond = s/1000000,
                 mile = 5280*feet,minute = 60*s,mm = m/1000,
                 mmol = mol/1000,month = 2629800*s,MOhm = 1000000*Ohm,
                 MPa = 1000000*Pa,ms = s/1000,MWb = 1000000*Wb,
                 Mg = 1000*kg,Mm = 1000000*m,Mmol = 1000000000*mol,
                 Ms = 1000000*s,ns = s/1000000000,ounce = pound_mass/16,
                 oz = ounce,Ohm = s*J/C^2,
                 pound_force = 32*ft*pound_mass/s^2,
                 pound_mass = 200*kg/441,psi = pound_force/inch^2,
                 Pa = N/m^2,week = 604800*s,Wb = J/A,yard = 3*feet,
                 year = 31557600*s,C = s*A,F = C^2/J,GA = 1000000000*A,
                 GC = 1000000000*C,GF = 1000000000*F,GH = 1000000000*H,
                 GJ = 1000000000*J,GK = 1000000000*K,GN = 1000000000*N,
                 GS = 1000000000*S,GT = 1000000000*T,GV = 1000000000*V,
                 GW = 1000000000*W,H = J/A^2,J = m*N,kA = 1000*A,
                 kC = 1000*C,kF = 1000*F,kH = 1000*H,kHz = 1000*Hz,
                 kJ = 1000*J,kK = 1000*K,kN = 1000*N,kOhm = 1000*Ohm,
                 kPa = 1000*Pa,kS = 1000*S,kT = 1000*T,kV = 1000*V,
                 kW = 1000*W,kWb = 1000*Wb,mA = A/1000,mC = C/1000,
                 mF = F/1000,mH = H/1000,mHz = Hz/1000,mJ = J/1000,
                 mK = K/1000,mN = N/1000,mOhm = Ohm/1000,mPa = Pa/1000,
                 mS = S/1000,mT = T/1000,mV = V/1000,mW = W/1000,
                 mWb = Wb/1000,MA = 1000000*A,MC = 1000000*C,
                 MF = 1000000*F,MH = 1000000*H,MJ = 1000000*J,
                 MK = 1000000*K,MN = 1000000*N,MS = 1000000*S,
                 MT = 1000000*T,MV = 1000000*V,MW = 1000000*W,
                 N = kg*m/s^2,R = 5*K/9,S = 1/Ohm,T = J/(m^2*A),V = J/C,
                 W = J/s}

     Converiones de unidades fundamentales.

          (%i1) load ("ezunits")$
          (%i2) 1 ` ft `` m;
          Computing conversions to base units; may take a moment.
                                      381
          (%o2)                       ---- ` m
                                      1250
          (%i3) %, numer;
          (%o3)                      0.3048 ` m
          (%i4) 1 ` kg `` lbm;
                                      441
          (%o4)                       --- ` lbm
                                      200
          (%i5) %, numer;
          (%o5)                      2.205 ` lbm
          (%i6) 1 ` W `` Btu/hour;
                                     720   Btu
          (%o6)                      --- ` ----
                                     211   hour
          (%i7) %, numer;
                                                  Btu
          (%o7)               3.412322274881517 ` ----
                                                  hour
          (%i8) 100 ` degC `` degF;
          (%o8)                      212 ` degF
          (%i9) -40 ` degF `` degC;
          (%o9)                     (- 40) ` degC
          (%i10) 1 ` acre*ft `` m^3;
                                  60228605349    3
          (%o10)                  ----------- ` m
                                   48828125
          (%i11) %, numer;
                                                    3
          (%o11)                1233.48183754752 ` m

     Transformando pies a metros y viceversa.

          (%i1) load ("ezunits")$
          (%i2) 100 ` m + 100 ` ft;
          (%o2)                  100 ` m + 100 ` ft
          (%i3) (100 ` m + 100 ` ft) `` ft;
                                     163100
          (%o3)                      ------ ` ft
                                      381
          (%i4) %, numer;
          (%o4)                428.0839895013123 ` ft
          (%i5) (100 ` m + 100 ` ft) `` m;
                                      3262
          (%o5)                       ---- ` m
                                       25
          (%i6) %, numer;
          (%o6)                      130.48 ` m

     Análisis dimensional para encontrar dimensiones y unidades
     fundamentales.

          (%i1) load ("ezunits")$
          (%i2) foo : 1 ` acre * ft;
          (%o2)                      1 ` acre ft
          (%i3) dimensions (foo);
                                             3
          (%o3)                        length
          (%i4) fundamental_units (foo);
                                          3
          (%o4)                          m
          (%i5) foo `` m^3;
                                  60228605349    3
          (%o5)                   ----------- ` m
                                   48828125
          (%i6) %, numer;
                                                    3
          (%o6)                 1233.48183754752 ` m

     Declaración de conversiones.

          (%i1) load ("ezunits")$
          (%i2) declare_unit_conversion (MMBtu = 10^6*Btu, kW = 1000*W);
          (%o2)                         done
          (%i3) declare_unit_conversion (kWh = kW*hour, MWh = 1000*kWh,
                                         bell = 1800*s);
          (%o3)                         done
          (%i4) 1 ` kW*s `` MWh;
          Computing conversions to base units; may take a moment.
                                       1
          (%o4)                     ------- ` MWh
                                    3600000
          (%i5) 1 ` kW/m^2 `` MMBtu/bell/ft^2;
                                 1306449      MMBtu
          (%o5)                 ---------- ` --------
                                8242187500          2
                                             bell ft

 -- Función: constvalue (<x>)
 -- Función: declare_constvalue (<a>, <x>)
 -- Función: remove_constvalue (<a>)

     Devuelve la constante declarada para un símbolo.  Los valores
     constantes se declaran con ‘declare_constvalue’.

     Los valores constantes reconocidos por ‘constvalue’ son distintos
     de los valores declarados por ‘numerval’ y reconocidos por
     ‘constantp’.

     El paquete ‘physical_units’ declara los valores constantes de las
     constantes físicas.

     ‘remove_constvalue’ deshace la acción de ‘declare_constvalue’.

     Para utilizar estas funciones ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     Valor de una constante física.

          (%i1) load ("physical_constants")$
          (%i2) constvalue (%G);
                                               3
                                              m
          (%o2)                    6.67428 ` -----
                                                 2
                                             kg s
          (%i3) get ('%G, 'description);
          (%o3)           Newtonian constant of gravitation

     Declarando una nueva constante.

          (%i1) load ("ezunits")$
          (%i2) declare_constvalue (FOO, 100 ` lbm / acre);
                                           lbm
          (%o2)                      100 ` ----
                                           acre
          (%i3) FOO * (50 ` acre);
          (%o3)                     50 FOO ` acre
          (%i4) constvalue (%);
          (%o4)                      5000 ` lbm

 -- Función: units (<x>)
 -- Función: declare_units (<a>, <u>)

     Devuelve las unidades de la magnitud dimensional <x>, o 1 en caso
     de que <x> sea adimensional.

     <x> puede ser una expresión literal dimensional a ` b, un símbolo
     con unidades declaradas por medio de ‘declare_units’, o una
     expresión que contenga cualquiera o ambos de los anteriores.

     ‘declare_constvalue’ declara que ‘units(<a>)’ debe devolver <u>,
     siendo <u> una expresión.

     Para utilizar estas funciones ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     ‘units’ aplicado a expresiones dimensionales literales.

          (%i1) load ("ezunits")$
          (%i2) foo : 100 ` kg;
          (%o2)                              100 ` kg
          (%i3) bar : x ` m/s;
                                                   m
          (%o3)                                x ` -
                                                   s
          (%i4) units (foo);
          (%o4)                                 kg
          (%i5) units (bar);
                                                 m
          (%o5)                                  -
                                                 s
          (%i6) units (foo * bar);
                                               kg m
          (%o6)                                ----
                                                s
          (%i7) units (foo / bar);
                                               kg s
          (%o7)                                ----
                                                m
          (%i8) units (foo^2);
                                                  2
          (%o8)                                 kg

     ‘units’ aplicado a símbolos con unidades declaradas.

          (%i1) load ("ezunits")$
          (%i2) linenum:0;
          (%o0)                                  0
          (%i1) units (aa);
          (%o1)                                  1
          (%i2) declare_units (aa, J);
          (%o2)                                  J
          (%i3) units (aa);
          (%o3)                                  J
          (%i4) units (aa^2);
                                                 2
          (%o4)                                 J
          (%i5) foo : 100 ` kg;
          (%o5)                              100 ` kg
          (%i6) units (aa * foo);
          (%o6)                                kg J

 -- Función: qty (<x>)
 -- Función: declare_qty (<a>, <x>)

     ‘qty’ devuelve la parte adimensional de la magnitud dimensional
     <x>, o <x>, si <x> es adimensional.  <x> puede ser una expresión
     literal dimensional a ` b, un símbolo con unidades declaradas o una
     expresión que contenga cualquiera o ambos de los anteriores.

     ‘declare_qty’ declara que ‘qty(<a>)’ debe devolver <x>, siendo <x>
     una magnitud dimensional.

     Para utilizar estas funciones ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     ‘qty’ aplicado a expresiones dimensionales literales.

          (%i1) load ("ezunits")$
          (%i2) foo : 100 ` kg;
          (%o2)                       100 ` kg
          (%i3) qty (foo);
          (%o3)                          100
          (%i4) bar : v ` m/s;
                                            m
          (%o4)                         v ` -
                                            s
          (%i5) foo * bar;
                                            kg m
          (%o5)                     100 v ` ----
                                             s
          (%i6) qty (foo * bar);
          (%o6)                         100 v

     ‘qty’ aplicado a símbolos con unidades declaradas.

          (%i1) load ("ezunits")$
          (%i2) declare_qty (aa, xx);
          (%o2)                          xx
          (%i3) qty (aa);
          (%o3)                          xx
          (%i4) qty (aa^2);
                                           2
          (%o4)                          xx
          (%i5) foo : 100 ` kg;
          (%o5)                       100 ` kg
          (%i6) qty (aa * foo);
          (%o6)                        100 xx

 -- Función: unitp (<x>)

     Devuelve ‘true’ si <x> es una expresión dimensional literal, un
     símbolo declarado como dimensional o una expresión en la que su
     operador principal ha sido declarado como dimensional.  En
     cualquier otro caso, ‘unitp’ devuelve ‘false’.

     Para utilizar esta función ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     ‘unitp’ aplicado a expresiones dimensionales literales.

          (%i1) load ("ezunits")$
          (%i2) unitp (100 ` kg);
          (%o2)                         true

     ‘unitp’ applied to a symbol declared dimensional.

          (%i1) load ("ezunits")$
          (%i2) unitp (foo);
          (%o2)                         false
          (%i3) declare (foo, dimensional);
          (%o3)                         done
          (%i4) unitp (foo);
          (%o4)                         true

     ‘unitp’ aplicado a una expresión en la que el operador principal se
     declara dimensional.

          (%i1) load ("ezunits")$
          (%i2) unitp (bar (x, y, z));
          (%o2)                         false
          (%i3) declare (bar, dimensional);
          (%o3)                         done
          (%i4) unitp (bar (x, y, z));
          (%o4)                         true

 -- Función: declare_unit_conversion (<u> = <v>, ...)

     Añade las ecuaciones <u> = <v>, ...  a la lista de conversiones de
     unidades conocidas por el operador de conversión ``.  <u> y <v> son
     términos multiplicativos en las que las variables son unidades o
     expresiones dimensionales literales.

     De momento, es imperativo expresar las conversiones de forma que el
     miembro izquierdo de cada ecuación sea una unidad simple (en
     opsición a una expresión multiplicativa) o una expresión
     dimensional literal con la cantidad igual a 1 y con unidad simple.
     Está previsto eliminar esta restricción en versiones futuras.

     ‘known_unit_conversions’ es la lista de conversiones de unidades
     conocidas.

     Para utilizar esta función ejecútese primero ‘load("ezunits")’.

     Ejemplos:

     Conversión de unidades expresadas por ecuaciones con términos
     multiplicativos.

          (%i1) load ("ezunits")$
          (%i2) declare_unit_conversion (nautical_mile = 1852 * m,
                                         fortnight = 14 * day);
          (%o2)                         done
          (%i3) 100 ` nautical_mile / fortnight `` m/s;
          Computing conversions to base units; may take a moment.
                                      463    m
          (%o3)                       ---- ` -
                                      3024   s

     Conversión de unidades expresadas por ecuaciones con expresiones
     dimensionales literales.

          (%i1) load ("ezunits")$
          (%i2) declare_unit_conversion (1 ` fluid_ounce = 2 ` tablespoon);
          (%o2)                         done
          (%i3) declare_unit_conversion (1 ` tablespoon = 3 ` teaspoon);
          (%o3)                         done
          (%i4) 15 ` fluid_ounce `` teaspoon;
          Computing conversions to base units; may take a moment.
          (%o4)                     90 ` teaspoon

 -- Función: declare_dimensions (<a_1>, <d_1>, ..., <a_n>, <d_n>)
 -- Función: remove_dimensions (<a_1>, ..., <a_n>)

     ‘declare_dimensions’ declara <a_1>, ..., <a_n> con las dimensiones
     <d_1>, ..., <d_n>, respectivamente.

     Cada <a_k> es un símbolo o lista de símbolos.  En caso de ser una
     lista, cada símbolo en <a_k> se declara de dimensión <d_k>.

     ‘remove_dimensions’ invierte el efecto de ‘declare_dimensions’.

     Ejecútese ‘load("ezunits")’ para hacer uso de estas funciones.

     Ejemplos:

          (%i1) load ("ezunits") $
          (%i2) declare_dimensions ([x, y, z], length, [t, u], time);
          (%o2)                         done
          (%i3) dimensions (y^2/u);
                                             2
                                       length
          (%o3)                        -------
                                        time
          (%i4) fundamental_units (y^2/u);
          0 errors, 0 warnings
                                          2
                                         m
          (%o4)                          --
                                         s

 -- Función: declare_fundamental_dimensions (<d_1>, <d_2>, <d_3>, ...)
 -- Función: remove_fundamental_dimensions (<d_1>, <d_2>, <d_3>, ...)
 -- Variable global: fundamental_dimensions

     ‘declare_fundamental_dimensions’ declara dimensiones fundamentales.
     Los símbolos <d_1>, <d_2>, <d_3>, ...  se añaden a la lista de
     dimensiones fundamentales si no están ya presentes en la lista.

     ‘remove_fundamental_dimensions’ invierte el efecto de
     ‘declare_fundamental_dimensions’.

     ‘fundamental_dimensions’ es la lista de dimensiones fundamentales.
     Por defecto, la lista comprende algunas dimensiones físicas.

     Ejecútese ‘load("ezunits")’ para hacer uso de estas funciones.

     Ejemplos:

          (%i1) load ("ezunits") $
          (%i2) fundamental_dimensions;
          (%o2) [length, mass, time, current, temperature, quantity]
          (%i3) declare_fundamental_dimensions (money, cattle, happiness);
          (%o3)                         done
          (%i4) fundamental_dimensions;
          (%o4) [length, mass, time, current, temperature, quantity,
                                                  money, cattle, happiness]
          (%i5) remove_fundamental_dimensions (cattle, happiness);
          (%o5)                         done
          (%i6) fundamental_dimensions;
          (%o6) [length, mass, time, current, temperature, quantity, money]

 -- Función: declare_fundamental_units (<u_1>, <d_1>, ..., <u_n>, <d_n>)
 -- Función: remove_fundamental_units (<u_1>, ..., <u_n>)

     ‘declare_fundamental_units’ declara <u_1>, ..., <u_n> de
     dimensiones <d_1>, ..., <d_n>, respectivamente.  Todos los
     argumentos deben símbolos.

     Tras la llamada a ‘declare_fundamental_units’, ‘dimensions(<u_k>)’
     devuelve <d_k> para cada argumento <u_1>, ..., <u_n>, y
     ‘fundamental_units(<d_k>)’ devuelve <u_k> para cada <d_1>, ...,
     <d_n>.

     ‘remove_fundamental_units’ invierte el efecto de
     ‘declare_fundamental_units’.

     Ejecútese ‘load("ezunits")’ para hacer uso de estas funciones.

     Ejemplos:

          (%i1) load ("ezunits") $
          (%i2) declare_fundamental_dimensions (money, cattle, happiness);
          (%o2)                         done
          (%i3) declare_fundamental_units (dollar, money, goat, cattle,
                                           smile, happiness);
          (%o3)                 [dollar, goat, smile]
          (%i4) dimensions (100 ` dollar/goat/km^2);
                                       money
          (%o4)                    --------------
                                                2
                                   cattle length
          (%i5) dimensions (x ` smile/kg);
                                      happiness
          (%o5)                       ---------
                                        mass
          (%i6) fundamental_units (money*cattle/happiness);
          0 errors, 0 warnings
                                     dollar goat
          (%o6)                      -----------
                                        smile

 -- Función: dimensions (<x>)
 -- Función: dimensions_as_list (<x>)

     ‘dimensions’ devuelve las dimensiones de la magnitud dimensional
     <x> en forma de expresión que contiene productos y potencias de
     dimensiones fundamentales.

     ‘dimensions_as_list’ devuelve las dimensiones de la magnitud
     dimensional <x> en forma de lista, cuyos elementos indican las
     potencias de las dimensiones fundamentales correspondientes.

     Para utilizar estas funciones ejecútese primero ‘load("ezunits")’.

     Ejemplos:

          (%i1) load ("ezunits")$
          (%i2) dimensions (1000 ` kg*m^2/s^3);
                                          2
                                    length  mass
          (%o2)                     ------------
                                           3
                                       time
          (%i3) declare_units (foo, acre*ft/hour);
                                       acre ft
          (%o3)                        -------
                                        hour
          (%i4) dimensions (foo);
                                             3
                                       length
          (%o4)                        -------
                                        time

          (%i1) load ("ezunits")$
          (%i2) fundamental_dimensions;
          (%o2)  [length, mass, time, charge, temperature, quantity]
          (%i3) dimensions_as_list (1000 ` kg*m^2/s^3);
          (%o3)                 [2, 1, - 3, 0, 0, 0]
          (%i4) declare_units (foo, acre*ft/hour);
                                       acre ft
          (%o4)                        -------
                                        hour
          (%i5) dimensions_as_list (foo);
          (%o5)                 [3, 0, - 1, 0, 0, 0]

 -- Función: fundamental_units (<x>)
 -- Función: fundamental_units ()

     ‘fundamental_units(<x>)’ devuelve las unidades asociadas a las
     dimensiones fundamentales de <x>, tal como queda determinada por
     ‘dimensions(<x>)’.

     <x> puede ser una expresión literal dimensional a ` b, un símbolo
     con unidades declaradas a través de ‘declare_units’ o una expresión
     que contenga a ambos.

     ‘fundamental_units()’ devuelve una lista con las unidades
     fundamentales conocidas, tal como fueron declaradas por
     ‘declare_fundamental_units’.

     Para utilizar esta función ejecútese primero ‘load("ezunits")’.

     Ejemplos:

          (%i1) load ("ezunits")$
          (%i2) fundamental_units ();
          (%o2)                 [m, kg, s, A, K, mol]
          (%i3) fundamental_units (100 ` mile/hour);
                                          m
          (%o3)                           -
                                          s
          (%i4) declare_units (aa, g/foot^2);
                                          g
          (%o4)                         -----
                                            2
                                        foot
          (%i5) fundamental_units (aa);
                                         kg
          (%o5)                          --
                                          2
                                         m

 -- Función: dimensionless (<L>)

     Devuelve una expresión sin dimensiones que se puede formar a partir
     de una lista <L> de cantidades dimensionales

     Para utilizar esta función ejecútese primero ‘load("ezunits")’.

     Ejemplos:

          (%i1) load ("ezunits") $
          (%i2) dimensionless ([x ` m, y ` m/s, z ` s]);
          0 errors, 0 warnings
          0 errors, 0 warnings
                                         y z
          (%o2)                         [---]
                                          x

     Cantidades adimensionales obtenidas a partir de cantidades físicas.
     Nótese que el primer elemento de la lista es proporcional a la
     constante de estructura fina.

          (%i1) load ("ezunits") $
          (%i2) load ("physical_constants") $
          (%i3) dimensionless([%h_bar, %m_e, %m_P, %%e, %c, %e_0]);
          0 errors, 0 warnings
          0 errors, 0 warnings
                                        2
                                     %%e        %m_e
          (%o3)                [--------------, ----]
                                %c %e_0 %h_bar  %m_P

 -- Función: natural_unit (<expr>, [<v_1>, ..., <v_n>])

     Busca los exponentes <e_1>, ..., <e_n> tales que ‘dimension(<expr>)
     = dimension(<v_1>^<e_1> ... <v_n>^<e_n>)’.

     Para utilizar esta función ejecútese primero ‘load("ezunits")’.


File: maxima.info,  Node: f90,  Next: finance,  Prev: ezunits,  Up: Top

51 f90
******

* Menu:

* Funciones y variables para f90::


File: maxima.info,  Node: Funciones y variables para f90,  Prev: f90,  Up: f90

51.1 Funciones y variables para f90
===================================

 -- Función: f90 (<expr_1>, ..., <expr_n>)

     Imprime una o más expresiones <expr_1>, ..., <expr_n> como un
     programa Fortran 90.  El programa se obtiene a través de la salida
     estándar.

     La función ‘f90’ imprime su salida en el llamado formato libre de
     Fortran 90: no se presta atención alguna a las posiciones de
     caracteres respecto de las columnas y los renglones largos se
     dividen a un ancho fijo con el carácter ‘&’ indicando continuación
     de código.

     Ejecútese ‘load("f90")’ antes de utilizar esta función.

     Véase también ‘fortran’.

     Ejemplos:

          (%i1) load ("f90")$
          (%i2) foo : expand ((xxx + yyy + 7)^4);
                   4            3         3        2    2             2
          (%o2) yyy  + 4 xxx yyy  + 28 yyy  + 6 xxx  yyy  + 84 xxx yyy
                    2        3             2
           + 294 yyy  + 4 xxx  yyy + 84 xxx  yyy + 588 xxx yyy + 1372 yyy
                4         3          2
           + xxx  + 28 xxx  + 294 xxx  + 1372 xxx + 2401
          (%i3) f90 ('foo = foo);
          foo = yyy**4+4*xxx*yyy**3+28*yyy**3+6*xxx**2*yyy**2+84*xxx*yyy**2&
          +294*yyy**2+4*xxx**3*yyy+84*xxx**2*yyy+588*xxx*yyy+1372*yyy+xxx**&
          4+28*xxx**3+294*xxx**2+1372*xxx+2401
          (%o3)                         false

     Expresiones múltiples.  Captura de la salida estándar a un fichero
     por medio de la función ‘with_stdout’.

          (%i1) load ("f90")$
          (%i2) foo : sin (3*x + 1) - cos (7*x - 2);
          (%o2)              sin(3 x + 1) - cos(7 x - 2)
          (%i3) with_stdout ("foo.f90",
                             f90 (x=0.25, y=0.625, 'foo=foo, 'stop, 'end));
          (%o3)                         false
          (%i4) printfile ("foo.f90");
          x = 0.25
          y = 0.625
          foo = sin(3*x+1)-cos(7*x-2)
          stop
          end
          (%o4)                        foo.f90


File: maxima.info,  Node: finance,  Next: fractals,  Prev: f90,  Up: Top

52 finance
**********

* Menu:

* Introducción a finance::
* Funciones y Variables para finance::


File: maxima.info,  Node: Introducción a finance,  Next: Funciones y Variables para finance,  Prev: finance,  Up: finance

52.1 Introducción a finance
===========================

Este es el Paquete "Finance" (Ver 0.1).

En todas las funciones, <rate> es la tasa de interés compuesto, <num> es
el número de periodos y debe ser positivo, y <flow> se refiere al flujo
de caja; entonces, si se tiene un egreso el flujo es negativo y para un
ingreso un valor positivo.

Note que antes de usar las funciones definidas en este paquete, debe
cargarla escribiendo ‘load("finance")$’.

Autor: Nicolás Guarin Zapata.


File: maxima.info,  Node: Funciones y Variables para finance,  Prev: Introducción a finance,  Up: finance

52.2 Funciones y Variables para finance
=======================================

 -- Function: days360 (<año1>,<mes1>,<dia1>,<año2>,<mes2>,<dia2>)

     Calcula la distancia entre 2 fechas, asumiendo años de 360 dias y
     meses de 30 días.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) days360(2008,12,16,2007,3,25);
          (%o2)                      - 621

 -- Function: fv (<rate>,<PV>,<num>)

     Calcular el Valor Futuro a partir de uno en el Presente para una
     tasa de interés dada.  <rate> es la tasa de interés, <PV> es el
     valor prestente y <num> es el número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) fv(0.12,1000,3);
          (%o2)                     1404.928

 -- Function: pv (<rate>,<FV>,<num>)

     Calcula el valor actual de un valor futuro dada la tasa de interés.
     <rate> es la tasa de interés, <FV> es el valor futuro y <num> es el
     número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) pv(0.12,1000,3);
          (%o2)                711.7802478134108

 -- Function: graph_flow (<val>)

     Grafica el flujo de caja en una línea de tiempo, los valores
     positivos están en azul y hacia arriba; los negativos están en rojo
     y hacia abajo.  La dirección del flujo está dada por el signo de
     los valores.  <val> es una lista de los valores del flujo de caja.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) graph_flow([-5000,-3000,800,1300,1500,2000])$

 -- Function: annuity_pv (<rate>,<PV>,<num>)

     Calcula una anualidad conociendo el valor presente (tipo deuda),
     para unos pagos periódicos y constantes.  <rate> es la tasa de
     interés, <PV> es el valor presente y <num> es el número de
     periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) annuity_pv(0.12,5000,10);
          (%o2)                884.9208207992202

 -- Function: annuity_fv (<rate>,<FV>,<num>)

     Calcula una anualidad conociendo el valor deseado (valor futuro),
     para una serie de pagos periódicos y constantes.  <rate> es la tasa
     de interés, <FV> es el valor futuroe y <num> es el número de
     periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) annuity_fv(0.12,65000,10);
          (%o2)                3703.970670389863

 -- Function: geo_annuity_pv (<rate>,<growing_rate>,<PV>,<num>)

     Calcula una anualidad conociendo el valor presente (tipo deuda) en
     una serie de pagos periodicos crecientes.  <rate> es la tasa de
     interés, <growing_rate> es el crecimiento de los pagos, <PV> es el
     valor presente, y <num> es el número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) geo_annuity_pv(0.14,0.05,5000,10);
          (%o2)                802.6888176505123

 -- Function: geo_annuity_fv (<rate>,<growing_rate>,<FV>,<num>)

     Calcular una anualidad conociendo el valor deseado (valor futuro)
     en una serie de pagos periodicos crecientes.  <rate> es la tasa de
     interés, <growing_rate> es el crecimiento de los pagos, <FV> es el
     valor futuro, y <num> es el número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) geo_annuity_fv(0.14,0.05,5000,10);
          (%o2)                216.5203395312695

 -- Function: amortization (<rate>,<amount>,<num>)

     La tabla de amortización determinada por una tasa.  Siendo <rate>
     es la tasa de interés, <amount> es el valor de la deuda, and <num>
     es el número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) amortization(0.05,56000,12)$
                "n"    "Balance"     "Interest"   "Amortization"  "Payment"
               0.000     56000.000         0.000         0.000         0.000
               1.000     52481.777      2800.000      3518.223      6318.223
               2.000     48787.643      2624.089      3694.134      6318.223
               3.000     44908.802      2439.382      3878.841      6318.223
               4.000     40836.019      2245.440      4072.783      6318.223
               5.000     36559.597      2041.801      4276.422      6318.223
               6.000     32069.354      1827.980      4490.243      6318.223
               7.000     27354.599      1603.468      4714.755      6318.223
               8.000     22404.106      1367.730      4950.493      6318.223
               9.000     17206.088      1120.205      5198.018      6318.223
              10.000     11748.170       860.304      5457.919      6318.223
              11.000      6017.355       587.408      5730.814      6318.223
              12.000         0.000       300.868      6017.355      6318.223

 -- Function: arit_amortization (<rate>,<increment>,<amount>,<num>)

     La tabla de amortización determinada por una tasa específica y unos
     pagos crecientes se puede hallar con ‘arit_amortization’.  Nótese
     que los pagos no son constantes, estos presentan un crecimiento
     aritmético, el incremento es la diferencia entre dos filas
     consecutivas en la columna "Payment".  <rate> es la tasa de
     interés, <increment> es el incremento, <amount> es el valor de la
     deuda, and <num> es el número de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) arit_amortization(0.05,1000,56000,12)$
                "n"    "Balance"     "Interest"   "Amortization"  "Payment"
               0.000     56000.000         0.000         0.000         0.000
               1.000     57403.679      2800.000     -1403.679      1396.321
               2.000     57877.541      2870.184      -473.863      2396.321
               3.000     57375.097      2893.877       502.444      3396.321
               4.000     55847.530      2868.755      1527.567      4396.321
               5.000     53243.586      2792.377      2603.945      5396.321
               6.000     49509.443      2662.179      3734.142      6396.321
               7.000     44588.594      2475.472      4920.849      7396.321
               8.000     38421.703      2229.430      6166.892      8396.321
               9.000     30946.466      1921.085      7475.236      9396.321
              10.000     22097.468      1547.323      8848.998     10396.321
              11.000     11806.020      1104.873     10291.448     11396.321
              12.000        -0.000       590.301     11806.020     12396.321

 -- Function: geo_amortization (<rate>,<growing_rate>,<amount>,<num>)

     La tabla de amortización determinada por la tasa, el valor de la
     deuda, y el número de periodos se puede hallar con
     ‘geo_amortization’.  Nótese que los pagos no son constantes, estos
     presentan un crecimiento geométrico, growin_rate es entonces el
     cociente entre dos filas consecutivas de la columna "Payment".
     <rate> es la tasa de interés, <growing_rate> es el crecimeinto de
     los pagos, <amount> es el valor de la deuda, y <num> es el numero
     de periodos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) geo_amortization(0.05,0.03,56000,12)$
                "n"    "Balance"     "Interest"   "Amortization"  "Payment"
               0.000     56000.000         0.000         0.000         0.000
               1.000     53365.296      2800.000      2634.704      5434.704
               2.000     50435.816      2668.265      2929.480      5597.745
               3.000     47191.930      2521.791      3243.886      5765.677
               4.000     43612.879      2359.596      3579.051      5938.648
               5.000     39676.716      2180.644      3936.163      6116.807
               6.000     35360.240      1983.836      4316.475      6300.311
               7.000     30638.932      1768.012      4721.309      6489.321
               8.000     25486.878      1531.947      5152.054      6684.000
               9.000     19876.702      1274.344      5610.176      6884.520
              10.000     13779.481       993.835      6097.221      7091.056
              11.000      7164.668       688.974      6614.813      7303.787
              12.000         0.000       358.233      7164.668      7522.901

 -- Function: saving (<rate>,<amount>,<num>)

     La tabla que presenta los valores para un ahorro constante y
     periódico se pueden hallar con ‘saving’.  <amount> representa la
     cantidad deseada y <num> el número de periodos durante los que se
     ahorrará.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) saving(0.15,12000,15)$
                "n"    "Balance"     "Interest"   "Payment"
               0.000         0.000         0.000         0.000
               1.000       252.205         0.000       252.205
               2.000       542.240        37.831       252.205
               3.000       875.781        81.336       252.205
               4.000      1259.352       131.367       252.205
               5.000      1700.460       188.903       252.205
               6.000      2207.733       255.069       252.205
               7.000      2791.098       331.160       252.205
               8.000      3461.967       418.665       252.205
               9.000      4233.467       519.295       252.205
              10.000      5120.692       635.020       252.205
              11.000      6141.000       768.104       252.205
              12.000      7314.355       921.150       252.205
              13.000      8663.713      1097.153       252.205
              14.000     10215.474      1299.557       252.205
              15.000     12000.000      1532.321       252.205

 -- Function: npv (<rate>,<val>)

     Calcular el valor presente neto de una serie de valores para
     evaluar la viabilidad de un proyecto.  <flowValues> es una lista
     con los valores para cada periodo.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) npv(0.25,[100,500,323,124,300]);
          (%o2)                714.4703999999999

 -- Function: irr (<val>,<IO>)

     Tasa interna de retorno (en inglés Internal Rate of Return - IRR),
     es el valor de tasa que hace que el Valor Presente Neto (NPV) sea
     cero.  <flowValues> los valores para cada periodo (para periodos
     mayores a 0) y <I0> el valor para el periodo cero.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) res:irr([-5000,0,800,1300,1500,2000],0)$
          (%i3) rhs(res[1][1]);
          (%o3)                .03009250374237132

 -- Function: benefit_cost (<rate>,<input>,<output>)

     Calcular la relación Beneficio/Costo, Beneficio es el Valor
     Presente Neto (NPV) de los flujos de caja positivos (inputs), y
     Costo es el Valor Presente Neto de los flujos de caja negativos
     (outputs).  Nótese que si se desea tener un valor de cero para un
     periodo especifico, esta entrada/salida debe indicarse como cero
     para ese periodo.  <rate> es la tasa de interés, <input> es una
     lista con los ingresos, y <output> es una lista con los egresos.

     Ejemplo:

          (%i1) load("finance")$
          (%i2) benefit_cost(0.24,[0,300,500,150],[100,320,0,180]);
          (%o2)               1.427249324905784


File: maxima.info,  Node: fractals,  Next: ggf,  Prev: finance,  Up: Top

53 fractals
***********

* Menu:

* Introducción a fractals::
* Definiciones para IFS fractals::
* Definiciones para fractales complejos::
* Definiciones para cops de Koch::
* Definiciones para curvas de Peano::


File: maxima.info,  Node: Introducción a fractals,  Next: Definiciones para IFS fractals,  Prev: fractals,  Up: fractals

53.1 Introducción a fractals
============================

Este paquete define algunos fractales:

- con IFS (Iterated Function System) aleatorias: triángulo de
Sierpinsky, un árbol y un helecho.

- Fractales complejos: conjuntos de Mandelbrot y de Julia.

- Copos de Koch.

- Funciones de Peano: funciones de Sierpinski y Hilbert.

Autor: José Rammírez Labrador.

Para preguntas, sugerencias y fallos,

pepe DOT ramirez AAATTT uca DOT es


File: maxima.info,  Node: Definiciones para IFS fractals,  Next: Definiciones para fractales complejos,  Prev: Introducción a fractals,  Up: fractals

53.2 Definiciones para IFS fractals
===================================

Algunos fractales se pueden generar por medio de la aplicación iterativa
de transformaciones afines contractivas de forma aleatoria; véase

Hoggar S. G., "Mathematics for computer graphics", Cambridge University
Press 1994.

Definimos una lista con varias transformaciones afines contractivas,
luego las vamos seleccionando de forma aleatoria y recursiva.  La
probabilidad de selección de una transformación debe estar relacionada
con la razón de contracción.

Se pueden cambiar las transformaciones y encontrar nuevos fractales.

 -- Función: sierpinskiale (<n>)

     Triángulo de Sierpinski: 3 aplicaciones contractivas; constante de
     contracción de 0.5 y traslaciones.  Todas las aplicaciones tienen
     la misma constante de contracción.  El argumento <n> debe ser
     suficientemente alto, 10000 o mayor.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) n: 10000$
          (%i3) plot2d([discrete,sierpinskiale(n)], [style,dots])$

 -- Función: treefale (<n>)

     3 aplicaciones contractivas, todas ellas con el mismo coeficiente
     de contracción.  El argumento <n> debe ser suficientemente alto,
     10000 o mayor.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) n: 10000$
          (%i3) plot2d([discrete,treefale(n)], [style,dots])$

 -- Función: fernfale (<n>)

     4 aplicaciones contractivas, cuyas probabilidades de selección
     deben estar relacionadas con su constante de contracción.  El
     argumento <n> debe ser suficientemente alto, 10000 o mayor.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) n: 10000$
          (%i3) plot2d([discrete,fernfale(n)], [style,dots])$


File: maxima.info,  Node: Definiciones para fractales complejos,  Next: Definiciones para cops de Koch,  Prev: Definiciones para IFS fractals,  Up: Top

53.3 Definiciones para fractales complejos
==========================================

 -- Función: mandelbrot_set (<x>, <y>)

     Conjunto de Mandelbrot.

     Esta función debe realizar muchas operaciones y puede tardar
     bastante tiempo en ejecutarse, tiempo que también depende del
     número de puntos de la malla.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) plot3d (mandelbrot_set, [x, -2.5, 1], [y, -1.5, 1.5],
                          [gnuplot_preamble, "set view map"],
                          [gnuplot_pm3d, true],
                          [grid, 150, 150])$

 -- Función: julia_set (<x>, <y>)

     Conjuntos de Julia.

     Esta función debe realizar muchas operaciones y puede tardar
     bastante tiempo en ejecutarse, tiempo que también depende del
     número de puntos de la malla.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) plot3d (julia_set, [x, -2, 1], [y, -1.5, 1.5],
                          [gnuplot_preamble, "set view map"],
                          [gnuplot_pm3d, true],
                          [grid, 150, 150])$

     Véase también ‘julia_parameter’.

 -- Variable opcional: julia_parameter
     Valor por defecto: ‘%i’

     Parámetro complejo para fractales de Julia.  Su valor por defecto
     es ‘%i’, y otros que se sugieren son: ‘-.745+%i*.113002’,
     ‘-.39054-%i*.58679’, ‘-.15652+%i*1.03225’, ‘-.194+%i*.6557’ y
     ‘.011031-%i*.67037’.

 -- Función: julia_sin (<x>, <y>)

     Mientras que la función ‘julia_set’ implementa la transformación
     ‘julia_parameter+z^2’, la función ‘julia_sin’ implementa
     ‘julia_parameter*sin(z)’.  Véase el código fuente para más
     detalles.

     Este programa es lento porque calcula muchos senos; el tiempo de
     ejecución también depende del número de puntos de la malla.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) julia_parameter:1+.1*%i$
          (%i3) plot3d (julia_sin, [x, -2, 2], [y, -3, 3],
                          [gnuplot_preamble, "set view map"],
                          [gnuplot_pm3d, true],
                          [grid, 150, 150])$

     Véase también ‘julia_parameter’.


File: maxima.info,  Node: Definiciones para cops de Koch,  Next: Definiciones para curvas de Peano,  Prev: Definiciones para fractales complejos,  Up: Top

53.4 Definiciones para cops de Koch
===================================

 -- Función: snowmap (<ent>, <nn>)

     Copos de Koch.  La función ‘snowmap’ dibuja el copo de Koch sobre
     los vértices de un polígono convexo inicial del plano complejo.  La
     orientación del polígono es importante.  El argumento <nn> es el
     número de recursividades de la transformación de Koch, el cual debe
     ser pequeño (5 o 6).

     Ejemplos:

          (%i1) load("fractals")$
          (%i2) plot2d([discrete,
                        snowmap([1,exp(%i*%pi*2/3),exp(-%i*%pi*2/3),1],4)])$
          (%i3) plot2d([discrete,
                        snowmap([1,exp(-%i*%pi*2/3),exp(%i*%pi*2/3),1],4)])$
          (%i4) plot2d([discrete, snowmap([0,1,1+%i,%i,0],4)])$
          (%i5) plot2d([discrete, snowmap([0,%i,1+%i,1,0],4)])$


File: maxima.info,  Node: Definiciones para curvas de Peano,  Prev: Definiciones para cops de Koch,  Up: fractals

53.5 Definiciones para curvas de Peano
======================================

Funciones continuas que cubren un área.  Aviso: el número de puntos
crece exponencialmente con <n>.

 -- Función: hilbertmap (<nn>)

     Curva de Hilbert.  El argumento <nn> debe ser pequeño (por ejemplo,
     5).  Maxima se puede detener si <nn> es 7 o mayor.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) plot2d([discrete,hilbertmap(6)])$

 -- Función: sierpinskimap (<nn>)

     Curva de Sierpinski.  El argumento <nn> debe ser pequeño (por
     ejemplo, 5).  Maxima se puede detener si <nn> es 7 o mayor.

     Ejemplo:

          (%i1) load("fractals")$
          (%i2) plot2d([discrete,sierpinskimap(6)])$


File: maxima.info,  Node: ggf,  Next: graphs,  Prev: fractals,  Up: Top

54 ggf
******

* Menu:

* Funciones y variables para ggf::


File: maxima.info,  Node: Funciones y variables para ggf,  Prev: ggf,  Up: ggf

54.1 Funciones y variables para ggf
===================================

 -- Variable opcional: GGFINFINITY
     Valor por defecto: 3

     Variable opcional para la función ‘ggf’.

     Cuando se calcula la fracción continua de la función generatriz, si
     un cociente parcial tiene grado estrictamente mayor que
     <GGFINFINITY> será descartado y la convergencia alcanzada hasta ese
     momento será considerada como exacta para la función generatriz.
     Lo más frecuente es que el grado de todos los cocientes parciales
     sea 0 ó 1, de modo que si se utiliza un valor mayor se deberán dar
     más términos para conseguir un cálculo más exacto.

     Véase también ‘ggf’.

 -- Variable opcional: GGFCFMAX
     Valor por defeco: 3

     Variable opcional para la función ‘ggf’.

     Cuando se calcula la fracción continua de la función generatriz, si
     no se ha encontrado un resultado aceptable (véase la variable
     <GGFINFINITY>) después de haber calculado <GGFCFMAX> cocientes
     parciales, la función generatriz será considerada no equivalente a
     una fracción racional y la función ‘ggf’ se detendrá.  Puede
     asignársele a <GGFCFMAX> un valor mayor para funciones generatrices
     más complicadas.

     Véase también ‘ggf’.

 -- Función: ggf (<l>)
     Calcula la función generatriz de una sucesión de la que se
     suministran tan solo los primeros valores y cuyo término general es
     una fracción algebraica (cociente de dos polinomios).

     La solución se devuelve como una fracción de polinomios.  En caso
     de no poder encontrar una solución, se devuelve ‘done’.

     Esta función está controlada por las variables globales
     <GGFINFINITY> y <GGFCFMAX>.  Véanse también <GGFINFINITY> y
     <GGFCFMAX>.

     Antes de hacer uso de esta función ejecútese ‘load("ggf")’.


File: maxima.info,  Node: graphs,  Next: grobner,  Prev: ggf,  Up: Top

55 graphs
*********

* Menu:

* Introducción a graphs::
* Funciones y variables para graphs::


File: maxima.info,  Node: Introducción a graphs,  Next: Funciones y variables para graphs,  Prev: graphs,  Up: graphs

55.1 Introducción a graphs
==========================

El paquete ‘graphs’ permite trabajar con estructuras de grafos y
digrafos en Maxima.  Tanto los grafos como los digrafos son de
estructura simples (no tienen ni aristas mÃºltiples ni bucles), pero los
digrafos pueden tener una arista dirigida desde <u> hasta <v> y otra
desde <v> hasta <u>.

Los grafos se representan internamente como listas de adyacencia y se
implementan como estructuras de lisp.  Los vértices se identifican por
sus números de identificaciń (siempre enteros).  Las aristas/arcos se
representan por listas de longitud 2.  Se pueden asignar etiquetas a los
vértices de los grafos/digrafos y pesos a sus aristas/arcos.

La función ‘draw_graph’ dibuja grafos siguiendo un criterio rígido de
posicionamiento de los vértices.  También puede hacer uso del programa
graphviz disponible en <http://www.graphviz.org>.  La función
‘draw_graph’ utiliza el paquete ‘draw’ de Maxima.

Para hacer uso de este paquete, ejecútese primero ‘load("graphs")’.


File: maxima.info,  Node: Funciones y variables para graphs,  Prev: Introducción a graphs,  Up: graphs

55.2 Funciones y variables para graphs
======================================

55.2.1 Construyendo grafos
--------------------------

 -- Función: create_graph (<v_list>, <e_list>)
 -- Función: create_graph (<n>, <e_list>)
 -- Función: create_graph (<v_list>, <e_list>, <directed>)

     Crea un nuevo grafo sobre el conjunto de vértices <v_list> con
     aristas <e_list>.

     <v_list> es una lista de vértices (‘[v1, v2,..., vn]’) o una lista
     de vértices junto con sus respectivas etiquetas (‘[[v1,l1],
     [v2,l2],..., [vn,ln]]’).

     <n> es el número de vértices, los cuales se identificarán desde 0
     hasta n-1.

     <e_list> es una lista de aristas (‘[e1, e2,..., em]’) o una lista
     de aristas con sus respectivas ponderaciones (‘[[e1, w1], ..., [em,
     wm]]’).

     Si <directed> is not ‘false’, se devolverá un grafo orientado.

     Ejemplos:

     Crea un ciclo de 3 vértices.

          (%i1) load ("graphs")$
          (%i2) g : create_graph([1,2,3], [[1,2], [2,3], [1,3]])$
          (%i3) print_graph(g)$
          Graph on 3 vertices with 3 edges.
          Adjacencies:
            3 :  1  2
            2 :  3  1
            1 :  3  2

     Crea un ciclo de 3 vértices y aristas ponderadas:

          (%i1) load ("graphs")$
          (%i2) g : create_graph([1,2,3], [[[1,2], 1.0], [[2,3], 2.0],
                                          [[1,3], 3.0]])$
          (%i3) print_graph(g)$
          Graph on 3 vertices with 3 edges.
          Adjacencies:
            3 :  1  2
            2 :  3  1
            1 :  3  2

     Crea un grafo orientado:

          (%i1) load ("graphs")$
          (%i2) d : create_graph(
                 [1,2,3,4],
                 [
                  [1,3], [1,4],
                  [2,3], [2,4]
                 ],
                 'directed = true)$
          (%i3) print_graph(d)$
          Digraph on 4 vertices with 4 arcs.
          Adjacencies:
            4 :
            3 :
            2 :  4  3
            1 :  4  3

 -- Función: copy_graph (<g>)
     Devuelve una copia del grafo <g>.

 -- Función: circulant_graph (<n>, <d>)
     Devuelve un grafo cirlulante de parámetros <n> y <d>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : circulant_graph(10, [1,3])$
          (%i3) print_graph(g)$
          Graph on 10 vertices with 20 edges.
          Adjacencies:
            9 :  2  6  0  8
            8 :  1  5  9  7
            7 :  0  4  8  6
            6 :  9  3  7  5
            5 :  8  2  6  4
            4 :  7  1  5  3
            3 :  6  0  4  2
            2 :  9  5  3  1
            1 :  8  4  2  0
            0 :  7  3  9  1

 -- Función: clebsch_graph ()
     Devuelve el grafo de Clebsch.

 -- Función: complement_graph (<g>)
     Devuelve el complemento del grafo <g>.

 -- Función: complete_bipartite_graph (<n>, <m>)
     Devuelve el grafo bipartido completo de <n+m> vértices.

 -- Función: complete_graph (<n>)
     Devuelve el grafo completo de <n> vértices.

 -- Función: cycle_digraph (<n>)
     Devuelve el ciclo dirigido de <n> vértices.

 -- Función: cycle_graph (<n>)
     Devuelve el ciclo de <n> vértices.

 -- Función: cuboctahedron_graph (<n>)
     Devuelve el grafo cubooctaédrico.

 -- Función: cube_graph (<n>)
     Devuelve el cubo de <n> dimensiones.

 -- Función: dodecahedron_graph ()
     Devuelve el grafo del dodecaedro.

 -- Función: empty_graph (<n>)
     Devuelve el grafo vacío de <n> vértices.

 -- Función: flower_snark (<n>)
     Devuelve el grafo de flor de <4n> vértices.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) f5 : flower_snark(5)$
          (%i3) chromatic_index(f5);
          (%o3)                                  4

 -- Función: from_adjacency_matrix (<A>)
     Devuelve el grafo definido por la matriz de adyacencia <A>.

 -- Función: frucht_graph ()
     Devuelve el grafo de Frucht.

 -- Función: graph_product (<g1>, <g1>)
     Devuelve el producto dirigido de los grafos <g1> y <g2>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) grid : graph_product(path_graph(3), path_graph(4))$
          (%i3) draw_graph(grid)$


     (Figure graphs01: Producto directo de dos grafos)

 -- Función: graph_union (<g1>, <g1>)
     Devuelve la unión (suma) de los grafos <g1> y <g2>.

 -- Función: grid_graph (<n>, <m>)
     Devuelve la rejilla <n x m>.

 -- Función: great_rhombicosidodecahedron_graph ()
     Devuelve el grafo gran rombicosidodecaédrico.

 -- Función: great_rhombicuboctahedron_graph ()
     Devuelve el grafo gran rombicocubicooctaédrico.

 -- Función: grotzch_graph ()
     Devuelve el grafo de Grotzch.

 -- Función: heawood_graph ()
     Devuelve el grafo de Heawood.

 -- Función: icosahedron_graph ()
     Devuelve el grafo icosaédrico.

 -- Función: icosidodecahedron_graph ()
     Devuelve el grafo icosidodecaédrico.

 -- Función: induced_subgraph (<V>, <g>)
     Devuelve el grafo inducido por el subconjunto <V> de vértices del
     grafo <g>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) V : [0,1,2,3,4]$
          (%i4) g : induced_subgraph(V, p)$
          (%i5) print_graph(g)$
          Graph on 5 vertices with 5 edges.
          Adjacencies:
            4 :  3  0
            3 :  2  4
            2 :  1  3
            1 :  0  2
            0 :  1  4

 -- Función: line_graph (<g>)
     Devuelve el grafo de línea del grafo <g>.

 -- Función: make_graph (<vrt>, <f>)
 -- Función: make_graph (<vrt>, <f>, <oriented>)
     Crea un grafo por medio de la función de predicado <f>.

     <vrt> es una lista o conjunto de vértices o un simplemente un
     número entero.  Si <vrt> es un número entero, entonces los vértices
     del grafo serán los enteros desde 1 hasta <vrt>.

     <f> es una función de predicado.  Dos vértices <a> y <b> se
     conectarán si ‘f(a,b)=true’.

     Si <directed> no es <false>, entonces en grafo será dirigido.

     Ejemplo 1:
          (%i1) load("graphs")$
          (%i2) g : make_graph(powerset({1,2,3,4,5}, 2), disjointp)$
          (%i3) is_isomorphic(g, petersen_graph());
          (%o3)                         true
          (%i4) get_vertex_label(1, g);
          (%o4)                        {1, 2}

     Ejemplo 2:
          (%i1) load("graphs")$
          (%i2) f(i, j) := is (mod(j, i)=0)$
          (%i3) g : make_graph(20, f, directed=true)$
          (%i4) out_neighbors(4, g);
          (%o4)                    [8, 12, 16, 20]
          (%i5) in_neighbors(18, g);
          (%o5)                    [1, 2, 3, 6, 9]

 -- Función: mycielski_graph (<g>)
     Devuelve el grafo de Mycielski del grafo <g>.

 -- Función: new_graph ()
     Devuelve el grafo sin vértices ni aristas.

 -- Función: path_digraph (<n>)
     Devuelve el camino dirigido de <n> vértices.

 -- Función: path_graph (<n>)
     Devuelve el camino de <n> vértices.

 -- Función: petersen_graph ()
 -- Función: petersen_graph (<n>, <d>)
     Devuelve el grafo de Petersen <P_{n,d}>.  Los valores por defecto
     para <n> y <d> son ‘n=5’ y ‘d=2’.

 -- Función: random_bipartite_graph (<a>, <b>, <p>)
     Devuelve un grafo aleatorio bipartido a partir de los vértices
     ‘a+b’.  Cada arista se genera con probabilidad <p>.

 -- Función: random_digraph (<n>, <p>)
     Devuelve un grafo aleatorio dirigido de <n> vértices.  Cada arco se
     presenta con una probabilidad <p>.

 -- Función: random_regular_graph (<n>)
 -- Función: random_regular_graph (<n>, <d>)
     Devuelve un grafo aleatorio <d>-regular de <n> vértices.  El valor
     por defecto para <d> es ‘d=3’.

 -- Función: random_graph (<n>, <p>)
     Devuelve un grafo aleatorio de <n> vértices.  Cada arco se presenta
     con una probabilidad <p>.

 -- Función: random_graph1 (<n>, <m>)
     Devuelve un grafo aleatorio de <n> vértices y <m> arcos aleatorios.

 -- Función: random_network (<n>, <p>, <w>)
     Devuelve una red aleatoria de <n> vértices.  Cada arco se presenta
     con probabilidad <p> y tiene un peso dentro del rango ‘[0,w]’.  La
     función devuelve una lista ‘[network, source, sink]’.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) [net, s, t] : random_network(50, 0.2, 10.0);
          (%o2)                         [DIGRAPH, 50, 51]
          (%i3) max_flow(net, s, t)$
          (%i4) first(%);
          (%o4)                   27.65981397932507

 -- Función: random_tournament (<n>)
     Devuelve un torneo aleatorio de <n> vértices.

 -- Función: random_tree (<n>)
     Devuelve un árbol aleatorio de <n> vértices.

 -- Función: small_rhombicosidodecahedron_graph ()
     Devuelve el grafo pequeño rombicosidodecaédrico.

 -- Función: small_rhombicuboctahedron_graph ()
     Devuelve el grafo pequeño rombicocubicooctaédrico.

 -- Función: snub_cube_graph ()
     Devuelve el grafo cúbico volteado.

 -- Función: snub_dodecahedron_graph ()
     Devuelve el grafo dodecaédrico volteado.

 -- Función: truncated_cube_graph ()
     Devuelve el grafo cúbico truncado.

 -- Función: truncated_dodecahedron_graph ()
     Devuelve el grafo dodecaédrico truncado.

 -- Función: truncated_icosahedron_graph ()
     Devuelve el grafo icosaédrico truncado.

 -- Función: truncated_tetrahedron_graph ()
     Devuelve el grafo del tetraedro truncado.

 -- Función: tutte_graph ()
     Devuelve el grafo de Tutte.

 -- Función: underlying_graph (<g>)
     Devuelve el grafo asociado al grafo orientado <g>.

 -- Función: wheel_graph (<n>)
     Devuelve el grafo de rueda de <n+1> vértices.

55.2.2 Propiedades de los grafos
--------------------------------

 -- Función: adjacency_matrix (<gr>)
     Devuelve la matriz de adyacencia del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c5 : cycle_graph(4)$
          (%i3) adjacency_matrix(c5);
                                          [ 0  1  0  1 ]
                                          [            ]
                                          [ 1  0  1  0 ]
          (%o3)                           [            ]
                                          [ 0  1  0  1 ]
                                          [            ]
                                          [ 1  0  1  0 ]

 -- Función: average_degree (<gr>)
     Devuelve el grado medio de los vértices del garfo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) average_degree(grotzch_graph());
                                                40
          (%o2)                                 --
                                                11

 -- Función: biconnected_components (<gr>)
     Devuelve los subconjuntos de vértices biconectados del grafo <gr>.

     Ejemplo:

          (%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]
                      ])$
          (%i3) biconnected_components(g);
          (%o3)               [[6, 7], [4, 5, 6], [1, 2], [2, 3, 4]]


     (Figure graphs13: Grafo con vértices biconectados)

 -- Función: bipartition (<gr>)
     Devuelve una bipartición de los vértices del grafo <gr>, o una
     lista vacía si <gr> no es bipartido.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) h : heawood_graph()$
          (%i3) [A,B]:bipartition(h);
          (%o3)         [[8, 12, 6, 10, 0, 2, 4], [13, 5, 11, 7, 9, 1, 3]]
          (%i4) draw_graph(h, show_vertices=A, program=circular)$


     (Figure graphs02: Bipartición de los vértices de un grafo de
     Heawood)

 -- Función: chromatic_index (<gr>)
     Devuelve el índice cromático del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) chromatic_index(p);
          (%o3)                                  4

 -- Función: chromatic_number (<gr>)
     Devuelve el número cromático del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) chromatic_number(cycle_graph(5));
          (%o2)                                  3
          (%i3) chromatic_number(cycle_graph(6));
          (%o3)                                  2

 -- Función: clear_edge_weight (<e>, <gr>)
     Elimina el peso del arco <e> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : create_graph(3, [[[0,1], 1.5], [[1,2], 1.3]])$
          (%i3) get_edge_weight([0,1], g);
          (%o3)                                 1.5
          (%i4) clear_edge_weight([0,1], g)$
          (%i5) get_edge_weight([0,1], g);
          (%o5)                                  1

 -- Función: clear_vertex_label (<v>, <gr>)
     Elimina la etiqueta del vértice <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : create_graph([[0,"Zero"], [1, "One"]], [[0,1]])$
          (%i3) get_vertex_label(0, g);
          (%o3)                               Zero
          (%i4) clear_vertex_label(0, g);
          (%o4)                               done
          (%i5) get_vertex_label(0, g);
          (%o5)                               false

 -- Función: connected_components (<gr>)
     Devuelve las componentes conexas del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g: graph_union(cycle_graph(5), path_graph(4))$
          (%i3) connected_components(g);
          (%o3)                  [[1, 2, 3, 4, 0], [8, 7, 6, 5]]

 -- Función: diameter (<gr>)
     Devuelve el diámetro del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) diameter(dodecahedron_graph());
          (%o2)                                 5

 -- Función: edge_coloring (<gr>)
     Devuelve una coloración óptima de los arcos del grafo <gr>.

     La función devuelve el índice cromático y una lista que representa
     el coloreado de los arcos de <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) [ch_index, col] : edge_coloring(p);
          (%o3) [4, [[[0, 5], 3], [[5, 7], 1], [[0, 1], 1], [[1, 6], 2],
          [[6, 8], 1], [[1, 2], 3], [[2, 7], 4], [[7, 9], 2], [[2, 3], 2],
          [[3, 8], 3], [[5, 8], 2], [[3, 4], 1], [[4, 9], 4], [[6, 9], 3],
          [[0, 4], 2]]]
          (%i4) assoc([0,1], col);
          (%o4)                           1
          (%i5) assoc([0,5], col);
          (%o5)                           3

 -- Función: degree_sequence (<gr>)
     Devuelve una lista con los grados de los vértices del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) degree_sequence(random_graph(10, 0.4));
          (%o2)            [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]

 -- Función: edge_connectivity (<gr>)
     Devuelve la conectividad de las aristas del grafo <gr>.

     Véase también ‘min_edge_cut’.

 -- Función: edges (<gr>)
     Devuelve la lista de las aristas (arcos) del grafo (dirigido) <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) edges(complete_graph(4));
          (%o2)         [[2, 3], [1, 3], [1, 2], [0, 3], [0, 2], [0, 1]]

 -- Función: get_edge_weight (<e>, <gr>)
 -- Función: get_edge_weight (<e>, <gr>, <ifnot>)
     Devuelve el peso de la arista <e> del grafo <gr>.

     Si la arista no tiene peso, la función devuelve 1.  Si la arista no
     pertenece al grafo, la función emite un mensaje de error o devuelve
     el argumento opcional <ifnot>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c5 : cycle_graph(5)$
          (%i3) get_edge_weight([1,2], c5);
          (%o3)                                 1
          (%i4) set_edge_weight([1,2], 2.0, c5);
          (%o4)                               done
          (%i5) get_edge_weight([1,2], c5);
          (%o5)                                2.0

 -- Función: get_vertex_label (<v>, <gr>)
     Devuelve la etiqueta del vértice <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : create_graph([[0,"Zero"], [1, "One"]], [[0,1]])$
          (%i3) get_vertex_label(0, g);
          (%o3)                               Zero

 -- Función: graph_charpoly (<gr>, <x>)
     Devuelve el polinomio característico (de variable <x>) del grafo
     <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_charpoly(p, x), factor;
                                                   5        4
          (%o3)                     (x - 3) (x - 1)  (x + 2)

 -- Función: graph_center (<gr>)
     Devuelve el centro del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : grid_graph(5,5)$
          (%i3) graph_center(g);
          (%o3)                               [12]

 -- Función: graph_eigenvalues (<gr>)
     Devuelve los valores propios del grafo <gr>.  La función devuelve
     los valores propios en el mismo formato en el que lo hace la
     función ‘eigenvalue’.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_eigenvalues(p);
          (%o3)                     [[3, - 2, 1], [1, 4, 5]]

 -- Función: graph_periphery (<gr>)
     Devuelve la periferia del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : grid_graph(5,5)$
          (%i3) graph_periphery(g);
          (%o3)                          [24, 20, 4, 0]

 -- Función: graph_size (<gr>)
     Devuelve el número de aristas del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_size(p);
          (%o3)                                15

 -- Función: graph_order (<gr>)
     Devuelve el número de vértices del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_order(p);
          (%o3)                                10

 -- Función: girth (<gr>)
     Devuelve la longitud del ciclo más corto del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : heawood_graph()$
          (%i3) girth(g);
          (%o3)                                 6

 -- Función: hamilton_cycle (<gr>)
     Devuelve el ciclo de Hamilton del grafo <gr> o una lista vacía si
     <gr> no es hamiltoniano.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c : cube_graph(3)$
          (%i3) hc : hamilton_cycle(c);
          (%o3)              [7, 3, 2, 6, 4, 0, 1, 5, 7]
          (%i4) draw_graph(c, show_edges=vertices_to_cycle(hc))$


     (Figure graphs03: Ciclo de Hamilton de un grafo cúbico)

 -- Función: hamilton_path (<gr>)
     Devuelve el camino de Hamilton del grafo <gr> o una lista vacía si
     <gr> no los tiene.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) hp : hamilton_path(p);
          (%o3)                  [0, 5, 7, 2, 1, 6, 8, 3, 4, 9]
          (%i4) draw_graph(p, show_edges=vertices_to_path(hp))$


     (Figure graphs04: Camino de Hamilton de un grafo de Petersen)

 -- Función: isomorphism (<gr1>, <gr2>)
     Devuelve un isomorfismo entre los grafos/digrafos <gr1> y <gr2>.
     Si <gr1> y <gr2> no son isomorfos, devuelve una lista vacía.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) clk5:complement_graph(line_graph(complete_graph(5)))$
          (%i3) isomorphism(clk5, petersen_graph());
          (%o3) [9 -> 0, 2 -> 1, 6 -> 2, 5 -> 3, 0 -> 4, 1 -> 5, 3 -> 6,
                                                    4 -> 7, 7 -> 8, 8 -> 9]

 -- Función: in_neighbors (<v>, <gr>)
     Devuelve la lista de los nodos hijos del vértice <v> del grafo
     orientado <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : path_digraph(3)$
          (%i3) in_neighbors(2, p);
          (%o3)                                 [1]
          (%i4) out_neighbors(2, p);
          (%o4)                                 []

 -- Función: is_biconnected (<gr>)
     Devuelve ‘true’ si <gr> está biconectado y ‘false’ en caso
     contrario.

     Ejemplo:

     Example:
          (%i1) load ("graphs")$
          (%i2) is_biconnected(cycle_graph(5));
          (%o2)                         true
          (%i3) is_biconnected(path_graph(5));
          (%o3)                         false

 -- Función: is_bipartite (<gr>)
     Devuelve ‘true’ si <gr> es bipartido (2-coloreable) y ‘false’ en
     caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_bipartite(petersen_graph());
          (%o2)                               false
          (%i3) is_bipartite(heawood_graph());
          (%o3)                               true

 -- Función: is_connected (<gr>)
     Devuelve ‘true’ si el grafo <gr> es conexo y ‘false’ en caso
     contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_connected(graph_union(cycle_graph(4), path_graph(3)));
          (%o2)                               false

 -- Función: is_digraph (<gr>)
     Devuelve ‘true’ si <gr> es un grafo orientado (digrafo) y ‘false’
     en caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_digraph(path_graph(5));
          (%o2)                               false
          (%i3) is_digraph(path_digraph(5));
          (%o3)                               true

 -- Función: is_edge_in_graph (<e>, <gr>)
     Devuelve ‘true’ si <e> es una arista (arco) del grafo (digrafo) <g>
     y ‘false’ en caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c4 : cycle_graph(4)$
          (%i3) is_edge_in_graph([2,3], c4);
          (%o3)                               true
          (%i4) is_edge_in_graph([3,2], c4);
          (%o4)                               true
          (%i5) is_edge_in_graph([2,4], c4);
          (%o5)                               false
          (%i6) is_edge_in_graph([3,2], cycle_digraph(4));
          (%o6)                               false

 -- Función: is_graph (<gr>)
     Devuelve ‘true’ si <gr> es un grafo y ‘false’ en caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_graph(path_graph(5));
          (%o2)                               true
          (%i3) is_graph(path_digraph(5));
          (%o3)                               false

 -- Función: is_graph_or_digraph (<gr>)
     Devuelve ‘true’ si <gr> es una grafo, orientado o no, y ‘false’ en
     caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_graph_or_digraph(path_graph(5));
          (%o2)                               true
          (%i3) is_graph_or_digraph(path_digraph(5));
          (%o3)                               true

 -- Función: is_isomorphic (<gr1>, <gr2>)
     Devuelve ‘true’ si los grafos/digrafos <gr1> y <gr2> son isomorfos
     y ‘false’ en caso contrario.

     Véase también ‘isomorphism’.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) clk5:complement_graph(line_graph(complete_graph(5)))$
          (%i3) is_isomorphic(clk5, petersen_graph());
          (%o3)                         true

 -- Función: is_planar (<gr>)
     Devuelve ‘true’ si <gr> es un grafo planar y ‘false’ en caso
     contrario.

     El algoritmo utilizado es el de Demoucron, que es de tiempo
     cuadrático.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_planar(dodecahedron_graph());
          (%o2)                                true
          (%i3) is_planar(petersen_graph());
          (%o3)                                false
          (%i4) is_planar(petersen_graph(10,2));
          (%o4)                                true

 -- Función: is_sconnected (<gr>)
     Devuelve ‘true’ si el grafo orientado <gr> es fuertemente conexo,
     devolviendo ‘false’ en caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_sconnected(cycle_digraph(5));
          (%o2)                               true
          (%i3) is_sconnected(path_digraph(5));
          (%o3)                               false

 -- Función: is_vertex_in_graph (<v>, <gr>)
     Devuelve ‘true’ si <v> es un vértice del grafo <g> y ‘false’ en
     caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c4 : cycle_graph(4)$
          (%i3) is_vertex_in_graph(0, c4);
          (%o3)                               true
          (%i4) is_vertex_in_graph(6, c4);
          (%o4)                               false

 -- Función: is_tree (<gr>)
     Devuelve ‘true’ si <gr> es un árbol y ‘false’ en caso contrario.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) is_tree(random_tree(4));
          (%o2)                               true
          (%i3) is_tree(graph_union(random_tree(4), random_tree(5)));
          (%o3)                               false

 -- Función: laplacian_matrix (<gr>)
     Devuelve el laplaciano de la matriz del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) laplacian_matrix(cycle_graph(5));
                                    [  2   - 1   0    0   - 1 ]
                                    [                         ]
                                    [ - 1   2   - 1   0    0  ]
                                    [                         ]
          (%o2)                     [  0   - 1   2   - 1   0  ]
                                    [                         ]
                                    [  0    0   - 1   2   - 1 ]
                                    [                         ]
                                    [ - 1   0    0   - 1   2  ]

 -- Función: max_clique (<gr>)
     Devuelve el clique máximo del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : random_graph(100, 0.5)$
          (%i3) max_clique(g);
          (%o3)       [6, 12, 31, 36, 52, 59, 62, 63, 80]

 -- Función: max_degree (<gr>)
     Devuelve el grado máximo de los vértices del grafo <gr> y un
     vértice de grado máximo.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : random_graph(100, 0.02)$
          (%i3) max_degree(g);
          (%o3)                        [6, 79]
          (%i4) vertex_degree(95, g);
          (%o4)                           3

 -- Función: max_flow (<net>, <s>, <t>)
     Devuelve el flujo maximal de la red <net> con origen en <s> y final
     en <t>.

     La función devuelve el valor del flujo maximal y una lista con los
     pesos de los arcos del flujo óptimo.

     Ejemplo:

     Example:
          (%i1) load ("graphs")$
          (%i2) net : create_graph(
            [1,2,3,4,5,6],
            [[[1,2], 1.0],
             [[1,3], 0.3],
             [[2,4], 0.2],
             [[2,5], 0.3],
             [[3,4], 0.1],
             [[3,5], 0.1],
             [[4,6], 1.0],
             [[5,6], 1.0]],
            directed=true)$
          (%i3) [flow_value, flow] : max_flow(net, 1, 6);
          (%o3) [0.7, [[[1, 2], 0.5], [[1, 3], 0.2], [[2, 4], 0.2],
          [[2, 5], 0.3], [[3, 4], 0.1], [[3, 5], 0.1], [[4, 6], 0.3],
          [[5, 6], 0.4]]]
          (%i4) fl : 0$
          (%i5) for u in out_neighbors(1, net)
                   do fl : fl + assoc([1, u], flow)$
          (%i6) fl;
          (%o6)                                 0.7

 -- Función: max_independent_set (<gr>)
     Devuelve un conjunto maximal independiente de vértices del grafo
     <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) d : dodecahedron_graph()$
          (%i3) mi : max_independent_set(d);
          (%o3)             [0, 3, 5, 9, 10, 11, 18, 19]
          (%i4) draw_graph(d, show_vertices=mi)$


     (Figure graphs05: Conjunto maximal independiente de un grafo
     dodecaédrico)

 -- Función: max_matching (<gr>)
     Devuelve un conjunto maximal independiente de aristas del grafo
     <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) d : dodecahedron_graph()$
          (%i3) m : max_matching(d);
          (%o3) [[5, 7], [8, 9], [6, 10], [14, 19], [13, 18], [12, 17],
                                         [11, 16], [0, 15], [3, 4], [1, 2]]
          (%i4) draw_graph(d, show_edges=m)$


     (Figure graphs06: Conjunto maximal independiente de aristas de un
     grafo dodecaédrico)

 -- Función: min_degree (<gr>)
     Devuelve el grado mínimo de los vértices del grafo <gr> y un
     vértice de grado mínimo.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : random_graph(100, 0.1)$
          (%i3) min_degree(g);
          (%o3)                              [3, 49]
          (%i4) vertex_degree(21, g);
          (%o4)                                 9

 -- Función: min_edge_cut (<gr>)
     Devuelve el mínimo edge cut del grafo <gr>.  Un edge cut es un
     conjunto de aristas cuya eliminación aumenta el número de
     componentes del grafo.

     Véase también ‘edge_connectivity’.

 -- Función: min_vertex_cover (<gr>)
     Devuelve el mínimo nodo covering del grafo <gr>.

 -- Función: min_vertex_cut (<gr>)
     Devuelve el mínimo vertex cut del grafo <gr>.

     Véase también ‘vertex_connectivity’.

 -- Función: minimum_spanning_tree (<gr>)
     Devuelve el grafo de expansión mínimo del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : graph_product(path_graph(10), path_graph(10))$
          (%i3) t : minimum_spanning_tree(g)$
          (%i4) draw_graph(g, show_edges=edges(t))$


     (Figure graphs07: Grafo de expansión mínimo de un grafo
     rectangular)

 -- Función: neighbors (<v>, <gr>)
     Devuelve la lista de los vecinos del vértice <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) neighbors(3, p);
          (%o3)                             [4, 8, 2]

 -- Función: odd_girth (<gr>)
     Devuelve la longitud del ciclo impar más corto del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : graph_product(cycle_graph(4), cycle_graph(7))$
          (%i3) girth(g);
          (%o3)                                 4
          (%i4) odd_girth(g);
          (%o4)                                 7

 -- Función: out_neighbors (<v>, <gr>)
     Devuelve la lista de los nodos padres del vértice <v> del grafo
     orientado <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : path_digraph(3)$
          (%i3) in_neighbors(2, p);
          (%o3)                                 [1]
          (%i4) out_neighbors(2, p);
          (%o4)                                 []

 -- Función: planar_embedding (<gr>)
     Devuelve la lista de caminos faciales en una proyección planar de
     <gr>, o ‘false’ si <gr> no es un grafo planar.

     El grafo <gr> debe estar biconectado.

     El algoritmo utilizado es el de Demoucron, que es de tiempo
     cuadrático.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) planar_embedding(grid_graph(3,3));
          (%o2) [[3, 6, 7, 8, 5, 2, 1, 0], [4, 3, 0, 1], [3, 4, 7, 6],
                                                [8, 7, 4, 5], [1, 2, 5, 4]]

 -- Función: print_graph (<gr>)
     Muestra alguna información sobre el grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c5 : cycle_graph(5)$
          (%i3) print_graph(c5)$
          Graph on 5 vertices with 5 edges.
          Adjacencies:
            4 :  0  3
            3 :  4  2
            2 :  3  1
            1 :  2  0
            0 :  4  1
          (%i4) dc5 : cycle_digraph(5)$
          (%i5) print_graph(dc5)$
          Digraph on 5 vertices with 5 arcs.
          Adjacencies:
            4 :  0
            3 :  4
            2 :  3
            1 :  2
            0 :  1
          (%i6) out_neighbors(0, dc5);
          (%o6)                                [1]

 -- Función: radius (<gr>)
     Devuelve el radio del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) radius(dodecahedron_graph());
          (%o2)                                 5

 -- Función: set_edge_weight (<e>, <w>, <gr>)
     Asigna el peso <w> a la arista <e> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : create_graph([1, 2], [[[1,2], 1.2]])$
          (%i3) get_edge_weight([1,2], g);
          (%o3)                                1.2
          (%i4) set_edge_weight([1,2], 2.1, g);
          (%o4)                               done
          (%i5) get_edge_weight([1,2], g);
          (%o5)                                2.1

 -- Función: set_vertex_label (<v>, <l>, <gr>)
     Asigna la etiqueta <l> al vértice <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : create_graph([[1, "One"], [2, "Two"]], [[1,2]])$
          (%i3) get_vertex_label(1, g);
          (%o3)                                One
          (%i4) set_vertex_label(1, "oNE", g);
          (%o4)                               done
          (%i5) get_vertex_label(1, g);
          (%o5)                                oNE

 -- Función: shortest_path (<u>, <v>, <gr>)
     Devuelve el camino más corto desde <u> hasta <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) d : dodecahedron_graph()$
          (%i3) path : shortest_path(0, 7, d);
          (%o3)                          [0, 1, 19, 13, 7]
          (%i4) draw_graph(d, show_edges=vertices_to_path(path))$


     (Figure graphs08: Camino más corto entre dos vértices de un grafo
     dodecaédrico)

 -- Función: shortest_weighted_path (<u>, <v>, <gr>)
     Devuelve la longitud del camino más corto ponderado y el propio
     camino más corto ponderado desde <u> hasta <v> en el grafo <gr>.

     La longitud del camino ponderado es la suma de los pesos de las
     aristas del camino.  Si una arista no tiene peso asignado, su valor
     por defecto es la unidad.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g: petersen_graph(20, 2)$
          (%i3) for e in edges(g) do set_edge_weight(e, random(1.0), g)$
          (%i4) shortest_weighted_path(0, 10, g);
          (%o4) [2.575143920268482, [0, 20, 38, 36, 34, 32, 30, 10]]

 -- Función: strong_components (<gr>)
     Devuelve las componentes fuertes del grafo orientado <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) t : random_tournament(4)$
          (%i3) strong_components(t);
          (%o3)                         [[1], [0], [2], [3]]
          (%i4) vertex_out_degree(3, t);
          (%o4)                                 3

 -- Función: topological_sort (<dag>)
     Devuelve el orden topológico de los vértices del grafo orientado
     <dag> o una lista vacía si <dag> no es un grafo orientado acíclico.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g:create_graph(
                   [1,2,3,4,5],
                   [
                    [1,2], [2,5], [5,3],
                    [5,4], [3,4], [1,3]
                   ],
                   directed=true)$
          (%i3) topological_sort(g);
          (%o3)                           [1, 2, 5, 3, 4]

 -- Función: vertex_connectivity (<g>)
     Devuelve la conectividad de los vértices del grafo <g>.

     Véase también ‘min_vertex_cut’.

 -- Función: vertex_degree (<v>, <gr>)
     Devuelve el grado del vértice <v> del grafo <gr>.

 -- Función: vertex_distance (<u>, <v>, <gr>)
     Devuelve la longitud del camino más corto entre <u> y <v> del grafo
     o digrafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) d : dodecahedron_graph()$
          (%i3) vertex_distance(0, 7, d);
          (%o3)                                 4
          (%i4) shortest_path(0, 7, d);
          (%o4)                         [0, 1, 19, 13, 7]

 -- Función: vertex_eccentricity (<v>, <gr>)
     Devuelve la excentricidad del vértice <v> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g:cycle_graph(7)$
          (%i3) vertex_eccentricity(0, g);
          (%o3)                           3

 -- Función: vertex_in_degree (<v>, <gr>)
     Devuelve el grado de entrada del vértice <v> del grafo orientado
     <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p5 : path_digraph(5)$
          (%i3) print_graph(p5)$
          Digraph on 5 vertices with 4 arcs.
          Adjacencies:
            4 :
            3 :  4
            2 :  3
            1 :  2
            0 :  1
          (%i4) vertex_in_degree(4, p5);
          (%o4)                                 1
          (%i5) in_neighbors(4, p5);
          (%o5)                                [3]

 -- Función: vertex_out_degree (<v>, <gr>)
     Devuelve el grado de salida del vértice <v> del grafo orientado
     <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) t : random_tournament(10)$
          (%i3) vertex_out_degree(0, t);
          (%o3)                           2
          (%i4) out_neighbors(0, t);
          (%o4)                        [7, 1]

 -- Función: vertices (<gr>)
     Devuelve la lista de vértices del grafo <gr>.

     Example

          (%i1) load ("graphs")$
          (%i2) vertices(complete_graph(4));
          (%o2)                           [3, 2, 1, 0]

 -- Función: vertex_coloring (<gr>)
     Devuelve un coloreado óptimo de los vértices del grafo <gr>.

     La función devuelve el número cromático y una lista representando
     el coloreado de los vértices de <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p:petersen_graph()$
          (%i3) vertex_coloring(p);
          (%o3) [3, [[0, 2], [1, 3], [2, 2], [3, 3], [4, 1], [5, 3],
                                           [6, 1], [7, 1], [8, 2], [9, 2]]]

 -- Función: wiener_index (<gr>)
     Devuelve el índice de Wiener del grafo <gr>.

     Ejemplo:

          (%i1) wiener_index(dodecahedron_graph());
          (%o1)                          500

55.2.3 Modificación de grafos
-----------------------------

 -- Función: add_edge (<e>, <gr>)
     Añade la arista <e> al grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p : path_graph(4)$
          (%i3) neighbors(0, p);
          (%o3)                                [1]
          (%i4) add_edge([0,3], p);
          (%o4)                               done
          (%i5) neighbors(0, p);
          (%o5)                              [3, 1]

 -- Función: add_edges (<e_list>, <gr>)
     Añade las aristas de la lista <e_list> al grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : empty_graph(3)$
          (%i3) add_edges([[0,1],[1,2]], g)$
          (%i4) print_graph(g)$
          Graph on 3 vertices with 2 edges.
          Adjacencies:
            2 :  1
            1 :  2  0
            0 :  1

 -- Función: add_vertex (<v>, <gr>)
     Añade el vértice <v> al grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : path_graph(2)$
          (%i3) add_vertex(2, g)$
          (%i4) print_graph(g)$
          Graph on 3 vertices with 1 edges.
          Adjacencies:
            2 :
            1 :  0
            0 :  1

 -- Función: add_vertices (<v_list>, <gr>)
     Añade los vértices de la lista <v_list> al grafo <gr>.

 -- Función: connect_vertices (<v_list>, <u_list>, <gr>)
     Conecta todos los vértices de la lista <v_list> con los vértices de
     la lista <u_list> del grafo <gr>.

     <v_list> y <u_list> pueden ser vértices aislados o una lista de
     vértices.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g : empty_graph(4)$
          (%i3) connect_vertices(0, [1,2,3], g)$
          (%i4) print_graph(g)$
          Graph on 4 vertices with 3 edges.
          Adjacencies:
            3 :  0
            2 :  0
            1 :  0
            0 :  3  2  1

 -- Función: contract_edge (<e>, <gr>)
     Contrae la arista <e> del <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) g: create_graph(
                 8, [[0,3],[1,3],[2,3],[3,4],[4,5],[4,6],[4,7]])$
          (%i3) print_graph(g)$
          Graph on 8 vertices with 7 edges.
          Adjacencies:
            7 :  4
            6 :  4
            5 :  4
            4 :  7  6  5  3
            3 :  4  2  1  0
            2 :  3
            1 :  3
            0 :  3
          (%i4) contract_edge([3,4], g)$
          (%i5) print_graph(g)$
          Graph on 7 vertices with 6 edges.
          Adjacencies:
            7 :  3
            6 :  3
            5 :  3
            3 :  5  6  7  2  1  0
            2 :  3
            1 :  3
            0 :  3

 -- Función: remove_edge (<e>, <gr>)
     Elimina la arista <e> del grafo <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) c3 : cycle_graph(3)$
          (%i3) remove_edge([0,1], c3)$
          (%i4) print_graph(c3)$
          Graph on 3 vertices with 2 edges.
          Adjacencies:
            2 :  0  1
            1 :  2
            0 :  2

 -- Función: remove_vertex (<v>, <gr>)
     Elimina el vértice <v> del grafo <gr>.

 -- Función: vertex_coloring (<gr>)
     Devuelve un coloreado óptimo de los vértice del grafo <gr>.

     La función devuelve el número cromático y una lista representando
     el coloreado de los vértices de <gr>.

     Ejemplo:

          (%i1) load ("graphs")$
          (%i2) p:petersen_graph()$
          (%i3) vertex_coloring(p);
          (%o3) [3, [[0, 2], [1, 3], [2, 2], [3, 3], [4, 1], [5, 3],
                                          [6, 1], [7, 1], [8, 2], [9, 2]]]

55.2.4 Lectura y escritura de ficheros
--------------------------------------

 -- Función: dimacs_export (<gr>, <fl>)
 -- Función: dimacs_export (<gr>, <fl>, <comment1>, ..., <commentn>)
     Exporta el grafo al fichero <fl> en formato DIMACS. Los comentarios
     adicionales se anãdirán al comienzo del fichero.

 -- Función: dimacs_import (<fl>)
     Lee el grafo almacenado en el fichero <fl> en formato DIMACS.

 -- Función: graph6_decode (<str>)
     Devuelve el grafo codificado en formato graph6 en la cadena <str>.

 -- Función: graph6_encode (<gr>)
     Devuelve una cadena codificando el grafo <gr> en formato graph6.

 -- Función: graph6_export (<gr_list>, <fl>)
     Exporta los grafos de la lista <gr_list> al fichero <fl> en formato
     graph6.

 -- Función: graph6_import (<fl>)
     Lee la lista de grafos almacenados en el fichero <fl> en formato
     graph6.

 -- Función: sparse6_decode (<str>)
     Devuelve el grafo codificado en formato sparse6 en la cadena <str>.

 -- Función: sparse6_encode (<gr>)
     Devuelve una cadena codificando el grafo <gr> en formato sparse6.

 -- Función: sparse6_export (<gr_list>, <fl>)
     Exporta los grafos de la lista <gr_list> al fichero <fl> en formato
     sparse6.

 -- Función: sparse6_import (<fl>)
     Lee la lista de grafos almacenados en el fichero <fl> en formato
     sparse6.

55.2.5 Visualización
--------------------

 -- Función: draw_graph (<graph>)
 -- Función: draw_graph (<graph>, <option1>, ..., <optionk>)
     Dibuja el grafo utilizando el paquete ‘draw’.

     El algoritmo utilizado para posicionar los vértices se especifica
     con el argumento opcional <program>, cuyo valor por defecto es
     ‘program=spring_embedding’.  <draw_graph> también puede utilizar
     los programas de graphviz para posicionar los vértices, para lo
     cual deberá instalarse separadamente el programa graphviz.

     Ejemplo 1:

          (%i1) load ("graphs")$
          (%i2) g:grid_graph(10,10)$
          (%i3) m:max_matching(g)$
          (%i4) draw_graph(g,
             spring_embedding_depth=100,
             show_edges=m, edge_type=dots,
             vertex_size=0)$


     (Figure graphs09: Ejemplo de uso de draw_graph para dibujar un
     grafo)

     Ejemplo 2:

          (%i1) load ("graphs")$
          (%i2) g:create_graph(16,
              [
               [0,1],[1,3],[2,3],[0,2],[3,4],[2,4],
               [5,6],[6,4],[4,7],[6,7],[7,8],[7,10],[7,11],
               [8,10],[11,10],[8,9],[11,12],[9,15],[12,13],
               [10,14],[15,14],[13,14]
              ])$
          (%i3) t:minimum_spanning_tree(g)$
          (%i4) draw_graph(
              g,
              show_edges=edges(t),
              show_edge_width=4,
              show_edge_color=green,
              vertex_type=filled_square,
              vertex_size=2
              )$


     (Figure graphs10: Ejemplo de uso de draw_graph para dibujar un
     grafo)

     Ejemplo 3:

          (%i1) load ("graphs")$
          (%i2) mi : max_independent_set(g)$
          (%i3) draw_graph(
              g,
              show_vertices=mi,
              show_vertex_type=filled_up_triangle,
              show_vertex_size=2,
              edge_color=cyan,
              edge_width=3,
              =true,
              text_color=brown
              )$


     (Figure graphs11: Ejemplo de uso de draw_graph para dibujar un
     grafo)

     Ejemplo 4:

          (%i1) load ("graphs")$
          (%i2) net : create_graph(
              [0,1,2,3,4,5],
              [
               [[0,1], 3], [[0,2], 2],
               [[1,3], 1], [[1,4], 3],
               [[2,3], 2], [[2,4], 2],
               [[4,5], 2], [[3,5], 2]
              ],
              directed=true
              )$
          (%i3) draw_graph(
              net,
              show_weight=true,
              vertex_size=0,
              show_vertices=[0,5],
              show_vertex_type=filled_square,
              head_length=0.2,
              head_angle=10,
              edge_color="dark-green",
              text_color=blue
              )$


     (Figure graphs12: Ejemplo de uso de draw_graph para dibujar un
     grafo)

     Ejemplo 5:

          (%i1) load("graphs")$
          (%i2) g: petersen_graph(20, 2);
          (%o2)                         GRAPH
          (%i3) draw_graph(g, redraw=true, program=planar_embedding);
          (%o3)                         done


     (Figure graphs14: Ejemplo de uso de draw_graph para dibujar un
     grafo)

     Ejemplo 6:

          (%i1) load("graphs")$
          (%i2) t: tutte_graph();
          (%o2)                         GRAPH
          (%i3) draw_graph(t, redraw=true,
                              fixed_vertices=[1,2,3,4,5,6,7,8,9]);
          (%o3)                         done


     (Figure graphs15: Ejemplo de uso de draw_graph para dibujar un
     grafo)

 -- Variable opcional: draw_graph_program
     Valor por defecto: <spring_embedding>

     Programa a utilizar por defecto para posicionar los vértices en la
     función ‘draw_graph’.

 -- Opción de draw_graph: show_id
     Valor por defecto: <false>

     Si <show_id> vale <true> entonces se muestran los números
     identificadores de los vértices.

 -- Opción de draw_graph: show_label
     Valor por defecto: <false>

     Si <show_label> vale <true> entonces se muestran las etiquetas de
     los vértices.

 -- Opción de draw_graph: label_alignment
     Valor por defecto: <center>

     Indica cómo se deben alinear las etiquetas o números
     identificadores de los vértices.  Puede ser: ‘left’, ‘center’ or
     ‘right’.

 -- Opción de draw_graph: show_weight
     Valor por defecto: <false>

     si <show_weight> vale <true> entonces se mostrarán los pesos de las
     aristas.

 -- Opción de draw_graph: vertex_type
     Valor por defecto: <circle>

     Establece cómo se mostrarán los vértices.  Véase la opción
     <point_type> del paquete ‘draw’.

 -- Opción de draw_graph: vertex_size
     Tamanõ de los vértices.

 -- Opción de draw_graph: vertex_color
     Color a utilizar en los vértices.

 -- Opción de draw_graph: show_vertices
     Valor por defecto: []

     Dibuja los vértices seleccionados en la lista con colores
     diferentes.

 -- Opción de draw_graph: show_vertex_type
     Establece cómo se mostrarán los vértices de <show_vertices>.  Véase
     la opción <point_type> del paquete ‘draw’.

 -- Opción de draw_graph: show_vertex_size
     Tamanõs de los vértices de <show_vertices>.

 -- Opción de draw_graph: show_vertex_color
     Color a utilizar en los vértices de la lista <show_vertices>.

 -- Opción de draw_graph: vertex_partition
     Valor por defecto: []

     Una partición ‘[[v1,v2,...],...,[vk,...,vn]]’ de los vértices del
     grafo.  Los vértices de cada lista se dibujarán de diferente color.

 -- Opción de draw_graph: vertex_coloring
     Colores de los vértices.  Los colores <col> deben especificarse en
     el mismo formato que el devuelto por <vertex_coloring>.

 -- Opción de draw_graph: edge_color
     Color a utilizar en las aristas.

 -- Opción de draw_graph: edge_width
     Ancho de las aristas.

 -- Opción de draw_graph: edge_type
     Establece cómo se dibujarán las aristas.  Véase la opción
     <line_type> del paquete ‘draw’.

 -- Opción de draw_graph: show_edges
     Dibuja las aristas de la lista <e_list> con colores diferentes.

 -- Opción de draw_graph: show_edge_color
     Color a utilizar en las aristas de la lista <show_edges>.

 -- Opción de draw_graph: show_edge_width
     Anchos de las aristas de <show_edges>.

 -- Opción de draw_graph: show_edge_type
     Establece cómo se dibujarán las aristas de <show_edges>.  Véase la
     opción <line_type> del paquete ‘draw’.

 -- Opción de draw_graph: edge_partition
     Una partición ‘[[e1,e2,...],...,[ek,...,em]]’ de las aristas del
     grafo.  Las aristas de cada lista se dibujarán de diferente color.

 -- Opción de draw_graph: edge_coloring
     Colores de las aristas.  Los colores <col> deben especificarse en
     el mismo formato que el devuelto por <edge_coloring>.

 -- Opción de draw_graph: redraw
     Valor por defecto: <false>

     Si <redraw> vale ‘true’, las posiciones de los vértices se
     recalculan incluso si las posiciones están almacenadas de un dibujo
     previo del grafo.

 -- Opción de draw_graph: head_angle
     Valor por defecto: 15

     Ángulo de las flechas de los arcos en los grafos orientados.

 -- Opción de draw_graph: head_length
     Valor por defecto: 0.1

     Longitud de las flechas de los arcos en los grafos orientados.

 -- Opción de draw_graph: spring_embedding_depth
     Valor por defecto: 50

     Número de iteraciones del algoritmo de dibujo de grafos.

 -- Opción de draw_graph: terminal
     Terminal utilizado para ver el gráfo.  Véase la opción <terminal>
     del paquete ‘draw’.

 -- Opción de draw_graph: file_name
     Nombre del fichero cuando el terminal especificado no es la
     pantalla.

 -- Opción de draw_graph: program
     establece el programa para posicionado de vértices del grafo.
     Puede ser cualquiera de los programas graphviz (dot, neato, twopi,
     circ, fdp), <circular> o <spring_embedding> o <planar_embedding>;
     <planar_embedding> sĺo está disponible para grafos planares
     2-conectados.  Si ‘program=spring_embedding’, se puede especificar
     un conjunto de vértices de posición fija con la opción
     <fixed_vertices>.

 -- Opción de draw_graph: fixed_vertices
     Especifica una lista de vértices con posiciones fijas en un
     polígono regular.  Se puede utilizar cuando
     ‘program=spring_embedding’.

 -- Función: vertices_to_path (<v_list>)
     Convierte una lista <v_list> de vértices en la lista de aristas del
     camino definido por la propia <v_list>.

 -- Función: vertices_to_cycle (<v_list>)
     Convierte una lista <v_list> de vértices en la lista de aristas del
     ciclo definido por la propia <v_list>.


File: maxima.info,  Node: grobner,  Next: impdiff,  Prev: graphs,  Up: Top

56 grobner
**********

* Menu:

* Introducción a grobner::
* Funciones y variables para grobner::


File: maxima.info,  Node: Introducción a grobner,  Next: Funciones y variables para grobner,  Prev: Top,  Up: Top

56.1 Introducción a grobner
===========================

‘grobner’ es un paquete para operar con bases de Groebner en Maxima.

Para hacer uso de las funciones de este paquete es necesario cargar
previamente el archivo ‘grobner.lisp’:

     load("grobner");

Es posible ejecutar una demostración haciendo
     demo("grobner.demo");

o
     batch("grobner.demo")

Algunos de los cálculos de la demostración pueden llevar tiempo, razón
por la cual sus resultados se han guardado en el archivo
‘grobner-demo.output’, que se encuentra en el mismo directorio que el
archivo de demostración.

56.1.1 Notas sobre el paquete grobner
-------------------------------------

El autor del paquete es

Marek Rychlik

<http://alamos.math.arizona.edu>

habiendo sido distribuido el 24-05-2002 bajo los términos de la General
Public License (GPL) (ver archivo ‘grobner.lisp’).  Esta documentación
ha sido extraída de los archivos
‘README’, ‘grobner.lisp’, ‘grobner.demo’ y ‘grobner-demo.output’

por Günter Nowak.  Las sugerencias para mejorar la documentación se
pueden hacer en la lista de correos de _maxima_,
<maxima@math.utexas.edu>.

El código está algo anticuado.  Las implementaciones modernas utilizan
el algoritmo _F4_, más rápido, descrito en
A new efficient algorithm for computing Gröbner bases (F4)
Jean-Charles Faugère
LIP6/CNRS Université Paris VI
January 20, 1999

56.1.2 Implementaciones de órdenes admisibles de monomios
---------------------------------------------------------

   • ‘lex’

     lexicográfico puro; orden por defecto para la comparación de
     monomios.
   • ‘grlex’

     grado total, con empates resueltos por el orden lexicográfico.

   • ‘grevlex’

     grado total, con empates resueltos por el orden lexicográfico
     inverso.

   • ‘invlex’

     orden lexicográfico inverso.


File: maxima.info,  Node: Funciones y variables para grobner,  Prev: Introducción a grobner,  Up: Top

56.2 Funciones y variables para grobner
=======================================

56.2.1 Variables opcionales
---------------------------

 -- Variable opcional: poly_monomial_order
     Valor por defecto: ‘lex’

     Controla qué orden de monomios utiliza en los cálculos con
     polinomios y bases de Groebner.  Si no se le asigna valor alguno,
     se utilizará ‘lex’.

 -- Variable opcional: poly_coefficient_ring
     Valor por defecto: ‘expression_ring’

     Indica el anillo de coeficientes de los polinomios que se va a
     utilizar en los cálculos.  Si no se le asigna ningún valor, se
     utilizará el anillo de expresiones propio de _maxima_.  A esta
     variable se le puede asignar el valor ‘ring_of_integers’.

 -- Variable opcional: poly_primary_elimination_order
     Valor por defecto: ‘false’

     Nombre del orden por defecto para las variables eliminadas en las
     funciones basadas en eliminaciones.  Si no se le asigna ningún
     valor, se utilizará ‘lex’.

 -- Variable opcional: poly_secondary_elimination_order
     Valor por defecto: ‘false’

     Nombre del orden por defecto para las variables almacenadas en
     funciones basadas en eliminaciones.  Si no se le asigna ningún
     valor, se utilizará ‘lex’.

 -- Variable opcional: poly_elimination_order
     Valor por defecto: ‘false’

     Nombre del orden de eliminación por defecto utilizado en los
     cálculos de eliminación.  Si se le asigna un valor, ignorará los
     guardados en ‘poly_primary_elimination_order’ y
     ‘poly_secondary_elimination_order’.  El usuario se asegurará que
     este es un orden válido de eliminación.

 -- Variable opcional: poly_return_term_list
     Valor por defecto: ‘false’

     Si vale ‘true’, todas las funciones de este paquete devolverán los
     polinomios como una lista de términos en el orden activo de
     monomios, en lugar de una expresión ordinaria de _maxima_.

 -- Variable opcional: poly_grobner_debug
     Valor por defecto: ‘false’

     Si vale ‘true’, genera una salida de seguimiento y depuración.

 -- Variable opcional: poly_grobner_algorithm
     Valor por defecto: ‘buchberger’

     Valores posibles:
        • ‘buchberger’
        • ‘parallel_buchberger’
        • ‘gebauer_moeller’

     Es el nombre del algoritmo utilizado para encontrar las bases de
     Groebner.

 -- Variable opcional: poly_top_reduction_only
     Valor por defecto: ‘false’

     Si no vale ‘false’, siempre que sea posible el algoritmo de
     división se detendrá tras la primera reducción.

56.2.2 Operadores simples
-------------------------

‘poly_add’, ‘poly_subtract’, ‘poly_multiply’ y ‘poly_expt’ son los
operadores aritméticos para polinomios.  Se ejecutan utilizando la
representación interna, pero los resultados se devuelven en forma de
expresión ordinaria de _maxima_.

 -- Función: poly_add (<poly1>, <poly2>, <varlist>)
     Suma los polinomios <poly1> y <poly2>.

          (%i1) poly_add(z+x^2*y,x-z,[x,y,z]);
                                              2
          (%o1)                              x  y + x

 -- Función: poly_subtract (<poly1>, <poly2>, <varlist>)
     Resta el polinomio <poly2> de <poly1>.

          (%i1) poly_subtract(z+x^2*y,x-z,[x,y,z]);
                                                2
          (%o1)                          2 z + x  y - x

 -- Función: poly_multiply (<poly1>, <poly2>, <varlist>)
     Multiplica <poly1> por <poly2>.

          (%i2) poly_multiply(z+x^2*y,x-z,[x,y,z])-(z+x^2*y)*(x-z),expand;
          (%o1)                                  0

 -- Función: poly_s_polynomial (<poly1>, <poly2>, <varlist>)
     Devuelve el _polinomio syzygy_ (_S-polinomio_) de dos polinomios
     <poly1> y <poly2>.

 -- Función: poly_primitive_part (<poly1>, <varlist>)
     Devuelve el polinomio <poly> dividido por el MCD de sus
     coeficientes.

          (%i1) poly_primitive_part(35*y+21*x,[x,y]);
          (%o1)                              5 y + 3 x

 -- Función: poly_normalize (<poly>, <varlist>)
     Devuelve el polinomio <poly> dividido por el coeficiente principal.
     Da por supuesto que la división es posible, lo cual puede no ser
     siempre cierto en anillos que no son campos.

56.2.3 Otras funciones
----------------------

 -- Función: poly_expand (<poly>, <varlist>)
     Esta función expande los polinomios.  Equivale a ‘expand(<poly>)’
     si <poly> es un polinomio.  Si la representación no es compatible
     con un polinomio de variables <varlist>, devuelve un error.

          (%i1) poly_expand((x-y)*(y+x),[x,y]);
                                               2    2
          (%o1)                               x  - y
          (%i2) poly_expand((y+x)^2,[x,y]);
                                          2            2
          (%o2)                          y  + 2 x y + x
          (%i3) poly_expand((y+x)^5,[x,y]);
                            5      4         2  3       3  2      4      5
          (%o3)            y  + 5 x y  + 10 x  y  + 10 x  y  + 5 x  y + x
          (%i4) poly_expand(-1-x*exp(y)+x^2/sqrt(y),[x]);
                                                    2
                                            y      x
          (%o4)                       - x %e  + ------- - 1
                                                 sqrt(y)

          (%i5) poly_expand(-1-sin(x)^2+sin(x),[sin(x)]);
                                          2
          (%o5)                      - sin (x) + sin(x) - 1


 -- Función: poly_expt (<poly>, <number>, <varlist>)
     Eleva el polinomio <poly> a la potencia <number>, siendo este un
     entero positivo.  Si <number> no es un número entero positivo,
     devolverá un error.

          (%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand;
          (%o1)                                  0

 -- Función: poly_content (<poly>. <varlist>)
     ‘poly_content’ calcula el MCD de los coeficientes.

          (%i1) poly_content(35*y+21*x,[x,y]);
          (%o1)                                  7

 -- Función: poly_pseudo_divide (<poly>, <polylist>, <varlist>)
     Realiza la seudo-división del polinomio <poly> por la lista de n
     polinomios de <polylist>.  Devuelve varios resultados.  El primer
     resultado es una lista de cocientes a.  El segundo resultado es el
     resto r.  El tercer resultado es un coeficiente escalar c, tal que
     c*poly puede dividirse por <polylist> dentro del anillo de
     coeficientes, el cual no es necesariamente un campo.  Por último,
     el cuarto resultado es un entero que guarda el recuento de
     reducciones realizadas.  El objeto resultante satisface la
     ecuación:

     c*poly=sum(a[i]*polylist[i],i=1...n)+r.

 -- Función: poly_exact_divide (<poly1>, <poly2>, <varlist>)
     Divide el polinomio <poly1> por otro polinomio <poly2>.  Da por
     supuesto que es posible la división de resto nulo.  Devuelve el
     cociente.

 -- Función: poly_normal_form (<poly>, <polylist>, <varlist>)
     ‘poly_normal_form’ encuentra la forma normal de un polinomio <poly>
     respecto de un conjunto de polinomios <polylist>.

 -- Función: poly_buchberger_criterion (<polylist>, <varlist>)
     Devuelve ‘true’ si <polylist> es una base de Groebner respecto del
     orden de términos activo, utilizando el criterio de Buchberger:
     para cualesquiera polinomios h1 y h2 de <polylist> el S-polinomio
     S(h1,h2) se reduce a 0 modulo <polylist>.

 -- Función: poly_buchberger (<polylist_fl> <varlist>)
     ‘poly_buchberger’ ejecuta el algoritmo de Buchberger sobre una
     lista de polinomios y devuelve la base de Groebner resultante.

56.2.4 Postprocesamiento estándar de bases de Groebner
------------------------------------------------------

El _k-ésimo ideal de eliminación_ I_k de un ideal I sobre K[
x[1],...,x[n] ] es el ideal intersect(I, K[ x[k+1],...,x[n] ]).
El _ideal_ I:J es el ideal {h|para todo w en J: w*h pertence a I}.
El ideal I:p^inf es el ideal {h| existe un n en N: p^n*h pertence a I}.
El ideal I:J^inf es el ideal {h| existe un n en N y un p en J: p^n*h
pertence a I}.
El _ideal radical_ sqrt(I) es el ideal {h| existe un n en N : h^n
pertence a I }.

 -- Función: poly_reduction (<polylist>, <varlist>)
     ‘poly_reduction’ reduce una lista de polinomios <polylist> de
     manera que cada polinomio se reduce completamente respecto de los
     otros polinomios.

 -- Función: poly_minimization (<polylist>, <varlist>)
     Devuelve una sublista de la lista de polinomios <polylist> con el
     mismo ideal de monomios que <polylist>, pero mínimo, esto es,
     ningún monomio principal de los polinomios de la sublista divide a
     los monomios principales de los demás polinomios.

 -- Función: poly_normalize_list (<polylist>, <varlist>)
     ‘poly_normalize_list’ aplica ‘poly_normalize’ a cada polinomio de
     la lista.  Esto significa que divide cada polinomio de <polylist>
     por su coeficiente principal.

 -- Función: poly_grobner (<polylist>, <varlist>)
     Devuelve la base de Groebner del ideal asociado a los polinomios de
     <polylist>.  El resultado depende de las variables globales.

 -- Función: poly_reduced_grobner (<polylist>, <varlist>)
     Devuelve la base de Groebner reducida del ideal asociado a los
     polinomios de <polylist>.  El resultado depende de las variables
     globales.

 -- Función: poly_depends_p (<poly>, <var>, <varlist>)
     ‘poly_depends’ comprueba si el polinomio depende de la variable
     <var>.

 -- Función: poly_elimination_ideal (<polylist>, <n>, <varlist>)
     ‘poly_elimination_ideal’ devuelve la base de Groebner del n-ésimo
     ideal de eliminación de un ideal especificado como una lista de
     polinomios generadores (no necesariamente una base de Groebner).

 -- Función: poly_colon_ideal (<polylist1>, <polylist2>, <varlist>)
     Devuelve la base de Groebner reducida del ideal

     I(polylist1):I(polylist2)

     siendo polylist1 y polylist2 dos listas de polinomios.

 -- Función: poly_ideal_intersection (<polylist1>, <polylist2>,
          <varlist>)

     ‘poly_ideal_intersection’ devuelve la intersección de dos ideales.

 -- Función: poly_lcm (<poly1>, <poly2>, <varlist>)
     Devuelve el MCM de <poly1> y <poly2>.

 -- Función: poly_gcd (<poly1>, <poly2>, <varlist>)
     Devuelve el MCD de <poly1> y <poly2>.

     Véanse también ‘ezgcd’, ‘gcd’, ‘gcdex’ y ‘gcdivide’.

     Ejemplo:

          (%i1) p1:6*x^3+19*x^2+19*x+6;
                                  3       2
          (%o1)                6 x  + 19 x  + 19 x + 6
          (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                            5       4       3       2
          (%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
          (%i3) poly_gcd(p1, p2, [x]);
                                      2
          (%o3)                    6 x  + 13 x + 6

 -- Función: poly_grobner_equal (<polylist1>, <polylist2>, <varlist>)
     ‘poly_grobner_equal’ comprueba si dos bases de Groebner generan el
     mismo ideal.  Devuelve ‘true’ si dos listas de polinomios
     <polylist1> y <polylist2>, supuestas bases de Groebner, generan el
     mismo ideal, o ‘false’ en caso contrario.  Eso equivale a comprobar
     si cada polinomio de la primera base se reduce a 0 módulo la
     segunda base y viceversa.  Nótese que en el ejemplo que sigue la
     primera lista no es una base de Groebner, por lo que el resultado
     es ‘false’.

          (%i1) poly_grobner_equal([y+x,x-y],[x,y],[x,y]);
          (%o1)                         false

 -- Función: poly_grobner_subsetp (<polylist1>, <polylist2>, <varlist>)
     ‘poly_grobner_subsetp’ comprueba si el ideal generado por
     <polylist1> está contenido en el ideal generado por <polylist2>.
     Para que esta comprobación tenga éxito, <polylist2> debe ser una
     base de Groebner.

 -- Función: poly_grobner_member (<poly>, <polylist>, <varlist>)
     Devuelve ‘true’ si el polinomio <poly> pertenece al ideal generado
     por la lista de polinomios <polylist>, la cual se supone una base
     de Groebner.  Devolverá ‘false’ en caso contrario.

 -- Función: poly_ideal_saturation1 (<polylist>, <poly>, <varlist>)
     Devuelve la base de Groebner reducida de la saturación del ideal

     I(polylist):poly^inf

     Desde un punto de vista geométrico, sobre un campo algebraicamente
     cerrado, este es el conjunto de polinomios del ideal generado por
     <polylist> que no se anulan sobre la variedad de <poly>.

 -- Función: poly_ideal_saturation (<polylist1>, <polylist2>, <varlist>)
     Devuelve la base de Groebner reducida de la saturación del ideal

     I(polylist1):I(polylist2)^inf

     Desde un punto de vista geométrico, sobre un campo algebraicamente
     cerrado, este es el conjunto de polinomios del ideal generado por
     <polylist1> que no se anulan sobre la variedad de <polylist2>.

 -- Función: poly_ideal_polysaturation1 (<polylist1>, <polylist2>,
          <varlist>)
     <polylist2> es una lista de n poliomios ‘[poly1,...,polyn]’.
     Devuelve la base de Groebner reducida del ideal

     I(polylist):poly1^inf:...:polyn^inf

     obtenida a partir de una secuencia de saturaciones sucesivas de los
     polinomios de la lista <polylist2> del ideal generado por la lista
     de polinomios <polylist1>.

 -- Función: poly_ideal_polysaturation (<polylist>, <polylistlist>,
          <varlist>)
     <polylistlist> es una lista de n listas de polinomios
     ‘[polylist1,...,polylistn]’.  Devuelve la base de Groebner reducida
     de la saturación del ideal

     I(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf

 -- Función: poly_saturation_extension (<poly>, <polylist>, <varlist1>,
          <varlist2>)
     ‘poly_saturation_extension’ ejecuta el truco de Rabinowitz.

 -- Función: poly_polysaturation_extension (<poly>, <polylist>,
          <varlist1>, <varlist2>)


File: maxima.info,  Node: impdiff,  Next: interpol,  Prev: grobner,  Up: Top

57 impdiff
**********

* Menu:

* Funciones y variables para impdiff::


File: maxima.info,  Node: Funciones y variables para impdiff,  Prev: impdiff,  Up: impdiff

57.1 Funciones y variables para impdiff
=======================================

 -- Función: implicit_derivative (<f>,<indvarlist>,<orderlist>,<depvar>)
     Calcula las derivadas implícitas de funciones multivariantes.  <f>
     es una función array, los índices son los grados de las derivadas
     en el orden establecido en <indvarlist>, <indvarlist> es la lista
     de variables independientes, <orderlist> es el orden deseado y
     <depvar> es la variable dependiente.

     Antes de hacer uso de esta función ejecútese ‘load("impdiff")’.


File: maxima.info,  Node: interpol,  Next: lapack,  Prev: impdiff,  Up: Top

58 interpol
***********

* Menu:

* Introducción a interpol::
* Funciones y variables para interpol::


File: maxima.info,  Node: Introducción a interpol,  Next: Funciones y variables para interpol,  Prev: interpol,  Up: interpol

58.1 Introducción a interpol
============================

El paquete ‘interpol’ desarrolla los métodos de interpolación polinómica
de Lagrange, lineal y de splines cúbicos.

Para comentarios, fallos o sugerencias, contactar con <’mario ARROBA edu
PUNTO xunta PUNTO es’>.


File: maxima.info,  Node: Funciones y variables para interpol,  Prev: Introducción a interpol,  Up: interpol

58.2 Funciones y variables para interpol
========================================

 -- Función: lagrange (<points>)
 -- Función: lagrange (<points>, <option>)
     Calcula el polinomio de interpolación por el método de Lagrange.
     El argumento <points> debe ser:

        • una matriz de dos columnas, ‘p:matrix([2,4],[5,6],[9,3])’,
        • una lista de pares de números, ‘p: [[2,4],[5,6],[9,3]]’,
        • una lista de números, ‘p: [4,6,3]’, en cuyo caso las abscisas
          se asignarán automáticamente a 1, 2, 3, etc.

     En los dos primeros casos los pares se ordenan con respecto a la
     primera coordenada antes de proceder a los cálculos.

     Mediante el argumento <option> es posible seleccionar el nombre de
     la variable independiente, que por defecto es ‘'x’; para definir
     otra, escríbase algo como ‘varname='z’.

     Téngase en cuenta que cuando se trabaja con polinomios de grado
     alto, los cálculos con números decimales en coma flotante pueden
     ser muy inestables.

     Véanse también ‘linearinterpol’, ‘cspline’ y ‘ratinterpol’.

     Ejemplos:

          (%i1) load("interpol")$
          (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
          (%i3) lagrange(p);
                 (x - 7) (x - 6) (x - 3) (x - 1)
          (%o3)  -------------------------------
                               35
             (x - 8) (x - 6) (x - 3) (x - 1)
           - -------------------------------
                           12
             7 (x - 8) (x - 7) (x - 3) (x - 1)
           + ---------------------------------
                            30
             (x - 8) (x - 7) (x - 6) (x - 1)
           - -------------------------------
                           60
             (x - 8) (x - 7) (x - 6) (x - 3)
           + -------------------------------
                           84
          (%i4) f(x):=''%;
                         (x - 7) (x - 6) (x - 3) (x - 1)
          (%o4)  f(x) := -------------------------------
                                       35
             (x - 8) (x - 6) (x - 3) (x - 1)
           - -------------------------------
                           12
             7 (x - 8) (x - 7) (x - 3) (x - 1)
           + ---------------------------------
                            30
             (x - 8) (x - 7) (x - 6) (x - 1)
           - -------------------------------
                           60
             (x - 8) (x - 7) (x - 6) (x - 3)
           + -------------------------------
                           84
          (%i5) /* Evaluate the polynomial at some points */
                expand(map(f,[2.3,5/7,%pi]));
                                            4          3           2
                              919062  73 %pi    701 %pi    8957 %pi
          (%o5)  [- 1.567535, ------, ------- - -------- + ---------
                              84035     420       210         420
                                                       5288 %pi   186
                                                     - -------- + ---]
                                                         105       5
          (%i6) %,numer;
          (%o6) [- 1.567535, 10.9366573451538, 2.89319655125692]
          (%i7) load("draw")$  /* load draw package */
          (%i8) /* Plot the polynomial together with points */
                draw2d(
                  color      = red,
                  key        = "Lagrange polynomial",
                  explicit(f(x),x,0,10),
                  point_size = 3,
                  color      = blue,
                  key        = "Sample points",
                  points(p))$
          (%i9) /* Change variable name */
                lagrange(p, varname=w);
                 (w - 7) (w - 6) (w - 3) (w - 1)
          (%o9)  -------------------------------
                               35
             (w - 8) (w - 6) (w - 3) (w - 1)
           - -------------------------------
                           12
             7 (w - 8) (w - 7) (w - 3) (w - 1)
           + ---------------------------------
                            30
             (w - 8) (w - 7) (w - 6) (w - 1)
           - -------------------------------
                           60
             (w - 8) (w - 7) (w - 6) (w - 3)
           + -------------------------------
                           84

 -- Función: charfun2 (<x>, <a>, <b>)
     Devuelve ‘true’ si el número <x> pertenece al intervalo [a, b), y
     ‘false’ en caso contrario.

 -- Función: linearinterpol (<points>)
 -- Función: linearinterpol (<points>, <option>)
     Calcula rectas de interpolación.  El argumento <points> debe ser:

        • una matriz de dos columnas, ‘p:matrix([2,4],[5,6],[9,3])’,
        • una lista de pares de números, ‘p: [[2,4],[5,6],[9,3]]’,
        • una lista de números, ‘p: [4,6,3]’, en cuyo caso las abscisas
          se asignarán automáticamente a 1, 2, 3, etc.

     En los dos primeros casos los pares se ordenan con respecto a la
     primera coordenada antes de proceder a los cálculos.

     Mediante el argumento <option> es posible seleccionar el nombre de
     la variable independiente, que por defecto es ‘'x’; para definir
     otra, escríbase algo como ‘varname='z’.

     Véanse también ‘lagrange’, ‘cspline’ y ‘ratinterpol’.

     Ejemplos:

          (%i1) load("interpol")$
          (%i2) p: matrix([7,2],[8,3],[1,5],[3,2],[6,7])$
          (%i3) linearinterpol(p);
                  13   3 x
          (%o3)  (-- - ---) charfun2(x, minf, 3)
                  2     2
           + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
              5 x
           + (--- - 3) charfun2(x, 3, 6)
               3

          (%i4) f(x):=''%;
                          13   3 x
          (%o4)  f(x) := (-- - ---) charfun2(x, minf, 3)
                          2     2
           + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
              5 x
           + (--- - 3) charfun2(x, 3, 6)
               3
          (%i5)  /* Evaluate the polynomial at some points */
                 map(f,[7.3,25/7,%pi]);
                                      62  5 %pi
          (%o5)                 [2.3, --, ----- - 3]
                                      21    3
          (%i6) %,numer;
          (%o6)  [2.3, 2.952380952380953, 2.235987755982989]
          (%i7) load("draw")$  /* load draw package */
          (%i8)  /* Plot the polynomial together with points */
                 draw2d(
                   color      = red,
                   key        = "Linear interpolator",
                   explicit(f(x),x,-5,20),
                   point_size = 3,
                   color      = blue,
                   key        = "Sample points",
                   points(args(p)))$
          (%i9)  /* Change variable name */
                 linearinterpol(p, varname='s);
                 13   3 s
          (%o9) (-- - ---) charfun2(s, minf, 3)
                 2     2
           + (s - 5) charfun2(s, 7, inf) + (37 - 5 s) charfun2(s, 6, 7)
              5 s
           + (--- - 3) charfun2(s, 3, 6)
               3

 -- Función: cspline (<points>)
 -- Función: cspline (<points>, <option1>, <option2>, ...)
     Calcula el polinomio de interpolación por el método de los splines
     cúbicos.  El argumento <points> debe ser:

        • una matriz de dos columnas, ‘p:matrix([2,4],[5,6],[9,3])’,
        • una lista de pares de números, ‘p: [[2,4],[5,6],[9,3]]’,
        • una lista de números, ‘p: [4,6,3]’, en cuyo caso las abscisas
          se asignarán automáticamente a 1, 2, 3, etc.

     En los dos primeros casos los pares se ordenan con respecto a la
     primera coordenada antes de proceder a los cálculos.

     Esta función dispone de tres opciones para acomodarse a necesidades
     concretas:

        • ‘'d1’, por defecto ‘'unknown’, es la primera derivada en x_1;
          si toma el valor ‘'unknown’, la segunda derivada en x_1 se
          iguala a 0 (spline cúbico natural); en caso de tomar un valor
          numérico, la segunda derivada se calcula en base a este
          número.

        • ‘'dn’, por defecto ‘'unknown’, es la primera derivada en x_n;
          si toma el valor ‘'unknown’, la segunda derivada en x_n se
          iguala a 0 (spline cúbico natural); en caso de tomar un valor
          numérico, la segunda derivada se calcula en base a este
          número.

        • ‘'varname’, por defecto ‘'x’, es el nombre de la variable
          independiente.

     Véanse también ‘lagrange’, ‘linearinterpol’ y ‘ratinterpol’.

     Ejemplos:

          (%i1) load("interpol")$
          (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
          (%i3) /* Unknown first derivatives at the extremes
                   is equivalent to natural cubic splines */
                cspline(p);
                        3         2
                  1159 x    1159 x    6091 x   8283
          (%o3)  (------- - ------- - ------ + ----) charfun2(x, minf, 3)
                   3288      1096      3288    1096
                      3         2
                2587 x    5174 x    494117 x   108928
           + (- ------- + ------- - -------- + ------) charfun2(x, 7, inf)
                 1644       137       1644      137
                    3          2
              4715 x    15209 x    579277 x   199575
           + (------- - -------- + -------- - ------) charfun2(x, 6, 7)
               1644       274        1644      274
                      3         2
                3287 x    2223 x    48275 x   9609
           + (- ------- + ------- - ------- + ----) charfun2(x, 3, 6)
                 4932       274      1644     274

          (%i4) f(x):=''%$
          (%i5) /* Some evaluations */
                map(f,[2.3,5/7,%pi]), numer;
          (%o5) [1.991460766423356, 5.823200187269903, 2.227405312429507]
          (%i6) load("draw")$  /* load draw package */
          (%i7) /* Plotting interpolating function */
                draw2d(
                  color      = red,
                  key        = "Cubic splines",
                  explicit(f(x),x,0,10),
                  point_size = 3,
                  color      = blue,
                  key        = "Sample points",
                  points(p))$
          (%i8) /* New call, but giving values at the derivatives */
                cspline(p,d1=0,dn=0);
                        3          2
                  1949 x    11437 x    17027 x   1247
          (%o8)  (------- - -------- + ------- + ----) charfun2(x, minf, 3)
                   2256       2256      2256     752
                      3          2
                1547 x    35581 x    68068 x   173546
           + (- ------- + -------- - ------- + ------) charfun2(x, 7, inf)
                  564       564        141      141
                   3          2
              607 x    35147 x    55706 x   38420
           + (------ - -------- + ------- - -----) charfun2(x, 6, 7)
               188       564        141      47
                      3         2
                3895 x    1807 x    5146 x   2148
           + (- ------- + ------- - ------ + ----) charfun2(x, 3, 6)
                 5076       188      141      47
          (%i8) /* Defining new interpolating function */
                g(x):=''%$
          (%i9) /* Plotting both functions together */
                draw2d(
                  color      = black,
                  key        = "Cubic splines (default)",
                  explicit(f(x),x,0,10),
                  color      = red,
                  key        = "Cubic splines (d1=0,dn=0)",
                  explicit(g(x),x,0,10),
                  point_size = 3,
                  color      = blue,
                  key        = "Sample points",
                  points(p))$

 -- Función: ratinterpol (<points>, <numdeg>)
 -- Función: ratinterpol (<points>, <numdeg>, <option1>)
     Genera el interpolador racional para los datos dados por <points> y
     con grado <numdeg> en el numerador; el grado del denominador se
     calcula automáticamente.  El argumento <points> debe ser:

        • una matriz de dos columnas, ‘p:matrix([2,4],[5,6],[9,3])’,
        • una lista de pares de números, ‘p: [[2,4],[5,6],[9,3]]’,
        • una lista de números, ‘p: [4,6,3]’, en cuyo caso las abscisas
          se asignarán automáticamente a 1, 2, 3, etc.

     En los dos primeros casos los pares se ordenan con respecto a la
     primera coordenada antes de proceder a los cálculos.

     Esta función dispone de una opción para acomodarse a necesidades
     concretas:
        • ‘'varname’, por defecto ‘'x’, es el nombre de la variable
          independiente.

     Véanse también ‘lagrange’, ‘linearinterpol’, ‘cspline’,
     ‘minpack_lsquares’ y ‘lbfgs’.

     Ejemplos:

          (%i1) load("interpol")$
          (%i2) load("draw")$
          (%i3) p:[[7.2,2.5],[8.5,2.1],[1.6,5.1],[3.4,2.4],[6.7,7.9]]$
          (%i4) for k:0 thru length(p)-1 do
                  draw2d(
                    explicit(ratinterpol(p,k),x,0,9),
                    point_size = 3,
                    points(p),
                    title = concat("Grado del numerador = ",k),
                    yrange=[0,10])$


File: maxima.info,  Node: lapack,  Next: lbfgs,  Prev: interpol,  Up: Top

59 lapack
*********

* Menu:

* Introducción a lapack::
* Funciones y variables para lapack::


File: maxima.info,  Node: Introducción a lapack,  Next: Funciones y variables para lapack,  Prev: lapack,  Up: lapack

59.1 Introducción a lapack
==========================

‘lapack’ es una traducción automática a Common Lisp (con el programa
‘f2c’) de la librería LAPACK escrita en Fortran.


File: maxima.info,  Node: Funciones y variables para lapack,  Prev: Introducción a lapack,  Up: lapack

59.2 Funciones y variables para lapack
======================================

 -- Función: dgeev (<A>)
 -- Función: dgeev (<A>, <right_p>, <left_p>)

     Calcula los autovalores y, opcionalmente, también los autovectores
     de la matriz <A>.  Todos los elementos de <A> deben ser enteros o
     números decimales en coma flotante.  Además, <A> debe ser cuadrada
     (igual número de filas que de columnas) y puede ser o no simétrica.

     ‘dgeev(<A>)’ calcula sólo los autovalores de <A>.  ‘dgeev(<A>,
     <right_p>, <left_p>)’ calcula los autovalores de <A> y los
     autovectores por la derecha cuando <right_p> = ‘true’, y los
     autovectores por la izquierda cuando <left_p> = ‘true’.

     La función devuelve una lista de tres elementos.  El primer
     elemento es una lista con los autovalores.  El segundo elemento es
     ‘false’ o la matriz de autovectores por la derecha.  El tercer
     elemento es ‘false’ o la matriz de autovectores por la izquierda.

     El autovector por la derecha v(j) (la j-ésima columna de la matriz
     de autovectores por la derecha) satisface

     A . v(j) = lambda(j) . v(j)

     donde lambda(j) es su autovalor asociado.

     El autovector por la izquierda u(j) (la j-ésima columna de la
     matriz de autovectores por la izquierda) satisface

     u(j)**H . A = lambda(j) . u(j)**H

     donde u(j)**H denota la transpuesta conjugada de u(j).

     La función de Maxima ‘ctranspose’ calcula la transpuesta conjugada.

     Los autovectores calculados están normalizados para que su norma
     euclídea valga 1 y su componente mayor tenga su parte imaginaria
     igual a cero.

     Ejemplo:

          (%i1) load ("lapack")$
          (%i2) fpprintprec : 6;
          (%o2)                           6
          (%i3) M : matrix ([9.5, 1.75], [3.25, 10.45]);
                                   [ 9.5   1.75  ]
          (%o3)                    [             ]
                                   [ 3.25  10.45 ]
          (%i4) dgeev (M);
          (%o4)          [[7.54331, 12.4067], false, false]
          (%i5) [L, v, u] : dgeev (M, true, true);
                                     [ - .666642  - .515792 ]
          (%o5) [[7.54331, 12.4067], [                      ],
                                     [  .745378   - .856714 ]
                                                  [ - .856714  - .745378 ]
                                                  [                      ]]
                                                  [  .515792   - .666642 ]
          (%i6) D : apply (diag_matrix, L);
                                [ 7.54331     0    ]
          (%o6)                 [                  ]
                                [    0     12.4067 ]
          (%i7) M . v - v . D;
                          [      0.0       - 8.88178E-16 ]
          (%o7)           [                              ]
                          [ - 8.88178E-16       0.0      ]
          (%i8) transpose (u) . M - D . transpose (u);
                               [ 0.0  - 4.44089E-16 ]
          (%o8)                [                    ]
                               [ 0.0       0.0      ]

 -- Función: dgeqrf (<A>)

     Calcula la descomposición QR de la matriz <A>.  Todos los elementos
     de <A> deben ser enteros o números reales.  No es necesario que <A>
     tenga el mismo número de filas que de columnas.

     La función devuelve una lista con dos elementos; el primero es la
     matriz cuadrada ortonormal <Q>, con el mismo número de filas que
     <A>, y el segundo es la matriz triangular superior <R>, de iguales
     dimensiones que <A>.  El producto ‘<Q> . <R>’, siendo "."  el
     operador de la multiplicación matricial, es igual a <A>, ignorando
     errores de redondeo.

          (%i1) load ("lapack") $
          (%i2) fpprintprec : 6 $
          (%i3) M : matrix ([1, -3.2, 8], [-11, 2.7, 5.9]) $
          (%i4) [q, r] : dgeqrf (M);
                 [ - .0905357  .995893  ]
          (%o4) [[                      ],
                 [  .995893    .0905357 ]
                                         [ - 11.0454   2.97863   5.15148 ]
                                         [                               ]]
                                         [     0      - 2.94241  8.50131 ]
          (%i5) q . r - M;
                   [ - 7.77156E-16   1.77636E-15   - 8.88178E-16 ]
          (%o5)    [                                             ]
                   [      0.0       - 1.33227E-15   8.88178E-16  ]
          (%i6) mat_norm (%, 1);
          (%o6)                      3.10862E-15

 -- Función: dgesv (<A>, <b>)

     Calcula la solución <x> de la ecuación <A> <x> = <b>, siendo <A>
     una matriz cuadrada y <b> otra matriz con el mismo número de filas
     que <A> y un número arbitrario de columnas.  Las dimensiones de la
     solución <x> son las mismas de <b>.

     Los elementos de <A> y <b> deben ser reducibles a números decimales
     si se les aplica la función ‘float’, por lo que tales elementos
     pueden en principio ser de cualquier tipo numérico, constantes
     numéricas simbólicas o cualesquiera expresiones reducibles a un
     número decimal.  Los elementos de <x> son siempre números
     decimales.  Todas las operaciones aritméticas se realizan en coma
     flotante.

     ‘dgesv’ calcula la solución mediante la descomposición LU de <A>.

     Ejemplos:

     ‘dgesv’ calcula la solución <x> de la ecuación <A> <x> = <b>.

          (%i1) A : matrix ([1, -2.5], [0.375, 5]);
                                         [   1    - 2.5 ]
          (%o1)                          [              ]
                                         [ 0.375    5   ]
          (%i2) b : matrix ([1.75], [-0.625]);
                                            [  1.75   ]
          (%o2)                             [         ]
                                            [ - 0.625 ]
          (%i3) x : dgesv (A, b);
                                      [  1.210526315789474  ]
          (%o3)                       [                     ]
                                      [ - 0.215789473684211 ]
          (%i4) dlange (inf_norm, b - A.x);
          (%o4)                                 0.0

     <b> una matriz con el mismo número de filas que <A> y un número
     arbitrario de columnas.  Las dimensiones de <x> son las mismas de
     <b>.

          (%o0)                                done
          (%i1) A : matrix ([1, -0.15], [1.82, 2]);
                                         [  1    - 0.15 ]
          (%o1)                          [              ]
                                         [ 1.82    2    ]
          (%i2) b : matrix ([3.7, 1, 8], [-2.3, 5, -3.9]);
                                        [  3.7   1    8   ]
          (%o2)                         [                 ]
                                        [ - 2.3  5  - 3.9 ]
          (%i3) x : dgesv (A, b);
                  [  3.103827540695117   1.20985481742191    6.781786185657722  ]
          (%o3)   [                                                             ]
                  [ - 3.974483062032557  1.399032116146062  - 8.121425428948527 ]
          (%i4) dlange (inf_norm, b - A . x);
          (%o4)                       1.1102230246251565E-15

     Los elementos de <A> y <b> deben ser reducibles a números
     decimales.

          (%i1) A : matrix ([5, -%pi], [1b0, 11/17]);
                                         [   5    - %pi ]
                                         [              ]
          (%o1)                          [         11   ]
                                         [ 1.0b0   --   ]
                                         [         17   ]
          (%i2) b : matrix ([%e], [sin(1)]);
                                            [   %e   ]
          (%o2)                             [        ]
                                            [ sin(1) ]
          (%i3) x : dgesv (A, b);
                                       [ 0.690375643155986 ]
          (%o3)                        [                   ]
                                       [ 0.233510982552952 ]
          (%i4) dlange (inf_norm, b - A . x);
          (%o4)                        2.220446049250313E-16

 -- Función: dgesvd (<A>)
 -- Función: dgesvd (<A>, <left_p>, <right_p>)

     Calcula la descomposición singular (SVD, en inglés) de la matriz
     <A>, que contiene los valores singulares y, opcionalmente, los
     vectores singulares por la derecha o por la izquierda.  Todos los
     elementos de <A> deben ser enteros o números decimales en coma
     flotante.  La matriz <A> puede ser cuadrada o no (igual número de
     filas que de columnas).

     Sea m el número de filas y n el de columnas de <A>.  La
     descomposición singular de <A> consiste en calcular tres matrices:
     <U>, <Sigma> y <V^T>, tales que

     <A> = <U> . <Sigma> . <V>^T

     donde <U> es una matriz unitaria m-por-m, <Sigma> es una matriz
     diagonal m-por-n y <V^T> es una matriz unitaria n-por-n.

     Sea sigma[i] un elemento diagonal de Sigma, esto es, <Sigma>[i, i]
     = <sigma>[i].  Los elementos sigma[i] se llaman valores singulares
     de <A>, los cuales son reales y no negativos, siendo devueltos por
     la función ‘dgesvd’ en orden descendente.

     Las primeras min(m, n) columnas de <U> y <V> son los vectores
     singulares izquierdo y derecho de <A>.  Nótese que ‘dgesvd’
     devuelve la transpuesta de <V>, no la propia matriz <V>.

     ‘dgesvd(<A>)’ calcula únicamente los valores singulares de <A>.
     ‘dgesvd(<A>, <left_p>, <right_p>)’ calcula los valores singulares
     de <A> y los vectores sigulares por la izquierda cuando <left_p> =
     ‘true’, y los vectores sigulares por la derecha cuando <right_p> =
     ‘true’.

     La función devuelve una lista de tres elementos.  El primer
     elemento es una lista con los valores singulares.  El segundo
     elemento es ‘false’ o la matriz de vectores singulares por la
     izquierda.  El tercer elemento es ‘false’ o la matriz de vectores
     singulares por la derecha.

     Ejemplo:

          (%i1) load ("lapack")$
          (%i2) fpprintprec : 6;
          (%o2)                           6
          (%i3) M: matrix([1, 2, 3], [3.5, 0.5, 8], [-1, 2, -3], [4, 9, 7]);
                                  [  1    2    3  ]
                                  [               ]
                                  [ 3.5  0.5   8  ]
          (%o3)                   [               ]
                                  [ - 1   2   - 3 ]
                                  [               ]
                                  [  4    9    7  ]
          (%i4) dgesvd (M);
          (%o4)      [[14.4744, 6.38637, .452547], false, false]
          (%i5) [sigma, U, VT] : dgesvd (M, true, true);
          (%o5) [[14.4744, 6.38637, .452547],
          [ - .256731  .00816168   .959029    - .119523 ]
          [                                             ]
          [ - .526456   .672116   - .206236   - .478091 ]
          [                                             ],
          [  .107997   - .532278  - .0708315  - 0.83666 ]
          [                                             ]
          [ - .803287  - .514659  - .180867    .239046  ]
          [ - .374486  - .538209  - .755044 ]
          [                                 ]
          [  .130623   - .836799   0.5317   ]]
          [                                 ]
          [ - .917986   .100488    .383672  ]
          (%i6) m : length (U);
          (%o6)                           4
          (%i7) n : length (VT);
          (%o7)                           3
          (%i8) Sigma:
                  genmatrix(lambda ([i, j], if i=j then sigma[i] else 0),
                            m, n);
                            [ 14.4744     0        0    ]
                            [                           ]
                            [    0     6.38637     0    ]
          (%o8)             [                           ]
                            [    0        0     .452547 ]
                            [                           ]
                            [    0        0        0    ]
          (%i9) U . Sigma . VT - M;
                    [  1.11022E-15        0.0       1.77636E-15 ]
                    [                                           ]
                    [  1.33227E-15    1.66533E-15       0.0     ]
          (%o9)     [                                           ]
                    [ - 4.44089E-16  - 8.88178E-16  4.44089E-16 ]
                    [                                           ]
                    [  8.88178E-16    1.77636E-15   8.88178E-16 ]
          (%i10) transpose (U) . U;
                 [     1.0      5.55112E-17    2.498E-16     2.77556E-17  ]
                 [                                                        ]
                 [ 5.55112E-17      1.0       5.55112E-17    4.16334E-17  ]
          (%o10) [                                                        ]
                 [  2.498E-16   5.55112E-17       1.0       - 2.08167E-16 ]
                 [                                                        ]
                 [ 2.77556E-17  4.16334E-17  - 2.08167E-16       1.0      ]
          (%i11) VT . transpose (VT);
                    [      1.0           0.0      - 5.55112E-17 ]
                    [                                           ]
          (%o11)    [      0.0           1.0       5.55112E-17  ]
                    [                                           ]
                    [ - 5.55112E-17  5.55112E-17       1.0      ]

 -- Función: dlange (<norm>, <A>)
 -- Función: zlange (<norm>, <A>)

     Calcula una norma o seudonorma de la matriz <A>.

     ‘max’
          Calcula max(abs(A(i, j))), siendo i y j números de filas y
          columnas, respectivamente, de <A>.  Nótese que esta función no
          es una norma matricial.
     ‘one_norm’
          Calcula la norma L[1] de <A>, esto es, el máximo de la suma de
          los valores absolutos de los elementos de cada columna.
     ‘inf_norm’
          Calcula la norma L[inf] de <A>, esto es, el máximo de la suma
          de los valores absolutos de los elementos de cada fila.
     ‘frobenius’
          Calcula la norma de Frobenius de <A>, esto es, la raíz
          cuadrada de la suma de los cuadrados de los elementos de la
          matriz.

 -- Función: dgemm (<A>, <B>)
 -- Función: dgemm (<A>, <B>, <options>)
     Calcula el producto de dos matrices y, opcionalmente, suma este
     producto con una tercera matriz.

     En su forma más simple, ‘dgemm(<A>, <B>)’ calcula el producto de
     las matrices reales <A> y <B>.

     En la segunda forma, ‘dgemm’ calcula <alpha> * <A> * <B> + <beta> *
     <C>, donde <A>, <B> y <C> son matrices reales de dimensiones
     apropiadas, siendo <alpha> y <beta> números reales.  De forma
     opcional, tanto <A> como <B> pueden transponerse antes de calcular
     su producto.  Los parámetros adicionales se pueden especificar en
     cualquier orden, siendo su sintaxis de la forma ‘clave=valor’.  Las
     claves reconocidas son:

     ‘C’
          La matriz <C> que debe ser sumada.  El valor por defecto es
          ‘false’, lo que significa que no se sumará ninguna matriz.
     ‘alpha’
          El producto de <A> por <B> se multiplicará por este vaalor.
          El valor por defecto es 1.
     ‘beta’
          Si se da la matriz <C>, se multiplicará por este valor antes
          de ser sumada.  El valor por defecto es 0, lo que significa
          que <C> no se suma, incluso estando presente.  Por lo tanto,
          téngase cuidado en especificar un valor no nulo para <beta>.
     ‘transpose_a’
          Si toma el valor ‘true’, se utilizará la transpuesta de <A>,
          en lugar de la propia matriz <A>, en el producto.  El valor
          por defecto es ‘false’.
     ‘transpose_b’
          Si toma el valor ‘true’, se utilizará la transpuesta de <B>,
          en lugar de la propia matriz <B>, en el producto.  El valor
          por defecto es ‘false’.

          (%i1) load ("lapack")$
          (%i2) A : matrix([1,2,3],[4,5,6],[7,8,9]);
                                            [ 1  2  3 ]
                                            [         ]
          (%o2)                             [ 4  5  6 ]
                                            [         ]
                                            [ 7  8  9 ]
          (%i3) B : matrix([-1,-2,-3],[-4,-5,-6],[-7,-8,-9]);
                                         [ - 1  - 2  - 3 ]
                                         [               ]
          (%o3)                          [ - 4  - 5  - 6 ]
                                         [               ]
                                         [ - 7  - 8  - 9 ]
          (%i4) C : matrix([3,2,1],[6,5,4],[9,8,7]);
                                            [ 3  2  1 ]
                                            [         ]
          (%o4)                             [ 6  5  4 ]
                                            [         ]
                                            [ 9  8  7 ]
          (%i5) dgemm(A,B);
                                   [ - 30.0   - 36.0   - 42.0  ]
                                   [                           ]
          (%o5)                    [ - 66.0   - 81.0   - 96.0  ]
                                   [                           ]
                                   [ - 102.0  - 126.0  - 150.0 ]
          (%i6) A . B;
                                      [ - 30   - 36   - 42  ]
                                      [                     ]
          (%o6)                       [ - 66   - 81   - 96  ]
                                      [                     ]
                                      [ - 102  - 126  - 150 ]
          (%i7) dgemm(A,B,transpose_a=true);
                                   [ - 66.0  - 78.0   - 90.0  ]
                                   [                          ]
          (%o7)                    [ - 78.0  - 93.0   - 108.0 ]
                                   [                          ]
                                   [ - 90.0  - 108.0  - 126.0 ]
          (%i8) transpose(A) . B;
                                     [ - 66  - 78   - 90  ]
                                     [                    ]
          (%o8)                      [ - 78  - 93   - 108 ]
                                     [                    ]
                                     [ - 90  - 108  - 126 ]
          (%i9) dgemm(A,B,c=C,beta=1);
                                   [ - 27.0  - 34.0   - 41.0  ]
                                   [                          ]
          (%o9)                    [ - 60.0  - 76.0   - 92.0  ]
                                   [                          ]
                                   [ - 93.0  - 118.0  - 143.0 ]
          (%i10) A . B + C;
                                      [ - 27  - 34   - 41  ]
                                      [                    ]
          (%o10)                      [ - 60  - 76   - 92  ]
                                      [                    ]
                                      [ - 93  - 118  - 143 ]
          (%i11) dgemm(A,B,c=C,beta=1, alpha=-1);
                                      [ 33.0   38.0   43.0  ]
                                      [                     ]
          (%o11)                      [ 72.0   86.0   100.0 ]
                                      [                     ]
                                      [ 111.0  134.0  157.0 ]
          (%i12) -A . B + C;
                                         [ 33   38   43  ]
                                         [               ]
          (%o12)                         [ 72   86   100 ]
                                         [               ]
                                         [ 111  134  157 ]



File: maxima.info,  Node: lbfgs,  Next: lindstedt,  Prev: lapack,  Up: Top

60 lbfgs
********

* Menu:

* Introducción a lbfgs::
* Funciones y variables para lbfgs::


File: maxima.info,  Node: Introducción a lbfgs,  Next: Funciones y variables para lbfgs,  Prev: Top,  Up: Top

60.1 Introducción a lbfgs
=========================

La función ‘lbfgs’ implementa el llamado algoritmo L-BFGS [1] para
resolver problemas de minimización sin restricciones mediante una
técnica cuasi-Newton con memoria limitada (BFGS). El término memoria
limitada procede del hecho de que se almacena una aproximación de rango
bajo de la inversa de la matriz hessiana, en lugar de la matriz
completa.  El programa fue originalmente escrito en Fortran [2] por
Jorge Nocedal, incorporando algunas funciones escritas originalmente por
Jorge J. Moré y David J. Thuente, traducidas posteriormente a Lisp
automáticamente con el programa ‘f2cl’.  El paquete ‘lbfgs’ contiene el
código traducido, junto con una función interfaz que para controlar
ciertos detalles.

Referencias:

[1] D. Liu and J. Nocedal.  "On the limited memory BFGS method for large
scale optimization".  Mathematical Programming B 45:503–528 (1989)

[2] <http://netlib.org/opt/lbfgs_um.shar>


File: maxima.info,  Node: Funciones y variables para lbfgs,  Prev: Introducción a lbfgs,  Up: Top

60.2 Funciones y variables para lbfgs
=====================================

 -- Función: lbfgs (<FOM>, <X>, <X0>, <epsilon>, <iprint>)
 -- Function: lbfgs ([<FOM>, <grad>] <X>, <X0>, <epsilon>, <iprint>)

     Encuentra una solución aproximada para el problema de minimización
     sin restricciones de la función objetivo <FOM> para la lista de
     variables <X>, partiendo de los estimadores iniciales <X0>, de tal
     manera que norm(grad(FOM)) < epsilon*max(1, norm(X)).

     Si el argumento <grad> está presente, debe ser el gradiente de
     <FOM> respecto de las variables <X>.  <grad> puede ser una lista o
     una función que devuelva una lista con igual número de elementos
     que <X>.  Si el argumento no está presente, el gradiente se calcula
     automáticamente mediante derivación simbólica.  Si <FOM> es una
     función, el gradiente <grad> debe ser suministrado por el usuario.

     El algoritmo utilizado es una técnica cuasi-Newton con memoria
     limitada (BFGS) [1].  El término memoria limitada procede del hecho
     de que se almacena una aproximación de rango bajo de la inversa de
     la matriz hessiana, en lugar de la matriz completa.  Cada iteración
     del algoritmo es una búsqueda a lo largo de una recta, cuya
     dirección se calcula a partir de la matriz inversa aproximada del
     hessiano.  La función objetivo decrece siempre tras cada búsqueda
     exitosa a lo largo de la recta; además, casi siempre decrece
     también el módulo del gradiente de la función.

     El argumento <iprint> controla los mensajes de progreso que envía
     la función ‘lbfgs’.

     ‘iprint[1]’
          ‘<iprint>[1]’ controla la frecuencia con la que se emiten los
          mensajes.
          ‘iprint[1] < 0’
               No se envían mensajes.
          ‘iprint[1] = 0’
               Mensajes únicamente en la primera y última iteraciones.
          ‘iprint[1] > 0’
               Imprime un mensaje cada ‘<iprint>[1]’ iteraciones.
     ‘iprint[2]’
          ‘<iprint>[2]’ controla la cantidad de información contenida en
          los mensajes.
          ‘iprint[2] = 0’
               Imprime contador de iteraciones, número de evaluaciones
               de <FOM>, valor de <FOM>, módulo del gradiente de <FOM> y
               amplitud del paso.
          ‘iprint[2] = 1’
               Igual que ‘<iprint>[2] = 0’, incluyendo <X0> y el
               gradiente de <FOM> evaluado en <X0>.
          ‘iprint[2] = 2’
               Igual que ‘<iprint>[2] = 1’, incluyendo los valores de
               <X> en cada iteración.
          ‘iprint[2] = 3’
               Igual que ‘<iprint>[2] = 2’, incluyendo el gradiente de
               <FOM> en cada iteración.

     Las columnas devueltas por ‘lbfgs’ son las siguientes:

     ‘I’
          Número de iteraciones.  Se incremente tras cada búsqueda a lo
          largo de una recta.
     ‘NFN’
          Número de evaluaciones de la función objetivo.
     ‘FUNC’
          Valor de la función objetivo al final de cada iteración.
     ‘GNORM’
          Módulo del gradiente de la función objetivo al final de cada
          iteración.
     ‘STEPLENGTH’
          Un parámetro interno del algoritmo de búsqueda.

     Para más información sobre el algoritmo se puede acudir a los
     comentarios en el código original en Fortran [2].

     Véanse también ‘lbfgs_nfeval_max’ y ‘lbfgs_ncorrections’.

     Referencias:

     [1] D. Liu and J. Nocedal.  "On the limited memory BFGS method for
     large scale optimization".  Mathematical Programming B 45:503–528
     (1989)

     [2] <http://netlib.org/opt/lbfgs_um.shar>

     Ejemplos:

     La misma función objetivo utilizada por FGCOMPUTE en el programa
     sdrive.f del paquete LBFGS de Netlib.  Nótese que las variables en
     cuestión están subindicadas.  La función objetivo tiene un mínimo
     exacto igual a cero en u[k] = 1, para k = 1, ..., 8.

          (%i1) load ("lbfgs")$
          (%i2) t1[j] := 1 - u[j];
          (%o2)                     t1  := 1 - u
                                      j         j
          (%i3) t2[j] := 10*(u[j + 1] - u[j]^2);
                                                    2
          (%o3)                t2  := 10 (u      - u )
                                 j         j + 1    j
          (%i4) n : 8;
          (%o4)                           8
          (%i5) FOM : sum (t1[2*j - 1]^2 + t2[2*j - 1]^2, j, 1, n/2);
                           2 2           2              2 2           2
          (%o5) 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                      8    7           7           6    5           5
                               2 2           2              2 2           2
                  + 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                          4    3           3           2    1           1
          (%i6) lbfgs (FOM, '[u[1],u[2],u[3],u[4],u[5],u[6],u[7],u[8]],
                 [-1.2, 1, -1.2, 1, -1.2, 1, -1.2, 1], 1e-3, [1, 0]);
          *************************************************
            N=    8   NUMBER OF CORRECTIONS=25
                 INITIAL VALUES
           F=  9.680000000000000D+01   GNORM=  4.657353755084533D+02
          *************************************************
           I NFN   FUNC                    GNORM                   STEPLENGTH

           1   3   1.651479526340304D+01   4.324359291335977D+00   7.926153934390631D-04
           2   4   1.650209316638371D+01   3.575788161060007D+00   1.000000000000000D+00
           3   5   1.645461701312851D+01   6.230869903601577D+00   1.000000000000000D+00
           4   6   1.636867301275588D+01   1.177589920974980D+01   1.000000000000000D+00
           5   7   1.612153014409201D+01   2.292797147151288D+01   1.000000000000000D+00
           6   8   1.569118407390628D+01   3.687447158775571D+01   1.000000000000000D+00
           7   9   1.510361958398942D+01   4.501931728123679D+01   1.000000000000000D+00
           8  10   1.391077875774293D+01   4.526061463810630D+01   1.000000000000000D+00
           9  11   1.165625686278198D+01   2.748348965356907D+01   1.000000000000000D+00
          10  12   9.859422687859144D+00   2.111494974231706D+01   1.000000000000000D+00
          11  13   7.815442521732282D+00   6.110762325764183D+00   1.000000000000000D+00
          12  15   7.346380905773044D+00   2.165281166715009D+01   1.285316401779678D-01
          13  16   6.330460634066464D+00   1.401220851761508D+01   1.000000000000000D+00
          14  17   5.238763939854303D+00   1.702473787619218D+01   1.000000000000000D+00
          15  18   3.754016790406625D+00   7.981845727632704D+00   1.000000000000000D+00
          16  20   3.001238402313225D+00   3.925482944745832D+00   2.333129631316462D-01
          17  22   2.794390709722064D+00   8.243329982586480D+00   2.503577283802312D-01
          18  23   2.563783562920545D+00   1.035413426522664D+01   1.000000000000000D+00
          19  24   2.019429976373283D+00   1.065187312340952D+01   1.000000000000000D+00
          20  25   1.428003167668592D+00   2.475962450735100D+00   1.000000000000000D+00
          21  27   1.197874264859232D+00   8.441707983339661D+00   4.303451060697367D-01
          22  28   9.023848942003913D-01   1.113189216665625D+01   1.000000000000000D+00
          23  29   5.508226405855795D-01   2.380830599637816D+00   1.000000000000000D+00
          24  31   3.902893258879521D-01   5.625595817143044D+00   4.834988416747262D-01
          25  32   3.207542206881058D-01   1.149444645298493D+01   1.000000000000000D+00
          26  33   1.874468266118200D-01   3.632482152347445D+00   1.000000000000000D+00
          27  34   9.575763380282112D-02   4.816497449000391D+00   1.000000000000000D+00
          28  35   4.085145106760390D-02   2.087009347116811D+00   1.000000000000000D+00
          29  36   1.931106005512628D-02   3.886818624052740D+00   1.000000000000000D+00
          30  37   6.894000636920714D-03   3.198505769992936D+00   1.000000000000000D+00
          31  38   1.443296008850287D-03   1.590265460381961D+00   1.000000000000000D+00
          32  39   1.571766574930155D-04   3.098257002223532D-01   1.000000000000000D+00
          33  40   1.288011779655132D-05   1.207784334505595D-02   1.000000000000000D+00
          34  41   1.806140190993455D-06   4.587890258846915D-02   1.000000000000000D+00
          35  42   1.769004612050548D-07   1.790537363138099D-02   1.000000000000000D+00
          36  43   3.312164244118216D-10   6.782068546986653D-04   1.000000000000000D+00

           THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
           IFLAG = 0
          (%o6) [u  = 1.000005339816132, u  = 1.000009942840108,
                  1                       2
          u  = 1.000005339816132, u  = 1.000009942840108,
           3                       4
          u  = 1.000005339816132, u  = 1.000009942840108,
           5                       6
          u  = 1.000005339816132, u  = 1.000009942840108]
           7                       8

     Un problema de regresión.  La función objetivo es el cuadrado medio
     de la diferencia entre la predicción F(X[i]) y el valor observado
     Y[i].  La función F es monótona y acotada (llamada en ocasiones
     "sigmoidal").  En este ejemplo, ‘lbfgs’ calcula valores aproximados
     para los parámetros de F y ‘plot2d’ hace una representación gráfica
     comparativa de F junto con los datos observados.

          (%i1) load ("lbfgs")$
          (%i2) FOM : '((1/length(X))*sum((F(X[i]) - Y[i])^2, i, 1,
                                                          length(X)));
                                         2
                         sum((F(X ) - Y ) , i, 1, length(X))
                                 i     i
          (%o2)          -----------------------------------
                                      length(X)
          (%i3) X : [1, 2, 3, 4, 5];
          (%o3)                    [1, 2, 3, 4, 5]
          (%i4) Y : [0, 0.5, 1, 1.25, 1.5];
          (%o4)                [0, 0.5, 1, 1.25, 1.5]
          (%i5) F(x) := A/(1 + exp(-B*(x - C)));
                                             A
          (%o5)            F(x) := ----------------------
                                   1 + exp((- B) (x - C))
          (%i6) ''FOM;
                          A               2            A                2
          (%o6) ((----------------- - 1.5)  + (----------------- - 1.25)
                    - B (5 - C)                  - B (4 - C)
                  %e            + 1            %e            + 1
                      A             2            A               2
           + (----------------- - 1)  + (----------------- - 0.5)
                - B (3 - C)                - B (2 - C)
              %e            + 1          %e            + 1
                       2
                      A
           + --------------------)/5
                - B (1 - C)     2
             (%e            + 1)
          (%i7) estimates : lbfgs (FOM, '[A, B, C], [1, 1, 1], 1e-4, [1, 0]);
          *************************************************
            N=    3   NUMBER OF CORRECTIONS=25
                 INITIAL VALUES
           F=  1.348738534246918D-01   GNORM=  2.000215531936760D-01
          *************************************************

          I  NFN  FUNC                    GNORM                   STEPLENGTH
          1    3  1.177820636622582D-01   9.893138394953992D-02   8.554435968992371D-01
          2    6  2.302653892214013D-02   1.180098521565904D-01   2.100000000000000D+01
          3    8  1.496348495303004D-02   9.611201567691624D-02   5.257340567840710D-01
          4    9  7.900460841091138D-03   1.325041647391314D-02   1.000000000000000D+00
          5   10  7.314495451266914D-03   1.510670810312226D-02   1.000000000000000D+00
          6   11  6.750147275936668D-03   1.914964958023037D-02   1.000000000000000D+00
          7   12  5.850716021108202D-03   1.028089194579382D-02   1.000000000000000D+00
          8   13  5.778664230657800D-03   3.676866074532179D-04   1.000000000000000D+00
          9   14  5.777818823650780D-03   3.010740179797108D-04   1.000000000000000D+00

           THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
           IFLAG = 0
          (%o7) [A = 1.461933911464101, B = 1.601593973254801,
                                                     C = 2.528933072164855]
          (%i8) plot2d ([F(x), [discrete, X, Y]], [x, -1, 6]), ''estimates;
          (%o8)

     Especificando el gradiente de la función objetivo en lugar de
     calcularlo simbólicamente.

          (%i1) load ("lbfgs")$
          (%i2) F(a, b, c) := (a - 5)^2 + (b - 3)^4 + (c - 2)^6$
          (%i3) define(F_grad(a, b, c),
                       map (lambda ([x], diff (F(a, b, c), x)), [a, b, c]))$
          (%i4) estimates : lbfgs ([F, F_grad],
                             [a, b, c], [0, 0, 0], 1e-4, [1, 0]);
          *************************************************
            N=    3   NUMBER OF CORRECTIONS=25
                 INITIAL VALUES
           F=  1.700000000000000D+02   GNORM=  2.205175729958953D+02
          *************************************************

             I  NFN     FUNC                    GNORM                   STEPLENGTH

             1    2     6.632967565917637D+01   6.498411132518770D+01   4.534785987412505D-03
             2    3     4.368890936228036D+01   3.784147651974131D+01   1.000000000000000D+00
             3    4     2.685298972775191D+01   1.640262125898520D+01   1.000000000000000D+00
             4    5     1.909064767659852D+01   9.733664001790506D+00   1.000000000000000D+00
             5    6     1.006493272061515D+01   6.344808151880209D+00   1.000000000000000D+00
             6    7     1.215263596054292D+00   2.204727876126877D+00   1.000000000000000D+00
             7    8     1.080252896385329D-02   1.431637116951845D-01   1.000000000000000D+00
             8    9     8.407195124830860D-03   1.126344579730008D-01   1.000000000000000D+00
             9   10     5.022091686198525D-03   7.750731829225275D-02   1.000000000000000D+00
            10   11     2.277152808939775D-03   5.032810859286796D-02   1.000000000000000D+00
            11   12     6.489384688303218D-04   1.932007150271009D-02   1.000000000000000D+00
            12   13     2.075791943844547D-04   6.964319310814365D-03   1.000000000000000D+00
            13   14     7.349472666162258D-05   4.017449067849554D-03   1.000000000000000D+00
            14   15     2.293617477985238D-05   1.334590390856715D-03   1.000000000000000D+00
            15   16     7.683645404048675D-06   6.011057038099202D-04   1.000000000000000D+00

           THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
           IFLAG = 0
          (%o4) [a = 5.000086823042934, b = 3.052395429705181,
                                                     c = 1.927980629919583]

 -- Variable: lbfgs_nfeval_max
     Valor por defecto: 100

     La variable ‘lbfgs_nfeval_max’ almacena el número máximo de
     evaluaciones de la función objetivo en ‘lbfgs’.  Cuando se alcanza
     el valor ‘lbfgs_nfeval_max’, ‘lbfgs’ devuelve el resultado logrado
     en la última iteración exitosa.

 -- Variable: lbfgs_ncorrections
     Valor por defecto: 25

     La variable ‘lbfgs_ncorrections’ almacena el número de correcciones
     aplicadas a la matriz inversa aproximada del hessiano, la cual es
     gestionada por ‘lbfgs’.


File: maxima.info,  Node: lindstedt,  Next: linearalgebra,  Prev: lbfgs,  Up: Top

61 lindstedt
************

* Menu:

* Funciones y variables para lindstedt::


File: maxima.info,  Node: Funciones y variables para lindstedt,  Prev: lindstedt,  Up: lindstedt

61.1 Funciones y variables para lindstedt
=========================================

 -- Función: Lindstedt (<eq>,<pvar>,<torder>,<ic>)
     Este es el primer paso hacia un programa para resolver ecuaciones
     de Lindstedt.  Puede resolver problemas con condiciones iniciales,
     las cuales pueden ser constantes arbitrarias (no pueden usarse
     <%k1> ni <%k2>) donde las condiciones iniciales sobre las
     ecuaciones de perturbación son z[i]=0, z'[i]=0 para i>0.  El
     argumento <ic> es la lista de condiciones iniciales.

     Ejemplo:
          (%i1) load("makeOrders")$

          (%i2) load("lindstedt")$

          (%i3) Lindstedt('diff(x,t,2)+x-(e*x^3)/6,e,2,[1,0]);
                    2
                   e  (cos(5 T) - 24 cos(3 T) + 23 cos(T))
          (%o3) [[[---------------------------------------
                                    36864
             e (cos(3 T) - cos(T))
           - --------------------- + cos(T)],
                      192
                    2
                 7 e    e
          T = (- ---- - -- + 1) t]]
                 3072   16

     Antes de hacer uso de esta función ejecútense ‘load("makeOrders")’
     y ‘load("lindstedt")’.


File: maxima.info,  Node: linearalgebra,  Next: lsquares,  Prev: lindstedt,  Up: Top

62 linearalgebra
****************

* Menu:

* Introducción a linearalgebra::
* Funciones y variables para linearalgebra::


File: maxima.info,  Node: Introducción a linearalgebra,  Next: Funciones y variables para linearalgebra,  Prev: linearalgebra,  Up: linearalgebra

62.1 Introducción a linearalgebra
=================================

El paquete ‘linearalgebra’ contiene una batería de funciones para
álgebra lineal.

Ejemplo:

     (%i1) M : matrix ([1, 2], [1, 2]);
                                 [ 1  2 ]
     (%o1)                       [      ]
                                 [ 1  2 ]
     (%i2) nullspace (M);
                                    [  1  ]
                                    [     ]
     (%o2)                     span([   1 ])
                                    [ - - ]
                                    [   2 ]
     (%i3) columnspace (M);
                                     [ 1 ]
     (%o3)                      span([   ])
                                     [ 1 ]
     (%i4) ptriangularize (M - z*ident(2), z);
                              [ 1   2 - z   ]
     (%o4)                    [             ]
                              [           2 ]
                              [ 0  3 z - z  ]
     (%i5) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
                          [ 1 - z    2      3   ]
                          [                     ]
     (%o5)                [   4    5 - z    6   ]
                          [                     ]
                          [   7      8    9 - z ]
     (%i6) MM : ptriangularize (M, z);
                   [ 4  5 - z            6            ]
                   [                                  ]
                   [                2                 ]
                   [     66        z    102 z   132   ]
                   [ 0   --      - -- + ----- + ---   ]
     (%o6)         [     49        7     49     49    ]
                   [                                  ]
                   [               3        2         ]
                   [           49 z    245 z    147 z ]
                   [ 0    0    ----- - ------ - ----- ]
                   [            264      88      44   ]
     (%i7) algebraic : true;
     (%o7)                         true
     (%i8) tellrat (MM [3, 3]);
                              3       2
     (%o8)                  [z  - 15 z  - 18 z]
     (%i9) MM : ratsimp (MM);
                    [ 4  5 - z           6           ]
                    [                                ]
                    [                2               ]
     (%o9)          [     66      7 z  - 102 z - 132 ]
                    [ 0   --    - ------------------ ]
                    [     49              49         ]
                    [                                ]
                    [ 0    0             0           ]
     (%i10) nullspace (MM);
                             [        1         ]
                             [                  ]
                             [   2              ]
                             [  z  - 14 z - 16  ]
                             [  --------------  ]
     (%o10)             span([        8         ])
                             [                  ]
                             [    2             ]
                             [   z  - 18 z - 12 ]
                             [ - -------------- ]
                             [         12       ]
     (%i11) M : matrix ([1, 2, 3, 4], [5, 6, 7, 8],
                        [9, 10, 11, 12], [13, 14, 15, 16]);
                            [ 1   2   3   4  ]
                            [                ]
                            [ 5   6   7   8  ]
     (%o11)                 [                ]
                            [ 9   10  11  12 ]
                            [                ]
                            [ 13  14  15  16 ]
     (%i12) columnspace (M);
                                [ 1  ]  [ 2  ]
                                [    ]  [    ]
                                [ 5  ]  [ 6  ]
     (%o12)                span([    ], [    ])
                                [ 9  ]  [ 10 ]
                                [    ]  [    ]
                                [ 13 ]  [ 14 ]
     (%i13) apply ('orthogonal_complement, args (nullspace (transpose (M))));
                                [ 0 ]  [  1  ]
                                [   ]  [     ]
                                [ 1 ]  [  0  ]
     (%o13)                span([   ], [     ])
                                [ 2 ]  [ - 1 ]
                                [   ]  [     ]
                                [ 3 ]  [ - 2 ]


File: maxima.info,  Node: Funciones y variables para linearalgebra,  Prev: Introducción a linearalgebra,  Up: linearalgebra

62.2 Funciones y variables para linearalgebra
=============================================

 -- Función: addmatrices (<f>, <M_1>, ..., <M_n>)

     Utiliza la función <f> como una función aditiva, devolviendo la
     suma de las matrices <M_1>, ..., <M_n>.  La función <f> debe ser
     tal que acepte un número arbitrario de argumentos; en otras
     palabras, será una función n-aria de Maxima.

     Ejemplos:

          (%i1) m1 : matrix([1,2],[3,4])$
          (%i2) m2 : matrix([7,8],[9,10])$
          (%i3) addmatrices('max,m1,m2);
          (%o3) matrix([7,8],[9,10])
          (%i4) addmatrices('max,m1,m2,5*m1);
          (%o4) matrix([7,10],[15,20])

 -- Función: blockmatrixp (<M>)

     Devuelve el valor ‘true’ si y solo si <M> es una matriz cuyos
     elementos son a su vez matrices.

 -- Función: columnop (<M>, <i>, <j>, <theta>)

     Si <M> es una matriz, devuelve la matriz que resulta de hacer la
     operación columna ‘C_i <- C_i - <theta> * C_j’.  Si <M> carece de
     cualquiera de las filas <i> o <j>, devuelve un mensaje de error.

 -- Función: columnswap (<M>, <i>, <j>)

     Si <M> es una matriz, intercambia las columnas <i> y <j>.  Si <M>
     carece de cualquiera de las filas <i> o <j>, devuelve un mensaje de
     error.

 -- Función: columnspace (<M>)

     Si <M> es una matriz, devuelve ‘span (v_1, ..., v_n)’, donde el
     conjunto ‘{v_1, ..., v_n}’ es la base del espacio generado por las
     columnas de <M>.

 -- Función: copy (<e>)

     Devuelve una copia de la expresión <e> de Maxima.  Aunque <e> puede
     ser cualquier expresión de Maxima, la función ‘copy’ es
     especialmente útil cuando <e> es una lista o una matriz.
     Considérese el siguiente ejemplo:

          (%i1) m : [1,[2,3]]$
          (%i2) mm : m$
          (%i3) mm[2][1] : x$
          (%i4) m;
          (%o4)                      [1,[x,3]]
          (%i5) mm;
          (%o5)                      [1,[x,3]]
     Veamos el mismo ejemplo siendo ahora <mm> una copia de <m>
          (%i6) m : [1,[2,3]]$
          (%i7) mm : copy(m)$
          (%i8) mm[2][1] : x$
          (%i9) m;
          (%o9)                     [1,[2,3]]
          (%i10) mm;
          (%o10)                    [1,[x,3]]
     En esta ocasión, la asignación a <mm> no cambia el valor de <m>.

 -- Función: cholesky (<M>)
 -- Función: cholesky (<M>, <field>)

     Devuelve la factorización de Cholesky de la matriz autoadjunta (o
     hermítica) <M>.  El valor por defecto del segundo argumento es
     ‘generalring’.  Para una descripción de los posibles valores para
     <field>, véase ‘lu_factor’.

 -- Función: ctranspose (<M>)

     Devuelve la transpuesta compleja conjugada de la matriz <M>.  La
     función ‘ctranspose’ utiliza ‘matrix_element_transpose’ para
     transponer cada elemento de la matriz.

 -- Función: diag_matrix (<d_1>, <d_2>, ..., <d_n>)

     Devuelve una matriz diagonal con los elementos de la diagonal
     iguales a <d_1>, <d_2>, ..., <d_n>; cuando éstos son matrices, los
     elementos nulos de la matriz devuelta son matrices nulas de tamaño
     apropiado.  Por ejemplo:

          (%i1) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));

                                      [ [ 1  0 ]  [ 0  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  2 ]  [ 0  0 ] ]
          (%o1)                       [                    ]
                                      [ [ 0  0 ]  [ 3  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  0 ]  [ 0  4 ] ]
          (%i2) diag_matrix(p,q);

                                             [ p  0 ]
          (%o2)                              [      ]
                                             [ 0  q ]

 -- Función: dotproduct (<u>, <v>)

     Devuelve el producto escalar de los vectores <u> y <v>.  Equivale a
     ‘conjugate (transpose (<u>)) . <v>’.  Los argumentos <u> y <v>
     deben ser vectores columna.

 -- Función: eigens_by_jacobi (<A>)
 -- Función: eigens_by_jacobi (<A>, <field_type>)

     Calcula los valores y vectores propios de <A> por el método de las
     rotaciones de Jacobi.  <A> debe ser una matriz simétrica (aunque no
     necesariamente definida o semidefinida positiva).  El argumento
     <field_type> indica el tipo numérico sobre el que se realizan los
     cálculos, que puede ser tanto ‘floatfield’ como ‘bigfloatfield’.
     En caso de que no se especifique <field_type>, su valor por defecto
     será ‘floatfield’.

     Los elementos de <A> deben ser números o expresiones reducibles a
     números mediante la ejecución de ‘float’ o ‘bfloat’, según sea el
     valor de <field_type>.

     Ejemplos:

          (%i1) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
                               [     1         1    ]
                               [  -------   ------- ]
                               [  sqrt(2)   sqrt(2) ]
          (%o1)                [                    ]
                               [      1        1    ]
                               [ - -------  ------- ]
                               [   sqrt(2)  sqrt(2) ]
          (%i2) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
                                [ sqrt(3)     0    ]
          (%o2)                 [                  ]
                                [    0     sqrt(5) ]
          (%i3) M : S . L . transpose (S);
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- + -------  ------- - ------- ]
                      [    2         2        2         2    ]
          (%o3)       [                                      ]
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- - -------  ------- + ------- ]
                      [    2         2        2         2    ]
          (%i4) eigens_by_jacobi (M);
          The largest percent change was 0.1454972243679
          The largest percent change was 0.0
          number of sweeps: 2
          number of rotations: 1
          (%o4) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i5) float ([[sqrt(3), sqrt(5)], S]);
          (%o5) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i6) eigens_by_jacobi (M, bigfloatfield);
          The largest percent change was 1.454972243679028b-1
          The largest percent change was 0.0b0
          number of sweeps: 2
          number of rotations: 1
          (%o6) [[1.732050807568877b0, 2.23606797749979b0],
                          [  7.071067811865475b-1   7.071067811865475b-1 ]
                          [                                              ]]
                          [ - 7.071067811865475b-1  7.071067811865475b-1 ]

 -- Función: get_lu_factors (<x>)

     Cuando ‘<x> = lu_factor (<A>)’, entonces ‘get_lu_factors’ devuelve
     una lista de la forma ‘[P, L, U]’, donde <P> es una matriz
     permutación, <L> es triangular inferior con unos en la diagonal y
     <U> es triangular superior, verificándose que ‘<A> = <P> <L> <U>’.

 -- Función: hankel (<col>)
 -- Función: hankel (<col>, <row>)

     Devuelve la matriz de Hankel <H>.  La primera columna de <H>
     coincide con <col>, excepto en el primer elemento, la última fila
     de <H> es <row>.  El valor por defecto para <row> es el vector nulo
     con igual número de elementos que <col>.

 -- Función: hessian (<f>, <x>)

     Devuelve la matriz hessiana de <f> con respecto de la lista de
     variables <x>.  El elemento ‘(i, j)’-ésimo de la matriz hessiana es
     ‘diff(<f>, <x>[i], 1, <x>[j], 1)’.

     Ejemplos:

          (%i1) hessian (x * sin (y), [x, y]);
                               [   0       cos(y)   ]
          (%o1)                [                    ]
                               [ cos(y)  - x sin(y) ]
          (%i2) depends (F, [a, b]);
          (%o2)                       [F(a, b)]
          (%i3) hessian (F, [a, b]);
                                  [   2      2   ]
                                  [  d F    d F  ]
                                  [  ---   ----- ]
                                  [    2   da db ]
                                  [  da          ]
          (%o3)                   [              ]
                                  [   2      2   ]
                                  [  d F    d F  ]
                                  [ -----   ---  ]
                                  [ da db     2  ]
                                  [         db   ]

 -- Función: hilbert_matrix (<n>)

     Devuelve la matriz de Hilbert <n> por <n>.  Si <n> no es un entero
     positivo, emite un mensaje de error.

 -- Función: identfor (<M>)
 -- Función: identfor (<M>, <fld>)

     Devuelve una matriz identidad con la misma forma que la matriz <M>.
     Los elementos de la diagonal de la matriz identidad son la
     identidad multiplicativa del campo <fld>; el valor por defecto para
     <fld> es <generalring>.

     El primer argumento <M> debe ser una matriz cuadrada o no ser
     matriz en absoluto.  Si <M> es una matriz, sus elementos pueden ser
     matrices cuadradas.  La matriz puede tener bloques a cualquier
     nivel finito de profundidad.

     Véase también ‘zerofor’

 -- Función: invert_by_lu (<M>, <(rng generalring)>)

     Invierte la matriz <M> mediante la factorización LU, la cual se
     hace utilizando el anillo <rng>.

 -- Función: jacobian (<f>, <x>)

     Devuelve la matriz jacobiana de la lista de funciones <f> respecto
     de la lista de variables <x>.  El elemento ‘(i, j)’-ésimo de la
     matriz jacobiana es ‘diff(<f>[i], <x>[j])’.

     Ejemplos:

          (%i1) jacobian ([sin (u - v), sin (u * v)], [u, v]);
                            [ cos(v - u)  - cos(v - u) ]
          (%o1)             [                          ]
                            [ v cos(u v)   u cos(u v)  ]
          (%i2) depends ([F, G], [y, z]);
          (%o2)                  [F(y, z), G(y, z)]
          (%i3) jacobian ([F, G], [y, z]);
                                     [ dF  dF ]
                                     [ --  -- ]
                                     [ dy  dz ]
          (%o3)                      [        ]
                                     [ dG  dG ]
                                     [ --  -- ]
                                     [ dy  dz ]

 -- Función: kronecker_product (<A>, <B>)

     Devuelve el producto de Kroneckerde las matrices <A> y <B>.

 -- Función: listp (<e>, <p>)
 -- Función: listp (<e>)

     Dado el argumento opcional <p>, devuelve ‘true’ si <e> es una lista
     de Maxima y <p> toma el valor ‘true’ al aplicarlo a cada elemento
     de la lista.  Si a ‘listp’ no se le suministra el argumento
     opcional, devuelve ‘true’ si <e> es una lista de Maxima.  En
     cualquier otro caso, el resultado es ‘false’.

 -- Función: locate_matrix_entry (<M>, <r_1>, <c_1>, <r_2>, <c_2>, <f>,
          <rel>)

     El primer argumento debe ser una matriz, mientras que los
     argumentos desde <r_1> hasta <c_2> determinan la submatriz de <M>
     tomando las filas desde <r_1> hasta <r_2> y las columnas desde
     <c_1> hasta <c_2>.

     La función ‘locate_matrix_entry’ busca en la submatriz de <M> un
     elemento que satisfaga cierta propiedad.  hay tres posibilidades:

     (1) ‘<rel> = 'bool’ y <f> es un predicado:

     Rastrea la submatriz de izquierda a derecha y de arriba hacia
     abajo, devolviendo el índice del primer elemento que satisface el
     predicado <f>; si ningún elemento lo satisface, el resultado es
     ‘false’.

     (2) ‘<rel> = 'max’ y <f> una función real:

     Rastrea la submatriz buscando el elemento que maximice <f>,
     devolviendo el índice correspondiente.

     (3) ‘<rel> = 'min’ y <f> una función real:

     Rastrea la submatriz buscando el elemento que minimice <f>,
     devolviendo el índice correspondiente.

 -- Función: lu_backsub (<M>, <b>)

     Si ‘<M> = lu_factor (<A>, <field>)’, entonces ‘lu_backsub (<M>,
     <b>)’ resuelve el sistema de ecuaciones lineales ‘<A> <x> = <b>’.

 -- Función: lu_factor (<M>, <field>)

     Devuelve una lista de la forma ‘[<LU>, <perm>, <fld>]’, o ‘[<LU>,
     <perm>, <fld>, <lower-cnd> <upper-cnd>]’, donde

        • La matriz <LU> contiene la factorización de <M> de forma
          empaquetada, lo que significa tres cosas.  En primer lugar,
          que las filas de <LU> están permutadas de acuerdo con la lista
          <perm>; por ejemplo, si <perm> es la lista ‘[3,2,1]’, la
          primera fila de la factorización <LU> es la tercera fila de la
          matriz <LU>.  En segundo lugar, el factor triangular inferior
          de <M> es la parte triangular inferior de <LU> con los
          elementos de la diagonal sustituidos por unos.  Por último, el
          factor triangular superior de <M> es la parte triangular
          superior de <LU>.

        • Si el campo es ‘floatfield’ o ‘complexfield’, los números
          <lower-cnd> y <upper-cnd> son las cotas inferior y superior
          del número de condición de la norma infinita de <M>.  El
          número de condición no se puede estimar para todos los campos,
          en cuyo caso ‘lu_factor’ devuelve una lista de dos elementos.
          Tanto la cota inferior como la superior pueden diferir de sus
          valores verdaderos.  Véase también ‘mat_cond’.

     El argumento <M> debe ser una matriz cuadrada.

     El argumento opcional <fld> debe ser un símbolo que determine un
     anillo o un campo.  Los anillos y campos predefinidos son:

       a. ‘generalring’ – el anillo de las expresiones de Maxima

       b. ‘floatfield’ – el campo de los números decimales en coma
          flotante de doble precisión

       c. ‘complexfield’ – el campo de los números complejos decimales
          en coma flotante de doble precisión

       d. ‘crering’ – el anillo de las expresiones canónicas racionales
          (Canonical Rational Expression o CRE) de Maxima

       e. ‘rationalfield’ – el campo de los números racionales

       f. ‘runningerror’ – controla los errores de redondeo de las
          operaciones en coma flotante

       g. ‘noncommutingring’ – el anillo de las expresiones de Maxima en
          las que el producto es el operador no conmutativo "."

     Si el campo es ‘floatfield’, ‘complexfield’ o ‘runningerror’, el
     algoritmo utiliza pivoteo parcial; para los demás campos, las filas
     se cambian cuando se necesita evitar pivotes nulos.

     La suma aritmética en coma flotante no es asociativa, por lo que el
     significado de ’campo’ no coincide exactamente con su definición
     matemática.

     Un elemento del campo ‘runningerror’ consiste en una lista de
     Maxima de la forma ‘[x,n]’, donde <x> es un número decimal en coma
     flotante y ‘n’ un enetro.  La diferencia relativa entre el valor
     real de ‘x’ y ‘x’ está aproximadamente acotado por el valor epsilon
     de la máquina multiplicado por ‘n’.

     No es posible la definición de un nuevo campo por parte del
     usuario, a menos que éste tenga conocimientos de Common Lisp.  Para
     hacerlo, el usuario debe definir funciones para las operaciones
     aritméticas y para convertir de la representación del campo a
     Maxima y al revés.  Además, en los campos ordenados, donde se hace
     uso del pivoteo parcial, el usuario debe definir funciones para el
     módulo y para comparar números del campo.  Después de lo anterior,
     tan solo queda definir una estructura Common Lisp ‘mring’.  El
     fichero ‘mring’ tiene muchos ejemplos.

     Para calcular la factorización, la primera tarea consiste en
     convertir cada elemento de la matriz a un elemento del campo
     especificado.  Si la conversión no es posible, la factorización se
     detiene con un mensaje de error.  Los elementos del campo no
     necesitan ser expresiones de Maxima; por ejemplo, los elementos de
     ‘complexfield’ son números complejos de Common Lisp.  Tras la
     factorización, los elementos de la matriz deben convertirse
     nuevamente a expresiones de Maxima.

     Véase también ‘get_lu_factors’.

     Ejemplos:

          (%i1) w[i,j] := random (1.0) + %i * random (1.0);
          (%o1)          w     := random(1.) + %i random(1.)
                          i, j
          (%i2) showtime : true$
          Evaluation took 0.00 seconds (0.00 elapsed)
          (%i3) M : genmatrix (w, 100, 100)$
          Evaluation took 7.40 seconds (8.23 elapsed)
          (%i4) lu_factor (M, complexfield)$
          Evaluation took 28.71 seconds (35.00 elapsed)
          (%i5) lu_factor (M, generalring)$
          Evaluation took 109.24 seconds (152.10 elapsed)
          (%i6) showtime : false$

          (%i7) M : matrix ([1 - z, 3], [3, 8 - z]);
                                  [ 1 - z    3   ]
          (%o7)                   [              ]
                                  [   3    8 - z ]
          (%i8) lu_factor (M, generalring);
                    [ 1 - z         3        ]
                    [                        ]
          (%o8)    [[   3            9       ], [1, 2], generalring]
                    [ -----  - z - ----- + 8 ]
                    [ 1 - z        1 - z     ]
          (%i9) get_lu_factors (%);
                            [   1    0 ]  [ 1 - z         3        ]
                  [ 1  0 ]  [          ]  [                        ]
          (%o9)  [[      ], [   3      ], [                9       ]]
                  [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
                            [ 1 - z    ]  [              1 - z     ]
          (%i10) %[1] . %[2] . %[3];
                                  [ 1 - z    3   ]
          (%o10)                  [              ]
                                  [   3    8 - z ]

 -- Función: mat_cond (<M>, 1)
 -- Función: mat_cond (<M>, inf)

     Devuelve el número de condición de la <p>-norma de la matriz <M>.
     Los valores admisibles para <p> son 1 y <inf>.  Esta función
     utiliza la factorización LU para invertir la matriz <M>, por lo que
     el tiempo de ejecución de ‘mat_cond’ es proporcional al cubo del
     tamaño de la matriz; ‘lu_factor’ determina las cotas inferior y
     superior para el número de condición de la norma infinita en un
     tiempo proporcional al cuadrado del tamaño de la matriz.

 -- Función: mat_norm (<M>, 1)
 -- Función: mat_norm (<M>, inf)
 -- Función: mat_norm (<M>, frobenius)

     Devuelve la <p>-norma de la matriz <M>.  Los valores admisibles
     para <p> son 1, ‘inf’ y ‘frobenius’ (la norma matricial de
     Frobenius).  La matriz <M> no debe contener bloques.

 -- Función: matrixp (<e>, <p>)
 -- Función: matrixp (<e>)

     Dado el argumento opcional <p>, devuelve ‘true’ si <e> es una
     matriz y <p> toma el valor ‘true’ al aplicarlo a cada elemento de
     la matriz.  Si a ‘matrixp’ no se le suministra el argumento
     opcional, devuelve ‘true’ si <e> es una matriz.  En cualquier otro
     caso, el resultado es ‘false’.

     Véase también ‘blockmatrixp’

 -- Función: matrix_size (<M>)

     Devuelve una lista con el número de filas y columnas de la matriz
     <M>.

 -- Función: mat_fullunblocker (<M>)

     Si <M> es una matriz de bloques, transforma la matriz llevando
     todos los elementos de los bloques al primer nivel.  Si <M> es una
     matriz, devuelve <M>; en cualquier otro caso, envía un mensaje de
     error.

 -- Función: mat_trace (<M>)

     Calcula la traza de la matriz <M>.  Si <M> no es una matriz,
     devuelve una forma nominal.  Si <M> es una matriz de bloques,
     ‘mat_trace(M)’ calcula el mismo valor que
     ‘mat_trace(mat_unblocker(m))’.

 -- Función: mat_unblocker (<M>)

     Si <M> es una matriz de bloques, deshace los bloques de un nivel.
     Si <M> es una matriz, ‘mat_unblocker (M)’ devuelve <M>; en
     cualquier otro caso, envía un mensaje de error.

     Si todos los elementos de <M> son matrices, ‘mat_unblocker (M)’
     devuelve una matriz sin bloques, pero si los elementos de <M> son a
     su vez matrices de bloques, ‘mat_unblocker (M)’ devuelve una matriz
     con el nivel de bloques disminuido en uno.

     En caso de trabajar con matrices de bloques, quizás sea conveniente
     darle a ‘matrix_element_mult’ el valor ‘"."’ y a
     ‘matrix_element_transpose’ el valor ‘'transpose’.  Véase también
     ‘mat_fullunblocker’.

     Ejemplo:

          (%i1) A : matrix ([1, 2], [3, 4]);
                                      [ 1  2 ]
          (%o1)                       [      ]
                                      [ 3  4 ]
          (%i2) B : matrix ([7, 8], [9, 10]);
                                      [ 7  8  ]
          (%o2)                       [       ]
                                      [ 9  10 ]
          (%i3) matrix ([A, B]);
                               [ [ 1  2 ]  [ 7  8  ] ]
          (%o3)                [ [      ]  [       ] ]
                               [ [ 3  4 ]  [ 9  10 ] ]
          (%i4) mat_unblocker (%);
                                   [ 1  2  7  8  ]
          (%o4)                    [             ]
                                   [ 3  4  9  10 ]

 -- Función: nullspace (<M>)

     Si <M> es una matriz, devuelve ‘span (v_1, ..., v_n)’, siendo
     ‘{v_1, ..., v_n}’ la base del espacio nulo de <M>.  Si el espacio
     nulo contiene un único elemento, devuelve ‘span ()’.

 -- Función: nullity (<M>)

     Si <M> es una matriz, devuelve la dimensión del espacio nulo de
     <M>.

 -- Función: orthogonal_complement (<v_1>, ..., <v_n>)

     Devuelve ‘span (u_1, ..., u_m)’, siendo ‘{u_1, ..., u_m}’ la base
     del complemento ortogonal del conjunto ‘(v_1, ..., v_n)’, cuyos
     elementos deben ser vectores columna.

 -- Función: polynomialp (<p>, <L>, <coeffp>, <exponp>)
 -- Función: polynomialp (<p>, <L>, <coeffp>)
 -- Función: polynomialp (<p>, <L>)

     Devuelve ‘true’ si <p> es un polinomio cuyas variables son las de
     la lista <L>, el predicado <coeffp> toma el valor ‘true’ al
     aplicarlo a cada coeficiente y el predicado <exponp> también
     alcanza el valor ‘true’ al ser aplicado a los exponentes de las
     variables listadas en <L>.  En caso de necesitar que <exponp> no
     sea un predicado por defecto, se deberá especificar también el
     predicado <coeffp>, aunque aquí se desee su comportamiento por
     defecto.

     La instrucción ‘polynomialp (<p>, <L>, <coeffp>)’ equivale a
     ‘polynomialp (<p>, <L>, <coeffp>, 'nonnegintegerp)’, al tiempo que
     ‘polynomialp (<p>, <L>)’ equivale a ‘polynomialp (<p>, L<,>
     'constantp, 'nonnegintegerp)’.

     No es necesario expandir el polinomio:

          (%i1) polynomialp ((x + 1)*(x + 2), [x]);
          (%o1)                         true
          (%i2) polynomialp ((x + 1)*(x + 2)^a, [x]);
          (%o2)                         false

     Un ejemplo utilizando valores distintos a los utilizados por
     defecto en <coeffp> y en <exponp>:

          (%i1) polynomialp ((x + 1)*(x + 2)^(3/2), [x],
                             numberp, numberp);
          (%o1)                         true
          (%i2) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x],
                             numberp, numberp);
          (%o2)                         true

     Polinomios con dos variables:

          (%i1) polynomialp (x^2 + 5*x*y + y^2, [x]);
          (%o1)                         false
          (%i2) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
          (%o2)                         true

 -- Función: polytocompanion (<p>, <x>)

     Si <p> es un polinomio en <x>, devuelve la matriz compañera de <p>.
     Para un polinomio mónico <p> de grado <n> se tiene ‘<p> = (-1)^<n>
     charpoly (polytocompanion (<p>, <x>))’.

     Si <p> no es un polinomio en <x>, se devuelve un mensaje de error.

 -- Función: ptriangularize (<M>, <v>)

     Si <M> es una matriz en la que sus elementos son polinomios en <v>,
     devuelve una matriz <M2> tal que

       1. <M2> es triangular superior,

       2. ‘<M2> = <E_n> ... <E_1> <M>’, donde <E_1>, ..., <E_n> son
          matrices elementales cuyos elementos son polinomios en <v>,

       3. ‘|det (<M>)| = |det (<M2>)|’,

     Nota: esta función no comprueba si los elementos de la matriz son
     polinomios en <v>.

 -- Función: rowop (<M>, <i>, <j>, <theta>)

     Si <M> es una matriz, devuelve la matriz que resulta de relizar la
     transformación ‘R_i <- R_i - theta * R_j’ con las filas ‘R_i’ y
     ‘R_j’.  Si <M> no tiene estas filas, devuelve un mensaje de error.

 -- Función: rank (<M>)

     Calcula el rango de la matriz <M>.  El rango es la dimensión del
     espacio columna.  Ejemplo:
          (%i1) rank(matrix([1,2],[2,4]));
          (%o1)                                  1
          (%i2) rank(matrix([1,b],[c,d]));
          Proviso:  {d - b c # 0}
          (%o2)                                  2

 -- Función: rowswap (<M>, <i>, <j>)

     Si <M> es una matriz, intercambia las filas <i> y <j>.  Si <M>
     carece de estas filas, devuelve un mensaje de error.

 -- Función: toeplitz (<col>)
 -- Función: toeplitz (<col>, <row>)

     Devuelve una matriz de Toeplitz <T>.  La primera columna de <T> es
     <col>, excepto su primer elemento.  La primera fila de <T> es
     <row>.  El valor por defecto para <row> es el complejo conjugado de
     <col>.  Ejemplo:
          (%i1)  toeplitz([1,2,3],[x,y,z]);
                                            [ 1  y  z ]
                                            [         ]
          (%o1)                             [ 2  1  y ]
                                            [         ]
                                            [ 3  2  1 ]
          (%i2)  toeplitz([1,1+%i]);

                                        [   1     1 - %I ]
          (%o2)                         [                ]
                                        [ %I + 1    1    ]

 -- Función: vandermonde_matrix ([<x_1>, ..., <x_n>])

     Devuelve una matriz <n> por <n>, cuya <i>-ésima fila es ‘[1, <x_i>,
     <x_i>^2, ... <x_i>^(<n>-1)]’.

 -- Función: zerofor (<M>)
 -- Función: zerofor (<M>, <fld>)

     Devuelve la matriz nula con la misma estructura que la matriz <M>.
     Cada elemento de la matriz nula es la identidad aditiva del campo
     <fld>; el valor por defecto de <fld> es <generalring>.

     El primer argumento de <M> debe ser una matriz cuadrada o no ser
     matriz en absoluto.  Si <M> es una matriz, cada uno de sus
     elementos puede ser una matriz cuadrada, por lo que <M> puede ser
     una matriz de Maxima definida por bloques.

     Véase también ‘identfor’.

 -- Función: zeromatrixp (<M>)

     Si <M> no es una matriz definida por bloques, devuelve ‘true’ si
     ‘is (equal (<e>, 0))’ es verdadero para todo elemento <e> de <M>.
     Si <M> es una matriz por bloques, devuelve ‘true’ si ‘zeromatrixp’
     devuelve a su vez ‘true’ para cada elemento de <e>.

