This is maxima.info, produced by makeinfo version 4.7 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 la definición de funciones,  Prev: Macros,  Up: Definición de Funciones

39.4 Funciones y variables para la definición de funciones
==========================================================

 -- Función: apply (<F>, [<x_1>, ..., <x_n>])
     Construye y evalúa la expresión `<F>(<arg_1>, ..., <arg_n>)'.

     La función `apply' no hace distinciones entre funciones array y
     funciones ordinarias; cuando <F> es el nombre de una función array,
     `apply' evalúa `<F>(...)', esto es, hace una llamada con
     paréntesis en lugar de corchetes. La función `arrayapply' evalúa
     una llamada a función con corchetes para estos casos.

     Ejemplos:

     La función `apply' evalúa sus argumentos.  En este ejemplo, `min'
     se aplica al valor de `L'.

          (%i1) L : [1, 5, -10.2, 4, 3];
          (%o1)                 [1, 5, - 10.2, 4, 3]
          (%i2) apply (min, L);
          (%o2)                        - 10.2

     La función `apply' evalúa sus argumentos, incluso cuando la
     función <F> no lo hace.

          (%i1) F (x) := x / 1729;
                                             x
          (%o1)                     F(x) := ----
                                            1729
          (%i2) fname : F;
          (%o2)                           F
          (%i3) dispfun (F);
                                             x
          (%t3)                     F(x) := ----
                                            1729

          (%o3)                         [%t3]
          (%i4) dispfun (fname);
          fname is not the name of a user function.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) apply (dispfun, [fname]);
                                             x
          (%t5)                     F(x) := ----
                                            1729

          (%o5)                         [%t5]

     La función `apply' evalúa el nombre de función <F>.  La comilla
     simple `'' evita la evaluación.  El nombre `demoivre' corresponde
     a una variable global y también a una función.

          (%i1) demoivre;
          (%o1)                         false
          (%i2) demoivre (exp (%i * x));
          (%o2)                  %i sin(x) + cos(x)
          (%i3) apply (demoivre, [exp (%i * x)]);
          demoivre evaluates to false
          Improper name or value in functional position.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) apply ('demoivre, [exp (%i * x)]);
          (%o4)                  %i sin(x) + cos(x)


 -- Función: block ([<v_1>, ..., <v_m>], <expr_1>, ..., <expr_n>)
 -- Función: block (<expr_1>, ..., <expr_n>)
     La función `block' evalúa <expr_1>, ..., <expr_n> secuencialmente
     y devuelve el valor de la última expresión evaluada. La secuencia
     puede alterarse con las funciones `go', `throw' y `return'. La
     última expresión es <expr_n> a menos que `return' o una expresión
     que contenga un `throw' sea evaluada. Las variables <v_1>, ...,
     <v_m> son locales en el bloque; éstas se distiguen de las globales
     que tengan el mismo nombre. Si no se declaran variables locales
     entonces se puede omitir la lista. Dentro del bloque, cualquier
     otra variable distinta de <v_1>, ..., <v_m> se considera global.

     La función `block' guarda los valores actuales de las variables
     <v_1>, ..., <v_m>, si los tienen, a la entrada del bloque y luego
     las evalúa a sí mismas, es decir les saca el valor temporalmente.
     A las variables locales se les puede asignar cualquier valor
     dentro del bloque, pero al salir de éste, los valores inicialmente
     almacenados quedan restaurados, al tiempo que los asignados dentro
     del bloque se pierden.

     Un `block' puede aparecer dentro de otro `block'. Las variables
     locales se inicializan cada vez que se entra dentro de un nuevo
     bloque. Las variables locales de un bloque se consideran globales
     dentro de otro anidado dentro del primero. Si una variable es no
     local dentro de un bloque, su valor es el que le corresponde en el
     bloque superior. Este criterio se conoce con el nombre de "alcance
     dinámico".

     Si se quieren guardar y restaurar otras propiedades locales además
     del `valor' de las variables, por ejemplo `arreglo' (excepto
     arreglos completos), `function', `dependencies', `atvalue',
     `matchdeclare', `atomgrad', `constant' y `nonscalar' entonces
     debería usarse la función `local' dentro del bloque, siendo sus
     argumentos los nombres de las variables.

     El valor del bloque es el de la última sentencia o el argumento de
     la función `return', que puede utilizarse para salir del bloque.
     La función `go' puede usarse para transferir el control a la
     sentencia del bloque que esté etiquetada con el argumento de `go'.
     Para etiquetar una sentencia basta que vaya precedida de un
     argumento atómico como cualquier otra sentencia dentro del bloque.
     Por ejemplo, `block ([x], x:1, tururu, x: x+1, ..., go(tururu),
     ...)'.  El argumento de `go' debe ser el nombre de una etiqueta
     colocada dentro del bloque. No se puede utilzar `go' para
     trasladarse a una etiqueta de un bloque que no sea el que contenga
     a `go'.

     Normalmente los bloques aparecerán al lado derecho de las
     definiciones de funciones, pero también pueden utilizarse en otros
     contextos.


 -- Función: break (<expr_1>, ..., <expr_n>)
     Calcula e imprime <expr_1>, ..., <expr_n> para luego provocar la
     detención de Maxima, de modo que el usuario pueda examinar y
     cambiar el entorno de ejecución. Pulsando posteriormente `exit;'
     el cálculo se reanuda.


 -- Función: catch (<expr_1>, ..., <expr_n>)
     Evalúa <expr_1>, ..., <expr_n> una a una;  si alguna de ellas
     conlleva la evaluación de una expresión de la forma `throw (arg)',
     entonces el valor de `catch' es el de `throw (arg)' y ya no se
     evalúan más expresiones. Esta respuesta pasa todos los niveles de
     anidamiento hasta el `catch' más próximo. Si no hay ningún `catch'
     que contenga un `throw' se emite un mensaje de error.

     Si la evaluación de los argumentos no conlleva la evaluación de
     ningún `throw', entonces el valor de `catch' es el devuelto por
     <expr_n>.

          (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
          (%i2) g(l) := catch (map (''%, l))$
          (%i3) g ([1, 2, 3, 7]);
          (%o3)               [f(1), f(2), f(3), f(7)]
          (%i4) g ([1, 2, -3, 7]);
          (%o4)                          - 3

     La función `g' devuelve las imágenes por `f' de todos los
     elementos de la lista `l' si ésta contiene únicamente números no
     negativos; si no es este el caso, entonces `g' captura el primer
     negativo que encuentra y lo devuelve por medio del `throw'.


 -- Function: compfile (<filename>, <f_1>, ..., <f_n>)
 -- Function: compfile (<filename>, functions)
 -- Function: compfile (<filename>, all)
     Traduce funciones de Maxima a código Lisp, guardándolo luego en el
     fichero <filename>.

     Con la llamada `compfile(<filename>, <f_1>, ..., <f_n>)' se
     traducen las funciones especificadas, mientras que
     `compfile(<filename>, functions)' y `compfile(<filename>, all)'
     traducen las funciones definidas por el usuario.

     El código Lisp traducido no se evalúa, ni el fichero de salida es
     procesado por el compilador de Lisp.  La función `translate' crea
     y evalúa las traducciones Lisp, mientras que `compile_file'
     traduce primero de Maxima a Lisp y luego ejecuta el compilador
     Lisp.

     Véanse también `translate', `translate_file' y `compile_file'.


 -- Función: compile (<f_1>, ..., <f_n>)
 -- Función: compile (functions)
 -- Función: compile (all)
     Traduce las funciones de Maxima <f_1>, ..., <f_n> a Lisp,
     evaluando el código resultante, y llama a la función Lisp
     `COMPILE' para cada función traducida. La función `compile'
     devuelve una lista con los nombres de las funciones compiladas.

     Las llamadas `compile (all)' o `compile (functions)' compilan
     todas las funciones definidas por el usuario.

     La función `compile' no evalúa sus argumentos, pero con el
     operador comilla-comilla (`''') sí lo hace.


 -- Función: define (<f>(<x_1>, ..., <x_n>), <expr>)
 -- Función: define (<f>[<x_1>, ..., <x_n>], <expr>)
 -- Función: define (funmake (<f>, [<x_1>, ..., <x_n>]), <expr>)
 -- Función: define (arraymake (<f>, [<x_1>, ..., <x_n>]), <expr>)
 -- Función: define (ev (<expr_1>), <expr_2>)
     Define una función de nombre <f> con argumentos <x_1>, ..., <x_n>
     y cuerpo <expr>.  `define' evalúa siempre su segundo argumento, a
     menos que se indique lo contrario con el operador de comilla
     simple. La función así definida puede ser una función ordinaria de
     Maxima (con sus argumentos encerrados entre paréntesis) o una
     función array (con sus argumentos encerrados entre corchetes).

     Cuando el último o único argumento <x_n> es una lista de un solo
     elemento, la función definida por `define' acepta un número
     variable de argumentos. Los valores de los argumentos se van
     asignando uno a uno a <x_1>, ..., <x_(n - 1)>, y los que queden,
     si los hay, se asignan a <x_n> en forma de lista.

     Cuando el primer argumento de `define' es una expresión de la
     forma `<f>(<x_1>, ..., <x_n>)' o `<f>[<x_1>, ..., <x_n>]', se
     evalúan los argumentos de la función, pero no <f>, incluso cuando
     se trate de una función o variable ya existente con ese nombre.

     Cuando el primer argumento es una expresión con operador `funmake',
     `arraymake' o `ev', se evalúa este primer argumento, lo que
     permite calcular la función.

     Todas las definiciones de funciones aparecen en el mismo espacio
     de nombres; definiendo una función `f' dentro de otra función `g'
     no limita el alcance de `f' a `g'.

     Si un argumento formal <x_k> es un símbolo afectado por el
     operador comilla simple (expresión nominal), la función definida
     por `define' no evalúa el correspondiente valor de argumento.  En
     cualquier otro caso, los argumentos que se pasan son evaluados.

     Véanse también `:=' y `::='.

     Ejemplos:

     `define' evalúa siempre su segundo argumento, a menos que se
     indique lo contrario con el operador de comilla simple.

          (%i1) expr : cos(y) - sin(x);
          (%o1)                    cos(y) - sin(x)
          (%i2) define (F1 (x, y), expr);
          (%o2)              F1(x, y) := cos(y) - sin(x)
          (%i3) F1 (a, b);
          (%o3)                    cos(b) - sin(a)
          (%i4) F2 (x, y) := expr;
          (%o4)                   F2(x, y) := expr
          (%i5) F2 (a, b);
          (%o5)                    cos(y) - sin(x)

     La función así definida puede ser una función ordinaria de Maxima
     o una función array.

          (%i1) define (G1 (x, y), x.y - y.x);
          (%o1)               G1(x, y) := x . y - y . x
          (%i2) define (G2 [x, y], x.y - y.x);
          (%o2)                G2     := x . y - y . x
                                 x, y

     Cuando el último o único argumento <x_n> es una lista de un solo
     elemento, la función definida por `define' acepta un número
     variable de argumentos.

          (%i1) define (H ([L]), '(apply ("+", L)));
          (%o1)                H([L]) := apply("+", L)
          (%i2) H (a, b, c);
          (%o2)                       c + b + a

     Cuando el primer argumento es una expresión con operador `funmake',
     `arraymake' o `ev', se evalúa este primer argumento.

          (%i1) [F : I, u : x];
          (%o1)                        [I, x]
          (%i2) funmake (F, [u]);
          (%o2)                         I(x)
          (%i3) define (funmake (F, [u]), cos(u) + 1);
          (%o3)                  I(x) := cos(x) + 1
          (%i4) define (arraymake (F, [u]), cos(u) + 1);
          (%o4)                   I  := cos(x) + 1
                                   x
          (%i5) define (foo (x, y), bar (y, x));
          (%o5)                foo(x, y) := bar(y, x)
          (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
          (%o6)             bar(y, x) := sin(x) - cos(y)


 -- Función: define_variable (<name>, <default_value>, <mode>)
     Introduce una variable global en el entorno de Maxima. La función
     `define_variable' puede ser útil en los paquetes escritos por los
     usuarios que vayan a ser compilados o traducidos con frecuencia.

     La función `define_variable' ejecuta los siguientes pasos:

       1. `mode_declare (<name>, <mode>)' declara el modo de <name> al
          traductor.  Véase `mode_declare' para ver la lista de modos
          aceptables.

       2. Si aún no tiene asignación, se le da a la variable
          <default_value> el valor <name>.

       3. `declare (<name>, special)' la declara como especial.

       4. Asocia <name> a una función de comprobación para asegurar que
          a <name> sólo se le asignan valores del modo declarado.

     La propiedad `value_check' se puede asociar a cualquier variable
     que haya sido definida mediante `define_variable' en cualquiera de
     los modos diferentes a `any'. La propiedad `value_check' puede ser
     una expresión lambda o una función de una variable, que será
     invocada al intentar asignar un valor a la variable; el argumento
     pasado a la función `value_check' es el valor que se le quiere
     asignar a la variable.

     La función `define_variable' evalúa `default_value' pero no `name'
     ni `mode'; el valor que devuelve es el valor actual de `name', el
     cual es `default_value' si a `name' no se le ha aplicado ninguna
     asignación, o el valor de dicha asignación en caso contrario.

     Ejemplos:

     `foo' es una variable booleana con valor inicial `true'.
          (%i1) define_variable (foo, true, boolean);
          (%o1)                         true
          (%i2) foo;
          (%o2)                         true
          (%i3) foo: false;
          (%o3)                         false
          (%i4) foo: %pi;
          Error: foo was declared mode boolean, has value: %pi
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) foo;
          (%o5)                         false

     `bar' es una variable entera, cuyo valor habrá de ser primo.
          (%i1) define_variable (bar, 2, integer);
          (%o1)                           2
          (%i2) qput (bar, prime_test, value_check);
          (%o2)                      prime_test
          (%i3) prime_test (y) := if not primep(y) then
                                     error (y, "is not prime.");
          (%o3) prime_test(y) :=
                   if not primep(y) then error(y, "is not prime.")
          (%i4) bar: 1439;
          (%o4)                         1439
          (%i5) bar: 1440;
          1440 is not prime.
          #0: prime_test(y=1440)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) bar;
          (%o6)                         1439

     `baz_quux' es una variable a la que no se le podrá asignar valor
     alguno.  El modo `any_check' es como `any', pero `any_check'
     activa el mecanismo `value_check', cosa que `any' no hace.
          (%i1) define_variable (baz_quux, 'baz_quux, any_check);
          (%o1)                       baz_quux
          (%i2) F: lambda ([y], if y # 'baz_quux then
                           error ("Cannot assign to `baz_quux'."));
          (%o2) lambda([y], if y # 'baz_quux
                             then error(Cannot assign to `baz_quux'.))
          (%i3) qput (baz_quux, ''F, value_check);
          (%o3) lambda([y], if y # 'baz_quux
                             then error(Cannot assign to `baz_quux'.))
          (%i4) baz_quux: 'baz_quux;
          (%o4)                       baz_quux
          (%i5) baz_quux: sqrt(2);
          Cannot assign to `baz_quux'.
          #0: lambda([y],if y # 'baz_quux then
                       error("Cannot assign to `baz_quux'."))(y=sqrt(2))
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) baz_quux;
          (%o6)                       baz_quux


 -- Función: dispfun (<f_1>, ..., <f_n>)
 -- Función: dispfun (all)
     Muestra la deficnión de las funciones de usuario <f_1>, ...,
     <f_n>. Cada argumento puede ser el nombre de una macro (definida
     mediante `::='), una función ordinaria (definida mediante `:=' o
     `define'), una función arreglo  (definida mediante `:=' o
     `define', pero encerrando los argumentos dentro de corchetes `[
     ]'), una función de subíndice (definida mediante `:=' o `define',
     pero encerrando algunos argumentos entre corchetes y otros entre
     paréntesis  `( )'), una función de subíndice seleccionada por un
     subíndice variable, o una función de subíndice definida con un
     subíndice constante.

     La llamada `dispfun (all)' muestra todas las funciones de usuario
     tal como las dan las listas `functions', `arrays' y `macros',
     omitiendo las funciones con subíndices definidas con subíndices
     constantes.

     La función `dispfun' crea una etiqueta (`%t1', `%t2', etc.) para
     cada función mostrada, y asigna la definición de la función a la
     etiqueta. En contraste, `fundef' devuelve las definiciones de las
     funciones.

     La función `dispfun' no evalúa sus argumentos; el operador de
     comilla-comilla `''' permite la evaluación.

     La función `dispfun' devuelve la lista de etiquetas de expresiones
     intermedias correspondientes a las funciones mostradas.

     Ejemplos:

          (%i1) m(x, y) ::= x^(-y);
                                               - y
          (%o1)                   m(x, y) ::= x
          (%i2) f(x, y) :=  x^(-y);
                                               - y
          (%o2)                    f(x, y) := x
          (%i3) g[x, y] :=  x^(-y);
                                              - y
          (%o3)                     g     := x
                                     x, y
          (%i4) h[x](y) :=  x^(-y);
                                              - y
          (%o4)                     h (y) := x
                                     x
          (%i5) i[8](y) :=  8^(-y);
                                              - y
          (%o5)                     i (y) := 8
                                     8
          (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
                                               - y
          (%t6)                   m(x, y) ::= x

                                               - y
          (%t7)                    f(x, y) := x

                                              - y
          (%t8)                     g     := x
                                     x, y

                                              - y
          (%t9)                     h (y) := x
                                     x

                                              1
          (%t10)                     h (y) := --
                                      5        y
                                              5

                                               1
          (%t11)                    h  (y) := ---
                                     10         y
                                              10

                                              - y
          (%t12)                    i (y) := 8
                                     8

          (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
          (%i12) ''%;
                               - y              - y            - y
          (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
                                                      x, y
                            - y           1              1             - y
                  h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
                   x              5        y   10         y   8
                                          5             10


 -- Variable del sistema: functions
     Valor por defecto: `[]'

     La variable `functions' es una lista que contiene los nombres de
     las funciones ordinarias de Maxima. Una función ordinaria es
     aquella que ha sido construida mediante cualquiera de los métodos
     `define' o `:=' y que es invocada utilizando paréntesis. Una
     función puede definirse durante una sesión de Maxima o en un
     fichero que posteriormente será cargado en memoria por `load' o
     `batch'.

     Las funciones array, que son invocadas con corchetes (`F[x]'), y
     las funciones subindicadas, que son las invocadas con corchetes y
     paréntesis (`F[x](y)') se registran en la variable global `arrays',
     no en `functions'.

     Las funciones Lisp no se registran en ninguna lista.

     Ejemplos:

          (%i1) F_1 (x) := x - 100;
          (%o1)                   F_1(x) := x - 100
          (%i2) F_2 (x, y) := x / y;
                                                x
          (%o2)                    F_2(x, y) := -
                                                y
          (%i3) define (F_3 (x), sqrt (x));
          (%o3)                   F_3(x) := sqrt(x)
          (%i4) G_1 [x] := x - 100;
          (%o4)                    G_1  := x - 100
                                      x
          (%i5) G_2 [x, y] := x / y;
                                               x
          (%o5)                     G_2     := -
                                       x, y    y
          (%i6) define (G_3 [x], sqrt (x));
          (%o6)                    G_3  := sqrt(x)
                                      x
          (%i7) H_1 [x] (y) := x^y;
                                                y
          (%o7)                     H_1 (y) := x
                                       x
          (%i8) functions;
          (%o8)              [F_1(x), F_2(x, y), F_3(x)]
          (%i9) arrays;
          (%o9)                 [G_1, G_2, G_3, H_1]


 -- Función: fundef (<f>)
     Devuelve la definición de la función <f>.

     Cada argumento puede ser el nombre de una macro (definida mediante
     `::='), una función ordinaria (definida mediante `:=' o `define'),
     una función arreglo  (definida mediante `:=' o `define', pero
     encerrando los argumentos dentro de corchetes `[ ]'), una función
     de subíndice (definida mediante `:=' o `define', pero encerrando
     algunos argumentos entre corchetes y otros entre paréntesis  `(
     )'), una función de subíndice seleccionada por un subíndice
     variable, o una función de subíndice definida con un subíndice
     constante.

     La función `fundef' no evalúa sus argumentos; el operador
     comilla-comilla `''' permite la evaluación.

     La llamada de función `fundef (<f>)' devuelve la definición de
     <f>. Por el contrario, `dispfun (<f>)' crea una etiqueta
     intermedia y le asigna la definición a la etiqueta.


 -- Función: funmake (<F>, [<arg_1>, ..., <arg_n>])
     Devuelve una expresión `<F>(<arg_1>, ..., <arg_n>)'.  El valor así
     retornado es simplificado pero no evaluado, de forma que la
     función <F> no es invocada, incluso cuando exista.

     La función `funmake' no hace distinciones entre funciones array y
     funciones ordinarias; cuando <F> es el nombre de una función array,
     `funmake' devuelve `<F>(...)', esto es, una llamada a función con
     paréntesis en lugar de corchetes.  La función `arraymake' devuelve
     una llamada a función con corchetes para estos casos.

     La función `funmake' evalúa sus argumentos.

     Ejemplos:

     La función `funmake' aplicada a una función ordinaria de Maxima.

          (%i1) F (x, y) := y^2 - x^2;
                                             2    2
          (%o1)                  F(x, y) := y  - x
          (%i2) funmake (F, [a + 1, b + 1]);
          (%o2)                    F(a + 1, b + 1)
          (%i3) ''%;
                                        2          2
          (%o3)                  (b + 1)  - (a + 1)

     La función `funmake' aplicada a una macro.

          (%i1) G (x) ::= (x - 1)/2;
                                            x - 1
          (%o1)                    G(x) ::= -----
                                              2
          (%i2) funmake (G, [u]);
          (%o2)                         G(u)
          (%i3) ''%;
                                        u - 1
          (%o3)                         -----
                                          2

     La función `funmake' aplicada a una función subindicada.

          (%i1) H [a] (x) := (x - 1)^a;
                                                  a
          (%o1)                   H (x) := (x - 1)
                                   a
          (%i2) funmake (H [n], [%e]);
                                                 n
          (%o2)               lambda([x], (x - 1) )(%e)
          (%i3) ''%;
                                              n
          (%o3)                       (%e - 1)
          (%i4) funmake ('(H [n]), [%e]);
          (%o4)                        H (%e)
                                        n
          (%i5) ''%;
                                              n
          (%o5)                       (%e - 1)

     La función `funmake' aplicada a un símbolo que no está asociado a
     función alguna.

          (%i1) funmake (A, [u]);
          (%o1)                         A(u)
          (%i2) ''%;
          (%o2)                         A(u)

     La función `funmake' evalúa sus argumentos, pero no el valor
     retornado.

          (%i1) det(a,b,c) := b^2 -4*a*c;
                                              2
          (%o1)              det(a, b, c) := b  - 4 a c
          (%i2) (x : 8, y : 10, z : 12);
          (%o2)                          12
          (%i3) f : det;
          (%o3)                          det
          (%i4) funmake (f, [x, y, z]);
          (%o4)                    det(8, 10, 12)
          (%i5) ''%;
          (%o5)                         - 284

     Maxima simplifica el valor retornado de `funmake'.

          (%i1) funmake (sin, [%pi / 2]);
          (%o1)                           1


 -- Función: lambda ([<x_1>, ..., <x_m>], <expr_1>, ..., <expr_n>)
 -- Function: lambda ([[<L>]], <expr_1>, ..., <expr_n>)
 -- Function: lambda ([<x_1>, ..., <x_m>, [<L>]], <expr_1>, ...,
          <expr_n>)
     Define y devuelve una expresión lambda (es decir, una función
     anónima).  La función puede tener argumentos <x_1>, ..., <x_m> y/o
     argumentos opcionales <L>, que aparecerán dentro del cuerpo de la
     función como una lista.  El valor que devuelve la función es
     <expr_n>.  Una expresión lambda puede asignarse a una variable y
     ser evaluada como si fuese una función ordinaria. Además, puede
     aparecer en algunos contextos en los que sea necesario un nombre
     de función.

     Cuando se evalúa la función, se crean las variables <x_1>, ...,
     <x_m> sin asignación de valores. Una función `lambda' puede
     aparecer dentro de un `block' o de otra `lambda'. Las variables
     locales se inicializan cada vez que se entra dentro de un nuevo
     bloque o de otra función `lambda'. Las variables locales se
     consideran globales dentro de un bloque o función `lambda' anidado
     dentro del primero. Si una variable es no local dentro de un
     bloque o función `lambda', su valor es el que le corresponde en el
     bloque o función `lambda' superior. Este criterio se conoce con el
     nombre de "alcance dinámico".

     Una vez establecidas las variables locales <expr_1> a <expr_n> son
     secuencialmente evaluadas. La variable especial  `%%' representa
     el valor de la expresión inmediata anterior. Las sentencias
     `throw' y `catch' pueden aparecer también en la lista de
     expresiones.

     La función `return' no puede aparecer en una expresión `lambda' a
     menos que se encuentre acotada dentro de un bloque (`block'), en
     cuyo caso `return' establece el valor de retorno del bloque, pero
     no de la expresión `lambda', a menos que el bloque resulte ser
     precisamente <expr_n>. De igual manera, `go' no puede aparecer en
     una expresión `lambda' si no es dentro de un `block'.

     Las funciones `lambda' no evalúan sus argumentos;  el operador
     comilla-comilla `''' permite su evaluación.

     Ejemplo:

        * Una función lambda puede asignarse a una variable y ser
          evaluada como si fuese una función ordinaria.

          (%i1) f: lambda ([x], x^2);
                                                2
          (%o1)                    lambda([x], x )
          (%i2) f(a);
                                          2
          (%o2)                          a

        * Una expresión lambda puede aparecer en algunos contextos en
          los que sea necesario un nombre de función.

          (%i3) lambda ([x], x^2) (a);
                                          2
          (%o3)                          a
          (%i4) apply (lambda ([x], x^2), [a]);
                                          2
          (%o4)                          a
          (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
                                  2   2   2   2   2
          (%o5)                 [a , b , c , d , e ]

        * Los argumentos son variables locales. Otras variables se
          consideran globales. Las variables globales son evaluadas en
          el momento que lo es la expresión, a menos que la evaluación
          de las mismas sea forzada, como cuando se hace uso de `'''.

          (%i6) a: %pi$
          (%i7) b: %e$
          (%i8) g: lambda ([a], a*b);
          (%o8)                   lambda([a], a b)
          (%i9) b: %gamma$
          (%i10) g(1/2);
                                       %gamma
          (%o10)                       ------
                                         2
          (%i11) g2: lambda ([a], a*''b);
          (%o11)                lambda([a], a %gamma)
          (%i12) b: %e$
          (%i13) g2(1/2);
                                       %gamma
          (%o13)                       ------
                                         2

        * Las expresiones lambda pueden anidarse. Las variables locales
          de expresiones lambda exteriores se consideran globales en
          expresiones internas, a menos que se enmascaren con variables
          locales de igual nombre.

          (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
                                                             1
          (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
                                                             2
          (%i15) h(%pi, %gamma);
                                       %gamma
          (%o15)                       ------
                                         2

        * Puesto que `lambda' no evalúa sus argumentos, la expresión
          lambda `i' de más abajo no define una función del tipo
          "multiplicar por `a'". Tal tipo de función se puede definir a
          través de `buildq', como en la expresión lambda `i2' de más
          abajo.

          (%i16) i: lambda ([a], lambda ([x], a*x));
          (%o16)            lambda([a], lambda([x], a x))
          (%i17) i(1/2);
          (%o17)                  lambda([x], a x)
          (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
          (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
          (%i19) i2(1/2);
                                               x
          (%o19)                   lambda([x], -)
                                               2
          (%i20) i2(1/2)(%pi);
                                         %pi
          (%o20)                         ---
                                          2

        * Una expresión lambda puede tener un número variable de
          argumentos, los cuales se indican mediante `[<L>]', bien sea
          solo o como un último argumento. Estos argumentos aparecerán
          dentro del cuerpo de la función en forma de lista.

          (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
          (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
          (%i2) f (foo, %i, 17, 29, 256);
          (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
          (%i3) g : lambda ([[aa]], apply ("+", aa));
          (%o3)             lambda([[aa]], apply(+, aa))
          (%i4) g (17, 29, x, y, z, %e);
          (%o4)                  z + y + x + %e + 46

 -- Función: local (<v_1>, ..., <v_n>)
     Declara las variables  <v_1>, ..., <v_n> locales respecto de todas
     las propiedades en la sentencia en la que aparece esta función.

     La función `local' no evalúa sus argumentos y devuelve `done'.

     La función `local' sólo puede usarse dentro de un `block', en el
     cuerpo de definición de funciones o de expresiones `lambda' o en
     la función `ev', siéndole permitido aparecer una sóla vez en cada
     una de ellas.

     La función `local' es independiente de `context'.


 -- Variable opcional: macroexpansion
     Valor por defecto: `false'

     La variable `macroexpansion' controla si la expansión (esto es, el
     valor de retorno) de una función macro se sustituye por la llamada
     a la función macro. Una sustitución puede acelerar futuras
     evaluaciones de la expresión, bajo el coste que implica tener que
     almacenar la expansión.

    `false'
          La expansión de una función macro no se sustituye por la
          llamada a la función macro.

    `expand'
          La primera vez que se evalúa una llamada a función macro se
          almacena la expansión. De esta manera la expansión no se
          recalcula en llamadas posteriores; cualesquiera efectos
          laterales (como `print' o asignaciones a variables globales)
          tan solo tienen lugar la primera vez que la función macro es
          evaluada. La expansión en una expresión no afecta a otras
          expresiones que llamen a la misma función macro.

    `displace'
          La primera vez que se evalúa una llamada a una función macro,
          la expansión se sustituye por la llamada, modificando así la
          expresión desde la que se hizo la llamada a la función macro.
          La expansión no se recalcula en llamadas posteriores;
          cualesquiera efectos laterales tan solo tienen lugar la
          primera vez que la función macro es evaluada. La expansión en
          una expresión no afecta a otras expresiones que llamen a la
          misma función macro.

     Ejemplos:

     Si `macroexpansion' vale `false', una función macro es llamada
     cada vez que la expresión de llamada es evaluada.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
                                 return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                               return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
                                 return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                               return(x - 99))
          (%i4) macroexpansion: false;
          (%o4)                         false
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                            h(x)
          (%t6)                     f(x) := ----
                                            g(x)

          (%o6)                         done
          (%i7) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o7)                       --------
                                      a b + 99

     Si `macroexpansion' vale `expand', una función macro tan solo es
     llamada una vez.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
                                 return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                               return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
                                 return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                               return(x - 99))
          (%i4) macroexpansion: expand;
          (%o4)                        expand
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                            h(x)
          (%t6)                     f(x) := ----
                                            g(x)

          (%o6)                         done
          (%i7) f (a * b);
                                      a b - 99
          (%o7)                       --------
                                      a b + 99

     Si `macroexpansion' vale `expand', una función macro es llamada
     una vez y la expresión de llamada se modifica.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                            return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                            return(x - 99))
          (%i4) macroexpansion: displace;
          (%o4)                       displace
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                           x - 99
          (%t6)                    f(x) := ------
                                           x + 99

          (%o6)                         done
          (%i7) f (a * b);
                                      a b - 99
          (%o7)                       --------
                                      a b + 99


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

     Cuando `mode_checkp' vale `true', `mode_declare' chequea los modos
     de las variables con valores asignados.


 -- Variable opcional: mode_check_errorp
     Valor por defecto: `false'

     Cuando `mode_check_errorp' vale `true', `mode_declare' llama a
     error.


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

     Cuando `mode_check_warnp' vale `true', se detallan los errores de
     modo.


 -- Función: mode_declare (<y_1>, <modo_1>, ..., <y_n>, <modo_n>)
     La función `mode_declare' se utiliza para declarar los modos de
     variables y funciones para la ulterior traducción a Lisp o
     compilación de funciones. Se coloca habitualmente al comienzo de
     la definición de una función, de un script en Maxima o se ejecuta
     en tiempo real.

     Los argumentos de `mode_declare' son pares formados por una
     variable y un modo, el cual debe ser `boolean', `fixnum',
     `number', `rational' o `float'. Cada variable puede ser sustituida
     por una lista de variables, en cuyo caso todas ellas tendrán el
     mismo modo.

     Código numérico que utilice arreglos puede ejecutarse más rápido
     declarando el tamaño que va a ocupar el arreglo, como en:

          mode_declare (array (a [10, 10]), float)

     para un arreglo de números en coma flotante de dimensiones 10 x 10.

     Se puede declarar el modo del resultado de una función poniendo
     `function (f_1, f_2, ...)' como argumento; aquí `f_1', `f_2', ...
     son los nombres de las funciones. Por ejemplo, la expresión

          mode_declare ([function (f_1, f_2, ...)], fixnum)

     declara que el valor a devolver por  `f_1', `f_2', ... son enteros
     de modo "single-word".

     El nombre `modedeclare' es sinónimo de `mode_declare'.


 -- Función: mode_identity (<arg_1>, <arg_2>)
     Es una forma especial usada con `mode_declare' y `macros' para
     declarar, por ejemplo, una lista de listas de números.


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

     Si `transcompile' vale `true', `translate' y `translate_file'
     generan declaraciones para hacer el código traducido más apto para
     la compilación.

     La función `compfile' hace la asignación `transcompile: true'.


 -- Función: translate (<f_1>, ..., <f_n>)
 -- Función: translate (functions)
 -- Función: translate (all)
     Traduce las funciones definidas por el usuario <f_1>, ..., <f_n>
     del lenguaje de Maxima a Lisp y evalúa las traducciones Lisp.
     Normalmente las funciones traducidas se ejecutan más rapidamente
     que las originales.

     Las llamadas `translate (all)' o `translate (functions)' traducen
     todas las funciones de usuario.

     Las funciones a ser traducidas deberían incluir una llamada a
     `mode_declare' al comienzo siempre que sea posible, a fin de
     producir código más eficiente. Por ejemplo:

          f (x_1, x_2, ...) := block ([v_1, v_2, ...],
              mode_declare (v_1, modo_1, v_2, modo_2, ...), ...)

     donde <x_1>, <x_2>, ... son los parámetros que se pasan a la
     función y <v_1>, <v_2>, ... son las variables locales.

     Los nombres de las funciones traducidas son eliminados de la lista
     `functions' si `savedef' vale `false' (ver más abajo) y son
     añadidos a las listas `props'.

     Las funciones no deberían ser traducidas hasta no estar
     completamente depuradas.

     Se supone que las expresiones están simplificadas; en caso de no
     estarlo, se generará código correcto pero ineficiente. Así, el
     usuario no debería asignar a `simp' el valor `false', el cual
     inhibe la simplificación de la expresión a ser traducida.

     Cuando la variable `translate' vale `true', se traducen
     automáticamente las funciones de usuario a Lisp.

     Nótese que las funciones traducidas puede que no se ejecuten
     exactamente igual a como lo hacían antes de la traducción, debido
     a posibles incompatibilidades entre las versiones de Maxima y
     Lisp. En general, la función `rat' con más de un argumento y la
     función `ratvars' no deberían utilizarse si algunas de las
     variables son declaradas como expresiones racionales canónicas
     (CRE) mediante `mode_declare'. Además, la asignación  `prederror:
     false' no traducirá.

     Si `savedef' vale `true', entonces la versión de Maxima de una
     función de usuario permanecerá cuando la función sea traducida por
     `translate'. Con esto se hace posible que se muestre la definición
     llamando a `dispfun' y que la función sea editada.

     Si `transrun' vale `false' entonces las versiones interpretadas de
     todas las funciones serán ejecutadas en lugar de las versiones
     traducidas.

     El resultado devuelto por `translate' es una lista con los nombres
     de las funciones traducidas.


 -- Función: translate_file (<nombre_fichero_maxima>)
 -- Función: translate_file (<nombre_fichero_maxima>,
          <nombre_fichero_lisp>)
     Traduce un fichero en código Maxima a un fichero en código Lisp.
     La función `translate_file' devuelve una lista con los nombres de
     tres ficheros: el nombre del ficheero en Maxima, el nombre del
     fichero en Lisp y el nombre del fichero que contiene información
     adicional sobre la traducción. La función `translate_file' evalúa
     sus argumentos.

     La llamada `translate_file ("foo.mac"); load("foo.LISP")' es lo
     mismo que `batch ("foo.mac")', excepto por la presencia de ciertas
     restricciones, como el uso de `''' y `%', por ejemplo.

     La llamada `translate_file (<nombre_fichero_maxima>)' traduce un
     fichero en Maxima, <nombre_fichero_maxima>, a otro en Lisp de
     nombre similar. Por ejemplo, `foo.mac' se traduce en `foo.LISP'.
     El nombre del fichero en Maxima puede incluir el nombre de un
     directorio, en cuyo caso el fichero de salida Lisp se guardará en
     el mismo directorio desde el que se leyó la fuente Maxima.

     La llamada `translate_file (<nombre_fichero_maxima>,
     <nombre_fichero_lisp>)' traduce el fichero Maxima
     <nombre_fichero_maxima> en el fichero Lisp <nombre_fichero_lisp>.
     La función `translate_file' ignora la extensión del fichero, en
     caso de que exista, de `nombre_fichero_lisp'; la extensión del
     fichero de salida Lisp  será invariablemente `LISP'. El nombre del
     fichero Lisp puede incluir la ruta del directorio, en cuyo caso se
     almacenará en el directorio especificado.

     La función `translate_file' también escribe un fichero de mensajes
     de avisos del traductor con diversos niveles de gravedad. La
     extensión de este fichero es `UNLISP'. Este fichero puede contener
     información valiosa, aunque de difícil interpretación, para
     detectar fallos en el código traducido. El fichero `UNLISP' se
     guarda siempre en el mismo directorio desde el que se leyó la
     fuente de Maxima.

     La función `translate_file' emite código Lisp que incluye algunas
     declaraciones y definiciones que entran en efecto tan pronto como
     el código Lisp es compilado. Véase `compile_file' para más
     información sobre este particular.

     Véanse también `tr_array_as_ref', `tr_bound_function_applyp',
     `tr_exponent', `tr_file_tty_messagesp',
     `tr_float_can_branch_complex', `tr_function_call_default',
     `tr_numer', `tr_optimize_max_loop', `tr_semicompile',
     `tr_state_vars', `tr_warnings_get', `tr_warn_bad_function_calls',
     `tr_warn_fexpr', `tr_warn_meval', `tr_warn_mode',
     `tr_warn_undeclared', `tr_warn_undefined_variable', y `tr_windy'.


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

     Si `transrun' vale `false' entonces se ejecutarán las versiones
     interpretadas de todas las funciones, en lugar de las versiones
     traducidas.


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

     Si `translate_fast_arrays' vale `false', referencias de arreglos
     en el código Lisp creadas por  `translate_file' se ven afectadas
     por `tr_array_as_ref'.

     El valor de la variable `tr_array_as_ref' no tiene ningún efecto
     cuando `translate_fast_arrays' vale `true'.


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

     Si `tr_bound_function_applyp' vale `true', Maxima envía un aviso
     si encuentra una variable con valor asignado que está siendo
     utilizada como una función. `tr_bound_function_applyp' no influye
     en el código generado bajo estas circunstancias.

     Por ejemplo, una expresión como `g (f, x) := f (x+1)' provocará un
     mensaje de esta naturaleza.


 -- Variable opcional: tr_file_tty_messagesp
     Valor por defecto: `false'

     Si `tr_file_tty_messagesp' vale `true', los mensajes generados por
     `translate_file' durante la traducción de un fichero se muestran
     en la consola y se insertan en el fichero UNLISP.  Si vale
     `false', los mensajes sobre la traducción del fichero sólo se
     incorporan al fichero UNLISP.


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

     Le dice al traductor de Maxima a Lisp que las funciones `acos',
     `asin', `asec' y `acsc' pueden devolver valores complejos.


 -- Variable opcional: tr_function_call_default
     Valor por defecto: `general'

     El valor `false' significa llama a `meval', `expr' significa que
     Lisp asignó los argumentos de la función,  `general', el valor por
     defecto, devuelve código apropiado para `mexprs' y `mlexprs' pero
     no para `macros'. La opción `general' asegura que las asignaciones
     de las variables son correctas en el código compilado. En modo
     `general', cuando se traduce F(X), si F es una variable con valor,
     entonces se entiende que se quiere calcular `apply (f, [x])', y
     como tal se traduce, con el apropiado aviso. No es necesario
     desactivar esto. Con los valores por defecto la falta de mensajes
     de aviso implica compatibilidad completa entre el código traducido
     y compilado con el interpretado por Maxima.


 -- Variable opcional: tr_numer
     Valor por defecto: `false'

     Si `tr_numer' vale `true' se utilizan las propiedades numéricas en
     aquellos átomos que las posean, como en  `%pi'.


 -- Variable opcional: tr_optimize_max_loop
     Valor por defecto: 100

     El valor de `tr_optimize_max_loop' es el número máximo de veces
     que el traductor repetirá la macro-expansión y la optimización en
     el tratamiento de una expresión.


 -- Variable opcional: tr_semicompile
     Valor por defecto: `false'

     Si `tr_semicompile' vale `true', las salidas de `translate_file' y
     `compfile' serán macro-expandidas pero no compiladas a código
     máquina por el compilador de Lisp.


 -- Variable del sistema: tr_state_vars
     Valor por defecto:

          [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
          tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
          tr_function_call_default, tr_array_as_ref,tr_numer]

     Es la lista de variables que afectan la forma en que se obtiene la
     salida del código traducido. Esta información es útil para
     desarrolladores que pretendan corregir posibles fallos del
     traductor. Comparando el código traducido con el que se debería
     obtener bajo unas ciertas condiciones, es posible hacer el
     seguimiento de los fallos.


 -- Función: tr_warnings_get ()
     Devuelve una lista con los avisos dados por el traductor.


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

     Devuelve un aviso cuando se hacen llamadas a funciones que quizás
     no sean correctas debido a declaraciones inapropiadas realizadas
     durante la traducción.


 -- Variable opcional: tr_warn_fexpr
     Valor por defecto: `compfile'

     Devuelve un aviso si se encuentra con alguna FEXPR. Las FEXPR no
     deberían aparecer en el código traducido.


 -- Variable opcional: tr_warn_meval
     Valor por defecto: `compfile'

     Devuelve un aviso si la función `meval' es llamada.  Si `meval' es
     invocada, es señal de la presencia de problemas en la traducción.


 -- Variable opcional: tr_warn_mode
     Valor por defecto: `all'

     Devuelve un aviso cuando a las variables se les asignan valores
     incompatibles con su modo.


 -- Variable opcional: tr_warn_undeclared
     Valor por defecto: `compile'

     Determina cuando enviar mensajes sobre variables no declaradas.


 -- Variable opcional: tr_warn_undefined_variable
     Valor por defecto: `all'

     Devuelve un aviso cuando se detectan variables globales no
     definidas.


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

     Genera comentarios de ayuda y consejos sobre programación.


 -- Función: compile_file (<nombre_fich>)
 -- Función: compile_file (<nombre_fich>, <nombre_fich_compilado>)
 -- Función: compile_file (<nombre_fich>, <nombre_fich_compilado>,
          <nombre_fich_lisp>)
     Traduce el fichero Maxima <nombre_fich> a Lisp, ejecuta el
     compilador de Lisp y, en caso de ser exitosa la compilación, carga
     el código compilado en Maxima.

     La función `compile_file' devuelve una lista con los nombres de
     tres ficheros: el fichero original en Maxima, la traducción Lisp,
     notas sobre la traducción y el código compilado. Si la compilación
     falla, el cuarto elemento es  `false'.

     Algunas declaraciones y definiciones entran en efecto tan pronto
     como el código Lisp es compilado (sin cargar el código compilado).
     Éstas incluyen funciones definidas con el operador `:=', macros
     definidas con el operador `::=', `alias', `declare',
     `define_variable',  `mode_declare' y `infix', `matchfix', `nofix',
     `postfix', `prefix' y `compfile'.

     Asignaciones y llamadas a funciones no se evalúan hasta que el
     código compilado es cargado. En particular, dentro del fichero
     Maxima, asignaciones a los controles ("flags") de traducción
     (`tr_numer', etc.) no tienen efecto durante la traducción.

     El <nombre_fich> no puede contener sentencias del tipo `:lisp'.

     La función `compile_file' evalúa sus argumentos.


 -- Función: declare_translated (<f_1>, <f_2>, ...)
     Cuando se traduce un fichero de código Maxima a Lisp, es
     importante para el traductor saber qué funciones de las que están
     en el fichero van a ser llamadas como traducidas o compiladas, y
     cuáles son simplemente funciones Maxima o que no están definidas.
     Se genera el código `(MFUNCTION-CALL fn arg1 arg2 ...)' cuando el
     traductor no sabe si `fn' va a ser una función lisp.



File: maxima.info,  Node: Programación,  Next: Depurado,  Prev: Definición de Funciones,  Up: Top

40 Programación
***************

* Menu:

* Introducción a la programación::
* Funciones y variables para la programación::


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

40.1 Introducción a la programación
===================================

Maxima dispone de los bucles `do' para hacer iteraciones, así como
estructuras más primitivas del estilo de `go'.


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

40.2 Funciones y variables para la programación
===============================================

 -- Función: backtrace ()
 -- Función: backtrace (<n>)
     Devuelve la pila de llamadas, esto es, la lista de funciones que
     han llamado a la función actualmente activa.

     La llamada a `backtrace()' devuelve la pila completa de llamadas.

     Ejemplos:

          (%i1) h(x) := g(x/7)$
          (%i2) g(x) := f(x-11)$
          (%i3) f(x) := e(x^2)$
          (%i4) e(x) := (backtrace(), 2*x + 13)$
          (%i5) h(10);
          #0: e(x=4489/49)
          #1: f(x=-67/7)
          #2: g(x=10/7)
          #3: h(x=10)
                                        9615
          (%o5)                         ----
                                         49

     La llamada `backtrace (<n>)' devuelve las <n> funciones más
     recientes, incluyendo a la función actualmente activa.

     Ejemplos:

          (%i1) h(x) := (backtrace(1), g(x/7))$
          (%i2) g(x) := (backtrace(1), f(x-11))$
          (%i3) f(x) := (backtrace(1), e(x^2))$
          (%i4) e(x) := (backtrace(1), 2*x + 13)$
          (%i5) h(10);
          #0: h(x=10)
          #0: g(x=10/7)
          #0: f(x=-67/7)
          #0: e(x=4489/49)
                                        9615
          (%o5)                         ----
                                         49


 -- Operador especial: do
     La sentencia `do' se utiliza para realizar iteraciones.  Debido a
     su generalidad la sentencia `do' se describirá en dos partes. En
     primer lugar se mostrará su forma más usual, análoga a la de otros
     lenguajes de programación (Fortran, Algol, PL/I, etc.); después se
     mencionarán otras formas de uso.

     Hay tres variantes de esta sentencia que se diferencian entre sí
     únicamente por las condiciones de fin de bucle. Son las siguientes:

        * `for <variable>: <valor_inicial> step <incremento>       thru
          <límite> do <cuerpo>'

        * `for <variable>: <valor_inicial> step <incremento>
          while <condición> do <cuerpo>'

        * `for <variable>: <valor_inicial> step <incremento>
          unless <condición> do <cuerpo>'

     El <valor_inicial>, el <incremento>, el <límite> y el <cuerpo>
     pueden ser cualquier tipo de expresión válida de Maxima. Si el
     incremento es igual a la unidad (1) entonces "`step 1'" puede
     omitirse.

     La ejecución de la sentencia `do' se realiza asignando el
     valor_inicial a la variable (llamada de aquí en adelante
     variable-control). A continuación: (1) si la variable-control ha
     excedido el límite de la especificación dada por un `thru', o si
     la condición impuesta por `unless' es verdadera (`true'), o si la
     condición dada por `while' es falsa (`false') entonces la
     iteración `do' termina. (2) El cuerpo se evalúa.  (3) El
     incremento es sumado a la variable-control. El proceso de (1) a
     (3) se repite hasta que la condición de fin de iteración se
     satisfaga. También es posible especificar varias condiciones de
     terminación del bucle, en cuyo caso `do' terminará cuando se
     satisfaga alguna de ellas.

     En general la condición `thru' se satisfará cuando la
     variable-control sea mayor que el límite si el incremento es no
     negativo, o cuando la variable-control sea menor que el límite
     cuando el incremento es negativo. El incremento y el límite pueden
     ser expresiones no numéricas, tanto en cuanto esta desigualdad
     pueda quedar determinada. Sin embargo, a menos que el incremento
     sea un número negativo en el momento de comenzar el cómputo de
     `do', Maxima supondrá que se evaluará a una cantidad positiva. En
     caso de no ser efectivamente positivo, la sentencia `do' puede dar
     un resultado inesperado.

     Nótese que el límite, el incremento y la condición de terminación
     se evalúan en cada iteración del bucle. Así, si alguna de
     expresiones necesitan de muchos cálculos y devuelven un resultado
     que no va a cambiar durante toda la ejecución del cuerpo, será más
     eficiente dar este valor a una variable antes de comenzar la
     sentencia `do' y utilizarla luego durante su ejecución.

     El valor que habitualmente devuelva la sentencia `do' será el
     átomo `done'. Sin embargo, la función `return' puede usarse dentro
     del cuerpo para salir de `do' de forma prematura retornando un
     valor determinado.  Nótese no obstante que un `return' dentro de
     un `do' que está dentro de un bloque (`block') provocará una
     salida de `do' pero no de `block'. Repárese también en que la
     función `go' no puede usarse para salir de `do' e ir a algún lugar
     de `block'.

     La variable-control es siempre local respecto de `do', por lo que
     se puede utilizar cualquier nombre de variable sin afectar el
     valor de cualquier otra variable externa a `do' y que tenga el
     mismo nombre. La variable-control no tendrá asignado ningún valor
     una vez se haya concluido el `do'.

          (%i1) for a:-3 thru 26 step 7 do display(a)$
                                       a = - 3

                                        a = 4

                                       a = 11

                                       a = 18

                                       a = 25

          (%i1) s: 0$
          (%i2) for i: 1 while i <= 10 do s: s+i;
          (%o2)                         done
          (%i3) s;
          (%o3)                          55

     Nótese que la condición `while i <= 10' es equivalente a `unless i
     > 10' y a `thru 10'.

          (%i1) series: 1$
          (%i2) term: exp (sin (x))$
          (%i3) for p: 1 unless p > 7 do
                    (term: diff (term, x)/p,
                     series: series + subst (x=0, term)*x^p)$
          (%i4) series;
                            7    6     5    4    2
                           x    x     x    x    x
          (%o4)            -- - --- - -- - -- + -- + x + 1
                           90   240   15   8    2

     lo que da ocho términos del desarrollo de Taylor de la función
     `e^sin(x)'.

          (%i1) poly: 0$
          (%i2) for i: 1 thru 5 do
                    for j: i step -1 thru 1 do
                        poly: poly + i*x^j$
          (%i3) poly;
                            5      4       3       2
          (%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
          (%i4) guess: -3.0$
          (%i5) for i: 1 thru 10 do
                    (guess: subst (guess, x, 0.5*(x + 10/x)),
                     if abs (guess^2 - 10) < 0.00005 then return (guess));
          (%o5)                  - 3.162280701754386

     Este ejemplo calcula la raíz cuadrada negativa de 10 haciendo 10
     iteraciones del método de Newton-Raphson. De no haberse alcanzado
     el criterio de convergencia el valor devuelto hubiese sido `done'.

     En lugar de añadir siempre una cantidad a la variable-control a
     veces se puede querer que cambie en cada iteración siguiendo algún
     otro criterio. En tal caso se puede hacer uso de `next
     <expresión>' en lugar de `step <incremento>'. Esto hará que a la
     variable-control se le asigne el resultado de evaluar la expresión
     en cada iteración del bucle.

          (%i6) for count: 2 next 3*count thru 20 do display (count)$
                                      count = 2

                                      count = 6

                                     count = 18

     En ocasiones puede interesar realizar una iteración en la que la
     variable-control no se utilice nunca. Se podrá entonces dar
     únicamente las condiciones de terminación del bucle omitiendo la
     inicialización y actualizando la información, tal como se hace en
     el siguiente ejemplo para calcular la raíz cuadrada de 5
     utilizando un valor inicial alejado de la solución.

          (%i1) x: 1000$
          (%i2) thru 20 do x: 0.5*(x + 5.0/x)$
          (%i3) x;
          (%o3)                   2.23606797749979
          (%i4) sqrt(5), numer;
          (%o4)                   2.23606797749979

     Si así se quiere, incluso es posible omitir las condiciones de
     terminación completamente y escribir únicamente `do <body>', lo
     que provocará entrar en un bucle infinito. En tal caso, debería
     usarse la función `return' a fin de terminar con la ejecución de
     `do'.

          (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
                    do (y: ev(df), x: x - f(x)/y,
                        if abs (f (x)) < 5e-6 then return (x)))$
          (%i2) sqr (x) := x^2 - 5.0$
          (%i3) newton (sqr, 1000);
          (%o3)                   2.236068027062195

     (En este ejemplo, cuando se ejecuta `return' obliga a que sea `x'
     el valor devuelto por `do'. Al salirse del bloque, `x' es también
     el valor que devuelve `block' por ser `do' la última sentencia del
     bloque.)

     Hay todavía otra forma de `do' en Maxima. Su sintaxis es:

          for <variable> in <lista> <test_de_parada> do <cuerpo>

     Los elementos de <list> son cualesquiera expresiones que se irán
     asignando sucesivamente a la variable en cada repetición del
     cuerpo. El test de parada <end_tests> (que es opcional) puede
     usarse para terminar la ejecución de `do'; de otro modo las
     iteraciones se pararán cuando la lista se haya agotado o cuando se
     ejecute un `return' dentro del cuerpo.  (De hecho, la lista puede
     ser cualquier expresión no atómica, de la cual se irán extrayendo
     de forma sucesiva sus diferentes partes.)

          (%i1)  for f in [log, rho, atan] do ldisp(f(1))$
          (%t1)                                  0
          (%t2)                                rho(1)
                                               %pi
          (%t3)                                 ---
                                                4
          (%i4) ev(%t3,numer);
          (%o4)                             0.78539816


 -- Función: errcatch (<expr_1>, ..., <expr_n>)
     Evalúa las expresiones <expr_1>, ..., <expr_n> una a una y
     devuelve `[<expr_n>]' (una lista) en caso de que no ocurra ningún
     error. En caso de aparecer algún error durante el cálculo de
     alguno de los argumentos, `errcatch' evita que el error se
     propague y devuelve la lista vacía `[]' sin evaluar más argumentos.

     La función `errcatch' es útil en ficheros `batch' donde se
     sospeche que pueda aparecer algún error, el cual provocaría la
     terminación de la ejecución del `batch' de no ser previamente
     detectado.


 -- Función: error (<expr_1>, ..., <expr_n>)
 -- Variable del sistema: error
     Calcula y devuelve <expr_1>, ..., <expr_n>, enviando
     posteriormente una seãl de error a Maxima o al `errcatch' más
     cercano.

     A la variable `error' se le asigna una lista con la descripción
     del error. El primer elemento de `error' es una cadena de formato,
     la cual une todas las cadenas de los argumentos <expr_1>, ...,
     <expr_n>, siendo los demás elementos de la lista los valores de
     los argumentos que no son cadenas.

     La llamada a `errormsg()' formatea e imprime `error'. Se reimprime
     así el mensaje de error más reciente.


 -- Función: errormsg ()
     Reimprime el mensaje de error más reciente. La variable `error'
     guarda el mensaje y `errormsg' lo formatea e imprime.


 -- Operador especial: for
     Utilizado en las iteraciones. Véase `do' para una descripción de
     las técnicas de iteración en Maxima.


 -- Función: go (<etiqueta>)
     Se utiliza dentro de un bloque (`block') para transferir el
     control a la sentencia del bloque que esté etiquetada con el
     argumento de `go'. Una sentencia queda etiquetada cuando está
     precedida por un argumento de tipo átomo como cualquier otra
     sentencia de `block'.  Por ejemplo:

          block ([x], x:1, tururu, x+1, ..., go(tururu), ...)

     El argumento de `go' debe ser el nombre de una etiqueta que
     aparezca en el mismo bloque (`block'). No se puede utilizar `go'
     para transferir el control a un bloque que no sea aquel que
     contenga la sentencia `go'.


 -- Operador especial: if
     Evaluación condicionada. Se reconocen varias formas de expresiones
     `if'.

     La expresión `if <cond_1> then <expr_1> else <expr_0>' devuelve
     <expr_1> si <cond_1> vale `true', en caso contrario la respuesta
     es `expr_0'.

     La expresión `if <cond_1> then <expr_1> elseif <cond_2> then
     <expr_2> elseif ... else <expr_0>' devuelve <expr_k> si <cond_k>
     vale `true' y todas las condiciones anteriores toman el valor
     `false'.  Si ninguna de las condiciones vale `true', la respuesta
     es `expr_0'.

     La falta de un `else' final se interpreta como un `else false';
     esto es, la expresión `if <cond_1> then <expr_1>' equivale a `if
     <cond_1> then <expr_1> else false', y `if <cond_1> then <expr_1>
     elseif ... elseif <cond_n> then <expr_n>' equivale a su vez a `if
     <cond_1> then <expr_1> elseif ... elseif <cond_n> then <expr_n>
     else false'.

     Las alternativas <expr_0>, ..., <expr_n> pueden ser expresiones
     válidas de Maxima, incluidas expresiones `if' anidadas.  Las
     alternativas ni se simplifican ni se evalúan, a menos que su
     condición asociada valga `true'.

     Las condiciones <cond_1>, ..., <cond_n> deben ser expresiones
     capaces de dar como resultado `true' o `false' al ser evaluadas.
     Si en un momento dado una condición no da como resultado un valor
     de verdad (`true' o `false'), el comportamiento de `if' se controla
     con la variable global `prederror'. Si `prederror' vale `true', se
     considera un error que la condición evaluada no dé como resultado
     un valor de verdad; en caso contrario, las condiciones que no den
     como resultado un valor de verdad se aceptan, dándose el resultado
     como una expresión condicional.

     Las condiciones pueden contener operadores lógicos y relacionales,
     así como otros elementos, tal como se indica a continuación:

          Operación               Símbolo     Tipo

          menor que               <           operador relacional infijo
          menor o igual que       <=          operador relacional infijo
          igualdad (sintáctica)   =           operador relacional infijo
          negación de =           #           operador relacional infijo
          igualdad (por valor)    equal       operador relacional infijo
          negación de equal       notequal    operador relacional infijo
          mayor o igual que       >=          operador relacional infijo
          mayor que               >           operador relacional infijo
          y                       and         operador lógico infijo
          o                       or          operador lógico infijo
          no                      not         operador lógico prefijo


 -- Función: map (<f>, <expr_1>, ..., <expr_n>)
     Devuelve una expresión cuyo operador principal es el mismo que
     aparece en las expresiones <expr_1>, ..., <expr_n> pero cuyas
     subpartes son los resultados de aplicar <f> a cada una de las
     subpartes de las expresiones;  <f> puede ser tanto el nombre de
     una función de n argumentos como una expresión `lambda' de n
     argumentos.

     Uno de los usos que tiene `map' es la de aplicar (o mapear) una
     función (por ejemplo, `partfrac') sobre cada término de una
     expresión extensa en la que normalmente no se podría utilizar la
     función debido a insuficiencias en el espacio de almacenamiento
     durante el curso de un cálculo.

          (%i1) map(f,x+a*y+b*z);
          (%o1)                        f(b z) + f(a y) + f(x)
          (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                                     1       1        1
          (%o2)                     ----- - ----- + -------- + x
                                   x + 2   x + 1          2
                                                   (x + 1)
          (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                                1
          (%o3)                            y + ----- + 1
                                              x + 1
          (%i4) map("=",[a,b],[-0.5,3]);
          (%o4)                          [a = - 0.5, b = 3]

     Véase también `maperror' .

 -- Función: mapatom (<expr>)
     Devuelve `true' si y sólo <expr> es tratado por las rutinas de
     mapeo como un átomo.

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

     Cuando `maperror' toma el valor `false', hace que todas las
     funciones de mapeo, como por ejemplo

          map (f, <expr_1>, <expr_2>, ...)

     (1) paren cuando hayan terminado de procesar la <expr_i> más corta,
     a menos que todas ellas sean del mismo tamaño y (2) apliquen  `f'
     a `[expr_1, expr_2, ...]' si es el caso que las `expr_i' no son
     todas del mismo tipo de objeto.

     Cuando `maperror' toma el valor `true' entonces se emite un
     mensaje de error cuando se presenta cualquiera de los dos casos
     anteriores.


 -- Función: maplist (<f>, <expr_1>, ..., <expr_n>)
     Devuelve una lista con las aplicaciones de <f> a las partes de las
     expresiones <expr_1>, ..., <expr_n>; <f> es el nombre de una
     función ou una expresión lambda.

     La función `maplist' difiere de `map (<f>, <expr_1>, ...,
     <expr_n>)', la cual devuelve una expresión con el mismo operador
     principal que tenga <expr_i>, excepto en simplificaciones y en el
     caso en el que `map' hace un `apply'.


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

     Cuando `prederror' toma el valor `true', se emite un mensaje de
     error siempre que el predicado de una sentencia  `if' o de una
     función `is' no se pueda evaluar ni a verdadero (`true') ni  a
     falso (`false').

     Si toma el valor `false', se devuelve bajo las mismas
     circunstancias anteriores el valor `unknown'. El modo `prederror:
     false' no está soportado en el código traducido; sin embargo,
     `maybe' está soportado en código traducido.

     Véanse también `is' y `maybe'.


 -- Función: return (valor)
     Puede utilizarse para salir de un bloque, devolviendo su.  Véase
     `block' para más información.


 -- Función: scanmap (<f>, <expr>)
 -- Función: scanmap (<f>, <expr>, bottomup)
     Aplica recursivamente <f> sobre <expr>, de arriba hacia abajo.
     Esto es más útil cuando se busca una factorización completa, por
     ejemplo:

          (%i1) exp:(a^2+2*a+1)*y + x^2$
          (%i2) scanmap(factor,exp);
                                              2      2
          (%o2)                         (a + 1)  y + x

     Nótese que cómo `scanmap' aplica la función dada `factor' a las
     subexpresiones que forman a <expr>; si se presenta otra forma de
     <expr> a `scanmap' entonces el resultado puede ser diferente. Así,
     `%o2' no se restaura cuando `scanmap' se aplica a la forma
     expandida de exp:

          (%i3) scanmap(factor,expand(exp));
                                     2                  2
          (%o3)                      a  y + 2 a y + y + x

     Aquí hay otro ejemplo de la forma en que `scanmap' aplica
     recursivamente una función dada a todas las subexpresiones,
     incluyendo exponentes:

          (%i4) expr : u*v^(a*x+b) + c$
          (%i5) scanmap('f, expr);
                              f(f(f(a) f(x)) + f(b))
          (%o5) f(f(f(u) f(f(v)                      )) + f(c))

     `scanmap (<f>, <expr>, bottomup)' aplica <f> a <expr> de abajo
     hacia arriba. Por ejemplo, para `f' no definida,

          scanmap(f,a*x+b) ->
             f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
          scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
              -> f(f(a)*f(x))+f(b) ->
               f(f(f(a)*f(x))+f(b))

     En este caso se obtiene la misma respuesta por cualquiera de los
     dos métodos.


 -- Función: throw (<expr>)
     Evalúa <expr> y devuelve el valor del `catch' más reciente. La
     función `throw' se utiliza junto con `catch' como un mecanismo de
     retorno no local.


 -- Operador especial: while
     Véase `do'.


 -- Función: outermap (<f>, <a_1>, ..., <a_n>)
     Aplica la función <f> a cada uno de los elementos del producto
     vectorial <a_1> por <a_2> ... por <a_n>.

     El argumento <f> debe ser el nombre de una función de n argumentos,
     o una expresión lambda de n argumentos.  Cada uno de los
     argumentos <a_k> puede ser una lista, una lista anidada, una
     matriz o cualquier otro tipo de expresión.

     El valor devuelto por `outermap' es una estructura anidada. Si <x>
     es la respuesta dada por `outermap', entonces tiene la misma
     estructura que la primera lista, lista anidada o matriz,
     `<x>[i_1]...[i_m]' tiene la misma estructura que la segunda lista,
     lista anidada o matriz, `<x>[i_1]...[i_m][j_1]...[j_n]' tiene la
     misma estructura que la tercera lista, lista anidada o matriz, y
     así sucesivamente, siendo <m>, <n>, ... los números índice
     necesarios para acceder a los elementos de cada argumento: uno
     para las listas, dos para las matrices y uno o más para las listas
     anidadas.  Aquellos argumentos que no sean listas ni matrices no
     tienen efecto alguno sobre la estructura del valor retornado.

     Nótese que el efecto producido por `outermap' es diferente del que
     se obtiene al aplicar <f> a cada uno de los elementos del producto
     devuelto por `cartesian_product'. La función `outermap' mantiene
     la estructura de los argumentos en la respuesta, miemtras que
     `cartesian_product' no lo hace.

     La función `outermap' evalúa sus argumentos.

     Véanse también `map', `maplist' y `apply'.

     Ejemplos:

     Ejemplos elementales de uso de `outermap'.  Con el fin de mostrar
     con mayor claridad las combinaciones del argumento, se mantiene
     sin definir `F'.

          (%i1) outermap (F, [a, b, c], [1, 2, 3]);
          (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                               [F(c, 1), F(c, 2), F(c, 3)]]
          (%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
                   [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
                   [ [                  ]  [                  ] ]
                   [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
          (%o2)    [                                            ]
                   [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
                   [ [                  ]  [                  ] ]
                   [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
          (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
                 [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
          (%o3) [[                        ], [                        ]]
                 [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
          (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
                 [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
          (%o4) [[ [            ]  [            ] ],
                 [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                                        [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                                        [ [            ]  [            ] ]]
                                        [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
          (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
          (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
                                                     [c + 1, c + 2, c + 3]]

     El siguiente ejemplo permite hacer un análisis más profundo del
     valor retornado por `outermap'.  Los tres primeros argumentos son
     una matriz, una lista y otra matriz, en este orden. El valor
     devuelto es una matriz, cuyos elementos son listas y cada elemento
     de cada una de estas listas es a su vez una matriz.

          (%i1) arg_1 :  matrix ([a, b], [c, d]);
                                      [ a  b ]
          (%o1)                       [      ]
                                      [ c  d ]
          (%i2) arg_2 : [11, 22];
          (%o2)                       [11, 22]
          (%i3) arg_3 : matrix ([xx, yy]);
          (%o3)                      [ xx  yy ]
          (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
                                                             arg_2, arg_3);
                         [  [      a        a  ]  [      a        a  ]  ]
                         [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                         [  [      11       11 ]  [      22       22 ]  ]
          (%o4)  Col 1 = [                                              ]
                         [  [      c        c  ]  [      c        c  ]  ]
                         [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                         [  [      11       11 ]  [      22       22 ]  ]
                           [  [      b        b  ]  [      b        b  ]  ]
                           [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                           [  [      11       11 ]  [      22       22 ]  ]
                   Col 2 = [                                              ]
                           [  [      d        d  ]  [      d        d  ]  ]
                           [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                           [  [      11       11 ]  [      22       22 ]  ]
          (%i5) xx_1 : xx_0 [1][1];
                     [      a        a  ]  [      a        a  ]
          (%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
                     [      11       11 ]  [      22       22 ]
          (%i6) xx_2 : xx_0 [1][1] [1];
                                [      a        a  ]
          (%o6)                 [ xx + --  yy + -- ]
                                [      11       11 ]
          (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                            a
          (%o7)                        xx + --
                                            11
          (%i8) [op (arg_1), op (arg_2), op (arg_3)];
          (%o8)                  [matrix, [, matrix]
          (%i9) [op (xx_0), op (xx_1), op (xx_2)];
          (%o9)                  [matrix, [, matrix]

     La función `outermap' mantiene la estructura de los argumentos en
     su respuesta, mientras que `cartesian_product' no lo hace.

          (%i1) outermap (F, [a, b, c], [1, 2, 3]);
          (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                               [F(c, 1), F(c, 2), F(c, 3)]]
          (%i2) setify (flatten (%));
          (%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                                 F(c, 1), F(c, 2), F(c, 3)}
          (%i3) map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3}));
          (%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                                 F(c, 1), F(c, 2), F(c, 3)}
          (%i4) is (equal (%, %th (2)));
          (%o4)                         true



File: maxima.info,  Node: Depurado,  Next: augmented_lagrangian,  Prev: Programación,  Up: Top

41 Depurado
***********

* Menu:

* Depuración del código fuente::
* Claves de depuración::
* Funciones y variables para depurado::


File: maxima.info,  Node: Depuración del código fuente,  Next: Claves de depuración,  Up: Depurado

41.1 Depuración del código fuente
=================================

Maxima es capaz de dar asistencia en la depuración del código fuente.
Un usuario puede establecer un punto de referencia dentro del código de
una función a partir del cual se siga la ejecución línea a línea. La
compliación puede ser posteriormente examinada, conjuntamente con los
valores que se han ido asignando a las variables.

   La instrucción `:help', o `:h', muestra la lista de comandos para la
depuración. (En general, los comandos pueden abreviarse; en algunos
casos la lista de alternativas podrá ser listada.) Dentro del
depurador, el usuario podrá examinar también cualquier función propia
de Maxima, definirla y manipular variables y expresiones.

   El punto de referencia se establecerá con la instrucción `:br'. Ya
dentro del depurador, el usuario podrá avanzar una línea de cada vez
utilizando la instrucción `:n' (de "next", en inglés). La orden `:bt'
(de "backtrace") muestra la lista de la pila. Finalmente, con el
comando `:r' ("resume") se abandona el depurador continuando con la
ejecución. El uso de estas instrucciones se muestra en el siguiente
ejemplo.

     (%i1) load ("/tmp/foobar.mac");

     (%o1)                           /tmp/foobar.mac

     (%i2) :br foo
     Turning on debugging debugmode(true)
     Bkpt 0 for foo (in /tmp/foobar.mac line 1)

     (%i2) bar (2,3);
     Bkpt 0:(foobar.mac 1)
     /tmp/foobar.mac:1::

     (dbm:1) :bt                  <-- pulsando :bt se retrocede
     #0: foo(y=5)(foobar.mac line 1)
     #1: bar(x=2,y=3)(foobar.mac line 9)

     (dbm:1) :n                   <-- pulsando :n se avanza una línea
     (foobar.mac 2)
     /tmp/foobar.mac:2::

     (dbm:1) :n                   <-- pulsando :n se avanza otra línea
     (foobar.mac 3)
     /tmp/foobar.mac:3::

     (dbm:1) u;                   <-- se pide el valor de u
     28

     (dbm:1) u: 33;               <-- se cambia el valor de u a 33
     33

     (dbm:1) :r                   <-- pulsando :r se termina la depuración

     (%o2)                                1094

   El fichero `/tmp/foobar.mac' contiene lo siguiente:

     foo(y) := block ([u:y^2],
       u: u+3,
       u: u^2,
       u);

     bar(x,y) := (
       x: x+2,
       y: y+2,
       x: foo(y),
       x+y);

   USO DEL DEPURADOR EN EMACS

   Si el usuario está corriendo el código bajo GNU emacs en un entorno
de texto (dbl shell), o está ejecutando el  entorno gráfico `xmaxima',
entonces cuando una función pare en el punto de referencia, podrá
observar su posición actual en el archivo fuente, el cual será mostrado
en la otra mitad de la ventana, bien resaltada en rojo, o con una
pequeña flecha apuntando a la línea correcta. El usuario puede avanzar
líneas simples tecleando M-n (Alt-n).

   Bajo Emacs se debe ejecutar el programa en una ventana de texto
`dbl', la cual requiere el archivo `dbl.el' que está en el directorio
elisp. El usuario debe instalar los archivos elisp o agregar el
directorio elisp de Maxima a la ruta de búsqueda: por ejemplo, se puede
añadir lo siguiente al archivo `.emacs' o al `site-init.el'

     (setq load-path (cons "/usr/share/maxima/5.9.1/emacs" load-path))
     (autoload 'dbl "dbl")

   entonces en emacs

     M-x dbl

   debería abrir una ventana del sistema en la cual se pueden ejecutar
programas, por ejemplo Maxima, gcl, gdb, etc.  En esta ventana también
se puede ejecutar el depurador, mostrando el código fuente en la otra
ventana.

   El usuario puede colocar un punto de referencia en una línea
determinada sin más que teclear `C-x space'. Con esto se le hace saber
al depurador en qué función está el cursor y en qué línea del mismo. Si
el cursor está en la línea 2 de `foo', entonces insertará en la otra
ventana la instrucción "`:br foo 2'", a fin de detener `foo' justo en
la segunda línea. Para tener esto operativo, el usuario debe tener
activo maxima-mode.el (modo-maxima.el) en la ventana en la que está
`foobar.mac'. Hay otros comandos disponibles en la ventana, como
evaluar la función dentro de Maxima tecleando `Alt-Control-x'.


File: maxima.info,  Node: Claves de depuración,  Next: Funciones y variables para depurado,  Prev: Depuración del código fuente,  Up: Depurado

41.2 Claves de depuración
=========================

Las claves de depuración son palabras que no son interpretadas como
expresiones de Maxima. Una clave de depuración puede introducirse
dentro de Maxima o del depurador. Las claves de depuración comienzan
con dos puntos, ':'. Por ejemplo, para evaluar una expresión Lisp, se
puede teclear `:lisp' seguido de la expresión a ser evaluada.

     (%i1) :lisp (+ 2 3)
     5

   El número de argumentos depende del comando en particular. Además,
tampoco es necesario teclear el nombre completo de la instrucción, tan
solo lo justo para diferenciarla de las otras instrucciones. Así, `:br'
sería suficiente para `:break'.

   Las claves de depuración se listan a continuación.

`:break F n'
     Establece un punto de referencia en la función `F' en la línea `n'
     contando a partir del comienzo de la función. Si `F' es una
     cadena, entonces se entiende que se trata de un fichero, siendo
     entonces `n' el número de línea a partir del comienzo del fichero.
     El valor `n' es opcional; en caso de no ser suministrado, se
     entenderá que vale cero (primera línea de la función o fichero).

`:bt'
     Retrocede en la pila.

`:continue'
     Continua el cómputo de la función.

`:delete'
     Borra los punto de referencia especificados, o todos si no se
     especifica ninguno.

`:disable'
     Deshabilita los puntos de referencia especificados, o todos si no
     se especifica ninguno.

`:enable'
     Habilita los puntos de referencia especificados, o todos si no se
     especifica ninguno.

`:frame n'
     Imprime el elemento `n' de la pila, o el actualmente activo si no
     se especifica ninguno.

`:help'
     Imprime la ayuda sobre un comando del depurador, o de todos los
     comandos si no se especifica ninguno.

`:info'
     Imprime información sobre un elemento.

`:lisp expresión'
     Evalúa la `expresión' Lisp.

`:lisp-quiet expresión'
     Evalúa la `expresión' Lisp sin devolver el resultado.

`:next'
     Como `:step', excepto que `:next' se salta las llamadas a
     funciones.

`:quit'
     Sale del nivel actual del depurador sin completar el cómputo.

`:resume'
     Continúa con el cómputo.

`:step'
     Sigue con el cómputo de la función o fichero hasta que alcance una
     nueva línea fuente.

`:top'
     Retorna a Maxima desde cualquier nivel del depurador sin completar
     el cómputo.


File: maxima.info,  Node: Funciones y variables para depurado,  Prev: Claves de depuración,  Up: Depurado

41.3 Funciones y variables para depurado
========================================

 -- Variable opcional: refcheck
     Valor por defecto: `false'

     Cuando `refcheck' vale `true', Maxima imprime un mensaje cada vez
     que una variable es utilizada por vez primera en un cálculo.


 -- Variable opcional: setcheck
     Valor por defecto: `false'

     Cuando el valor de `setcheck' es una lista de variables (se admite
     que tengan subíndices) Maxima devuelve un mensaje indicando si los
     valores que han sido asignados a las variables lo han sido con el
     operador ordinario `:', o con el operador de asignación `::' o
     como resultado de haberse realizado una llamada de función, pero
     en ningún caso cuando la asignación haya sido hecha mediante los
     operadores `:=' o `::='. El mensaje contiene el nombre de la
     variable y su valor.

     La variable `setcheck' admite también los valores `all' o `true'
     con lo que el informe incluirá todas las variables.

     Cada nueva asignación de `setcheck' establece una nueva lista de
     variables a ser monitorizada, de forma que cualquier otra variable
     previamente asignada a `setcheck' es olvidada.

     Los nombres asignados a `setcheck' deben estar precedidos del
     apóstrofo `'' a fin de evitar que las variables sean evaluadas
     antes de ser almacenadas en `setcheck'. Por ejemplo, si `x', `y' y
     `z' ya guardan algún valor entoces se hará

          setcheck: ['x, 'y, 'z]$

     para colocarlas en la lista de variables a monitorizar.

     No se generará ninguna salida cuando una variable de la lista
     `setcheck' sea asignada a ella misma, como en `X: 'X'.


 -- Variable opcional: setcheckbreak
     Valor por defecto: `false'

     Si `setcheckbreak' es igual `true', Maxima se detendrá siempre que
     a una variable de la lista `setcheck' se le asigne un nuevo valor.
     La detención tendrá lugar justo antes de hacerse la asignación. En
     ese momento `setval' guarda el valor que se le va a dar a la
     variable. Entonces el usuario podrá darle un valor diferente
     pasándoselo a la variable `setval'.

     Véanse también `setcheck' y `setval'.


 -- Variable del sistema: setval
     Guarda el valor que va a ser asignado a una variable cuando
     `setcheckbreak' realiza una detención. Entonces se podrá asignarle
     otro valor pasándoselo previamente a `setval'.

     Véanse también `setcheck' y `setcheckbreak'.


 -- Función: timer (<f_1>, ..., <f_n>)
 -- Función: timer (all)
 -- Función: timer ()
     Dadas las funciones <f_1>, ..., <f_n>, `timer' coloca cada una de
     ellas en la lista de funciones para las cuales se generarán
     estadísticas relativas al tiempo de cómputo. Así, `timer(f)$
     timer(g)$' coloca a `f' y luego a `g' en dicha lista de forma
     acumulativa.

     La sentencia `timer(all)' coloca todas las funciones de usuario
     (las referenciadas por la variable global `functions') en la lista
     de funciones cuyos tiempos de ejecución se quieren monitorizar.

     Si no se le pasan argumentos a `timer' se obtendrá la lista de
     funciones cuyos tiempos de ejecución se quieren monitorizar.

     Maxima almacena la duración del cómputo de cada función de la
     lista, de forma que `timer_info' devolverá las estadísticas
     correspondientes, incluyendo el tiempo medio de cada llamada a la
     función, el número de llamadas realizadas y el tiempo total
     transcurrido. La instrucción `untimer' borra las funciones de la
     lista.

     La función `timer' no evalúa sus argumentos, de forma que `f(x) :=
     x^2$ g:f$ timer(g)$' no coloca a `f' en la lista.

     Si `trace(f)' está activada, entonces `timer(f)' está desactivada;
     `trace' y `timer' no pueden estar operativas al mismo tiempo.

     Véase también `timer_devalue'.


 -- Función: untimer (<f_1>, ..., <f_n>)
 -- Función: untimer ()
     Dadas las funciones <f_1>, ..., <f_n>, `untimer' las elimina de la
     lista de funciones cuyos tiempos de ejecución se quiere
     monitorizar.

     Si no se le suministran argumentos, `untimer' borra completamente
     la lista.

     Tras la ejecución de `untimer (f)', `timer_info (f)' aún devuelve
     las estadísticas de tiempo previamente registradas, pero
     `timer_info()' (sin argumentos) no devuelve información sobre
     aquellas funciones que ya no están en la lista. La ejecución de
     `timer (f)' inicializa todas las estadísticas a cero y coloca `f'
     nuevamente en la lista.


 -- Variable opcional: timer_devalue
     Valor por defecto: `false'

     Si `timer_devalue' es igual a `true', Maxima le resta a cada
     función cuyos tiempos de ejecución se quiere monitorizar el tiempo
     gastado en llamadas a otras funciones presentes también en la
     lista de monitorización. En caso contrario, los tiempos que se
     obtienen para cada función incluyen también los consumidos en
     otras funciones. Nótese que el tiempo consumido en llamadas a
     otras funciones que no están en la lista de monitorización no se
     resta del tiempo total.

     Véanse también `timer' y `timer_info'.


 -- Función: timer_info (<f_1>, ..., <f_n>)
 -- Función: timer_info ()
     Dadas las funciones <f_1>, ..., <f_n>, `timer_info' devuelve una
     matriz con información relativa a los tiempos de ejecución de cada
     una de estas funciones. Sin argumentos, `timer_info' devuelve la
     información asociada a todas las funciones cuyos tiempos de
     ejecución se quiere monitorizar.

     La matriz devuelta por `timer_info' incluye los nombres de las
     funciones, tiempo de ejecución en cada llamada, número de veces
     que ha sido llamada, tiempo total de ejecución y tiempo consumido
     en la recolección de basura, `gctime' (del inglés, "garbage
     collection time") en la versión original de Macsyma, aunque ahora
     toma el valor constante cero.

     Los datos con los que `timer_info' construye su respuesta pueden
     obtenerse también con la función `get':

          get(f, 'calls);  get(f, 'runtime);  get(f, 'gctime);

     Véase también `timer'.


 -- Función: trace (<f_1>, ..., <f_n>)
 -- Función: trace (all)
 -- Función: trace ()
     Dadas las funciones <f_1>, ..., <f_n>, `trace' imprime información
     sobre depuración cada vez que estas funciones son llamadas;
     `trace(f)$ trace(g)$' coloca de forma acumulativa a `f' y luego a
     `g' en la lista de funciones a ser rastradas.

     La sentencia `trace(all)' coloca todas las funciones de usuario
     (las referenciadas por la variable global `functions') en la lista
     de funciones a ser rastreadas.

     Si no se suministran argumentos, `trace' devuelve una lista con
     todas las funciones a ser rastreadas.

     La función `untrace' desactiva el rastreo. Véase también
     `trace_options'.

     La función `trace' no evalúa sus argumentos, de forma que `f(x) :=
     x^2$ g:f$ trace(g)$' no coloca a `f' en la lista de rastreo.

     Cuando una función se redefine es eliminada de la lista de
     rastreo. Así, tras  `timer(f)$ f(x) := x^2$', la función `f'
     dejará de estar en dicha lista.

     Si `timer (f)' está activado, entonces `trace (f)' está
     desactivado, ya que `trace' y `timer' no pueden estar ambos
     activos para la misma función.


 -- Función: trace_options (<f>, <option_1>, ..., <option_n>)
 -- Función: trace_options (<f>)
     Establece las opciones de rastreo para la función <f>. Cualquier
     otra opción previamente especificada queda reemplazada por las
     nuevas. La ejecución de `trace_options (<f>, ...)' no tiene ningún
     efecto, a menos que se haya invocado previamente a `trace (<f>)'
     (es indiferente que esta invocación sea anterior o posterior a
     `trace_options').

     `trace_options (<f>)' inicializa todas las opciones a sus valores
     por defecto.

     Las claves de opciones son:

        * `noprint': No se imprime mensaje alguno ni a la entrada ni a
          la salida de la función.

        * `break': Coloca un punto de referencia antes de que la
          función comience a ejecutarse y otro después de que termine
          su ejecución. Véase `break'.

        * `lisp_print': Muestra los argumentos y valores retornados
          como objetos de Lisp.

        * `info': Imprime `-> true' tanto a la entrada como a la salida
          de la función.

        * `errorcatch': Detecta errores, otorgando la posibilidad de
          marcar un error, reintentar la llamada a la función o
          especificar un valor de retorno.

     Las opciones de rastreo se especifican de dos formas. La única
     presencia de la clave de opción ya activa la opción. (Nótese que
     la opción <foo> no se activa mediante `<foo>: true' u otra forma
     similar; se tendrá en cuenta también que las claves no necesitan
     ir precedidas del apóstrofo.) Especificando la clave de opción
     junto con una función de predicado se hace que la opción quede
     condicionada al predicado.

     La lista de argumentos para las funciones de predicado es siempre
     `[level, direction, function, item]' donde `level' es el nivel de
     recursión para la función,  `direction' puede ser tanto `enter'
     como `exit', `function' es el nombre de la función  y `item' es la
     lista de argumentos (a la entrada) o el valor de retorno (a la
     salida).

     A continuación un ejemplo de opciones de rastreo no condicionales:

          (%i1) ff(n) := if equal(n, 0) then 1 else n * ff(n - 1)$

          (%i2) trace (ff)$

          (%i3) trace_options (ff, lisp_print, break)$

          (%i4) ff(3);

     Para la misma función, con la opción `break' condicionada a un
     predicado:

          (%i5) trace_options (ff, break(pp))$

          (%i6) pp (level, direction, function, item) := block (print (item),
              return (function = 'ff and level = 3 and direction = exit))$

          (%i7) ff(6);


 -- Función: untrace (<f_1>, ..., <f_n>)
 -- Función: untrace ()
     Dadas las funciones <f_1>, ..., <f_n>, `untrace' desactiva el
     rastreo previamente activado por la función `trace'. Si no se
     aportan argumentos, `untrace' desactiva el rastreo de todas las
     funciones.

     La llamada a `untrace' devuelve una lista con las funciones para
     las que el rastreo se ha desactivado.



File: maxima.info,  Node: augmented_lagrangian,  Next: bode,  Prev: Depurado,  Up: Top

42 augmented_lagrangian
***********************

* Menu:

* Funciones y variables para augmented_lagrangian::


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

42.1 Funciones y variables para augmented_lagrangian
====================================================

 -- Función: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>)
 -- Función: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>,
          optional_args)
     Devuelve una aproximación del valor mínimo de la expresión <FOM>
     respecto de las variables <xx>, manteniendo las restricciones <C>
     igual a cero. La lista <yy> contiene las soluciones iniciales para
     <xx>.  El algoritmo que se utiliza es el método del lagrangiano
     aumentado (ver referencias [1] y [2]).

     El argumento `optional_args' hace referencia a otros argumentos
     adicionales, los cuales se especifican de la forma `<symbol> =
     <value>'.  Los argumentos opcionales reconocidos son:

    `niter'
          Número de iteraciones del algoritmo.

    `lbfgs_tolerance'
          Tolerancia que se pasa a LBFGS.

    `iprint'
          Parámetro IPRINT (lista de dos enteros que controlan la
          frecuencia de mensajes) que se pasa a LBFGS.

    `%lambda'
          Valor inicial de `%lambda' que será utilizado para calcular el
          lagrangiano aumentado.

     Esta función minimiza el lagrangiano aumentado haciendo uso del
     algoritmo LBFGS, que es un método de los llamados quasi-Newton.

     Antes de hacer uso de esta función ejecútense
     `load("augmented_lagrangian")'.

     Véase también `lbfgs'.

     Referencias:

     [1]
     `http://www-fp.mcs.anl.gov/otc/Guide/OptWeb/continuous/constrained/nonlinearcon/auglag.html'

     [2] `http://www.cs.ubc.ca/spider/ascher/542/chap10.pdf'

     Ejemplo:

          (%i1) load (lbfgs);
          (%o1)     /maxima/share/lbfgs/lbfgs.mac
          (%i2) load (augmented_lagrangian);
          (%o2)
             /maxima/share/contrib/augmented_lagrangian.mac
          (%i3) FOM: x^2 + 2*y^2;
                                         2    2
          (%o3)                       2 y  + x
          (%i4) xx: [x, y];
          (%o4)                        [x, y]
          (%i5) C: [x + y - 1];
          (%o5)                      [y + x - 1]
          (%i6) yy: [1, 1];
          (%o6)                        [1, 1]
          (%i7) augmented_lagrangian_method(FOM, xx, C, yy, iprint=[-1,0]);
          (%o7) [[x = 0.66665984108002, y = 0.33334027245545],
                                           %lambda = [- 1.333337940892525]]



File: maxima.info,  Node: bode,  Next: contrib_ode,  Prev: augmented_lagrangian,  Up: Top

43 bode
*******

* Menu:

* Funciones y variables para bode::


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

43.1 Funciones y variables para bode
====================================

 -- Función: bode_gain (<H>, <range>, ...<plot_opts>...)
     Función para dibujar el gráfico de ganancia de Bode.

     Ejemplos (1 a 7 de
          `http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html',
     8 de Ron Crummett):
          (%i1) load("bode")$

          (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

          (%i3) bode_gain (H1 (s), [w, 1/1000, 1000])$

          (%i4) H2 (s) := 1 / (1 + s/omega0)$

          (%i5) bode_gain (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

          (%i7) bode_gain (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i8) H4 (s) := 1 + s/omega0$

          (%i9) bode_gain (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i10) H5 (s) := 1/s$

          (%i11) bode_gain (H5 (s), [w, 1/1000, 1000])$

          (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

          (%i13) bode_gain (H6 (s), [w, 1/1000, 1000]),
                            omega0 = 10, zeta = 1/10$

          (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

          (%i15) bode_gain (H7 (s), [w, 1/1000, 1000]),
                            omega0 = 10, zeta = 1/10$

          (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

          (%i17) bode_gain (H8 (s), [w, 1/1000, 1000])$

     Antes de hacer uso de esta función ejecútese  `load("bode")'.
     Véase también `bode_phase'.

 -- Función: bode_phase (<H>, <range>, ...<plot_opts>...)
     Función para dibujar el gráfico de fase de Bode.

     Ejemplos (1 a 7 de
          `http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html',
     8 de Ron Crummett):
          (%i1) load("bode")$

          (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

          (%i3) bode_phase (H1 (s), [w, 1/1000, 1000])$

          (%i4) H2 (s) := 1 / (1 + s/omega0)$

          (%i5) bode_phase (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

          (%i7) bode_phase (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i8) H4 (s) := 1 + s/omega0$

          (%i9) bode_phase (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i10) H5 (s) := 1/s$

          (%i11) bode_phase (H5 (s), [w, 1/1000, 1000])$

          (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

          (%i13) bode_phase (H6 (s), [w, 1/1000, 1000]),
                             omega0 = 10, zeta = 1/10$

          (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

          (%i15) bode_phase (H7 (s), [w, 1/1000, 1000]),
                             omega0 = 10, zeta = 1/10$

          (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

          (%i17) bode_phase (H8 (s), [w, 1/1000, 1000])$

          (%i18) block ([bode_phase_unwrap : false],
                        bode_phase (H8 (s), [w, 1/1000, 1000]));

          (%i19) block ([bode_phase_unwrap : true],
                        bode_phase (H8 (s), [w, 1/1000, 1000]));

     Antes de hacer uso de esta función ejecútese  `load("bode")'.
     Véase también `bode_gain'.


File: maxima.info,  Node: contrib_ode,  Next: descriptive,  Prev: bode,  Up: Top

44 contrib_ode
**************

* Menu:

* Introducción a contrib_ode::
* Funciones y variables para contrib_ode::
* Posibles mejoras a contrib_ode::
* Pruebas realizadas con contrib_ode::
* Referencias para contrib_ode::


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

44.1 Introducción a contrib_ode
===============================

La función `ode2' de Maxima resuelve ecuaciones diferenciales
ordinarias (EDO) simples de primer y segundo orden. La función
`contrib_ode' extiende las posibilidades de `ode2' con métodos
adicionales para ODEs lineales y no lineales de primer orden y
homogéneas lineales de segundo orden.  El código se encuentra en estado
de desarrollo y la syntaxis puede cambiar en futuras versiones. Una vez
el código se haya estabilizado podrá pasar a integrarse dentro de
Maxima.

   El paquete debe cargarse con la instrucción `load('contrib_ode)'
antes de utilizarlo.

   La sintaxis de `contrib_ode' es similar a la de `ode2'.  Necesita
tres argumentos: una EDO (sólo se necesita el miembro izquierdo si el
derecho es igual cero), la variable dependiente y la independiente. Si
encuentra la solución, devolverá una lista de resultados.

   La forma de los resultados devueltos es diferente de la utilizada
por `ode2'.  Puesto que las ecuaciones no lineales pueden tener
múltiples soluciones, `contrib_ode' devuelve una lista de soluciones.
Las soluciones pueden tener diferentes formatos:
   * una función explícita para la variable dependiente,

   * una función implícita para la variable dependiente,

   * una solución paramétrica en términos de la variable `%t' o

   * una transformación en otra EDO de variable `%u'.


   `%c' hace referencia a la constante de integración en las ecuaciones
de primer orden.  `%k1' y `%k2' son las constantes para las ecuaciones
de segundo orden.  Si por cualquier razón contrib_ode no pudiese
encontrar una solución, devolverá `false', quizás después de mostrar un
mensaje de error.

   Ejemplos:

   En ocasiones es necesario devolver una lista de soluciones, pues
algunas EDOs pueden tener múltiples soluciones:

     (%i1) load('contrib_ode)$

     (%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;

                         dy 2             dy
     (%o2)            x (--)  - (x y + 1) -- + y = 0
                         dx               dx
     (%i3) contrib_ode(eqn,y,x);

                                                  x
     (%o3)             [y = log(x) + %c, y = %c %e ]
     (%i4) method;

     (%o4)                        factor

   Las EDOs no lineales pueden tener soluciones singulares sin
constantes de integración, como en la segunda solución del ejemplo
siguiente:

     (%i1) load('contrib_ode)$

     (%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;

                            dy 2     dy
     (%o2)                 (--)  + x -- - y = 0
                            dx       dx
     (%i3) contrib_ode(eqn,y,x);

                                                2
                                      2        x
     (%o3)              [y = %c x + %c , y = - --]
                                               4
     (%i4) method;

     (%o4)                       clairault

   La siguiente ODE tiene dos soluciones paramétricas en términos de la
variable `%t'. En este caso, las soluciones paramétricas se pueden
manipular para dar soluciones explícitas.

     (%i1) load('contrib_ode)$

     (%i2) eqn:'diff(y,x)=(x+y)^2;

                               dy          2
     (%o2)                     -- = (y + x)
                               dx
     (%i3) contrib_ode(eqn,y,x);

     (%o3) [[x = %c - atan(sqrt(%t)), y = - x - sqrt(%t)],
                          [x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]]
     (%i4) method;

     (%o4)                       lagrange

   En el siguiente ejemplo (Kamke 1.112) se obtiene una solución
implícita.

     (%i1) load('contrib_ode)$

     (%i2) assume(x>0,y>0);

     (%o2)                    [x > 0, y > 0]
     (%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;

                          dy           2    2
     (%o3)              x -- - x sqrt(y  + x ) - y
                          dx
     (%i4) contrib_ode(eqn,y,x);

                                       y
     (%o4)                  [x - asinh(-) = %c]
                                       x
     (%i5) method;

     (%o5)                          lie

   La siguiente ecuación de Riccati se transforma en una EDO lineal de
segundo orden de variable `%u'. Maxima es incapaz de resolver la nueva
EDO, por lo que la devuelve si resolver:

     (%i1) load('contrib_ode)$

     (%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;

                         2 dy      2  2      n
     (%o2)              x  -- = c x  y  + b x  + a
                           dx
     (%i3) contrib_ode(eqn,y,x);

                    d%u
                    ---                            2
                    dx        2     n - 2   a     d %u
     (%o3)  [[y = - ----, %u c  (b x      + --) + ---- c = 0]]
                    %u c                     2      2
                                            x     dx
     (%i4) method;

     (%o4)                        riccati

   Para EDOs de primer orden, `contrib_ode' llama a `ode2'.  Entonces
trata de aplicar los siguientes métodos: factorización, Clairault,
Lagrange, Riccati, Abel y Lie. El método de Lie no se intenta aplicar a
las ecuaciones de Abel si el propio método de Abel no obtiene solución,
pero sí se utiliza si el método de Riccati devuelve una EDO de segundo
orden sin resolver.

   Para EDOs de segundo orden, `contrib_ode' llama a `ode2' y luego a
`odelin'.

   Se mostrarán mensajes de depurado si se ejecuta la sentencia
`put('contrib_ode,true,'verbose)'.


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

44.2 Funciones y variables para contrib_ode
===========================================

 -- Función: contrib_ode (<eqn>, <y>, <x>)
     Devuelve la lista de soluciones de la ecuación diferencia
     ordinaria (EDO) <eqn> de variable independiente <x> y variable
     dependiente <y>.


 -- Función: odelin (<eqn>, <y>, <x>)
     La función `odelin' resulve EDOs homogéneas lineales de primer y
     segundo orden con variable independiente <x> y variable
     dependiente <y>. Devuelve un conjunto fundamental de soluciones de
     la EDO.

     Para EDOs de segundo orden, `odelin' utiliza un método
     desarrollado por Bronstein y Lafaille, que busca las soluciones en
     términos de funciones especiales dadas.

          (%i1) load('contrib_ode);

          (%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
          ...trying factor method
          ...solving 7 equations in 4 variables
          ...trying the Bessel solver
          ...solving 1 equations in 2 variables
          ...trying the F01 solver
          ...solving 1 equations in 3 variables
          ...trying the spherodial wave solver
          ...solving 1 equations in 4 variables
          ...trying the square root Bessel solver
          ...solving 1 equations in 2 variables
          ...trying the 2F1 solver
          ...solving 9 equations in 5 variables
                 gauss_a(- 6, - 2, - 3, - x)  gauss_b(- 6, - 2, - 3, - x)
          (%o2) {---------------------------, ---------------------------}
                              4                            4
                             x                            x


 -- Función: ode_check (<eqn>, <soln>)
     Devuelve el valor de la ecuación diferencia ordinaria (EDO) <eqn>
     después de sustituir una posible solución <soln>. El valor es cero
     si <soln> es una solución de <eqn>.

          (%i1) load('contrib_ode)$

          (%i2) eqn:'diff(y,x,2)+(a*x+b)*y;

                                   2
                                  d y
          (%o2)                   --- + (a x + b) y
                                    2
                                  dx
          (%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
                   +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];

                                            3/2
                              1  2 (a x + b)
          (%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b)
                              3       3 a
                                                    3/2
                                      1  2 (a x + b)
                           + bessel_j(-, --------------) %k1 sqrt(a x + b)]
                                      3       3 a
          (%i4) ode_check(eqn,ans[1]);

          (%o4)                           0


 -- Variable opcional: `method'
     A la variable `method' se le asigna el método aplicado.


 -- Variable: `%c'
     `%c' es la constante de integración para EDOs de primer orden.


 -- Variable: `%k1'
     `%k1' es la primera constante de integración para EDOs de segundo
     orden.


 -- Variable: `%k2'
     `%k2' es la segunda constante de integración para EDOs de segundo
     orden.


 -- Función: gauss_a (<a>, <b>, <c>, <x>)
     `gauss_a(a,b,c,x)' y `gauss_b(a,b,c,x)' son funciones geométricas
     2F1 . Representan dos soluciones independientes cualesquiera de la
     ecuación diferencial hipergeométrica `x(1-x) diff(y,x,2) +
     [c-(a+b+1)x diff(y,x) - aby = 0' (A&S 15.5.1).

     El único uso que se hace de estas funciones es en las soluciones de
     EDOs que devuelven `odelin' y `contrib_ode'. La definición y
     utilización de estas funciones puede cambiar en futuras
     distribuciones de Maxima.

     Véanse también `gauss_b', `dgauss_a' y `gauss_b'.


 -- Función: gauss_b (<a>, <b>, <c>, <x>)
     Véase  también `gauss_a'.

 -- Función: dgauss_a (<a>, <b>, <c>, <x>)
     The derivative with respect to x of `gauss_a(a,b,c,x)'.

 -- Función: dgauss_b (<a>, <b>, <c>, <x>)
     Derivada de `gauss_b(<a>,<b>,<c>,<x>)' respecto de <x>.

 -- Función: kummer_m (<a>, <b>, <x>)
     Función M de Kummer, tal como la definen Abramowitz y Stegun,
     Handbook of Mathematical Functions, Sección 13.1.2.

     El único uso que se hace de esta función es en las soluciones de
     EDOs que devuelven `odelin' y `contrib_ode'. La definición y
     utilización de estas funciones puede cambiar en futuras
     distribuciones de Maxima.

     Véanse también `kummer_u', `dkummer_m' y `dkummer_u'.

 -- Función: kummer_u (<a>, <b>, <x>)
     Función U de Kummer, tal como la definen Abramowitz y Stegun,
     Handbook of Mathematical Functions, Sección 13.1.3.

     Véase  también `kummer_m'.

 -- Función: dkummer_m (<a>, <b>, <x>)
     Derivada de `kummer_m(<a>,<b>,<x>)' respecto de <x>.

 -- Función: dkummer_u (<a>, <b>, <x>)
     Derivada de `kummer_u(<a>,<b>,<x>)' respecto de <x>.


File: maxima.info,  Node: Posibles mejoras a contrib_ode,  Next: Pruebas realizadas con contrib_ode,  Prev: Funciones y variables para contrib_ode,  Up: contrib_ode

44.3 Posibles mejoras a contrib_ode
===================================

Este paquete aún se encuentra en fase de desarrollo. Aspectos
pendientes:

   * Extender el método FACTOR `ode1_factor' para que trabaje con
     raíces múltiples.

   * Extender el método FACTOR `ode1_factor' para que intente resolver
     factores de orden superior. En este momento sólo intenta resolver
     factores lineales.

   * Modificar la rutina LAGRANGE `ode1_lagrange' para que prefiera
     raíces reales a las complejas.

   * Añadir más métodos para las ecuaciones de RIccati.

   * Mejorar la identificación de las ecuaciones de Abel de segunda
     especie.  El procedimiento actual no es muy bueno.

   * Trabajar la rutina del grupo simétrico de Lie `ode1_lie'.  Existen
     algunos problemas: algunas partes no están implementadas, algunos
     ejemplos no terminan de ejecutarse, otros producen errors, otros
     devuelven respuestas muy complejas.

   * Hacer más pruebas.



File: maxima.info,  Node: Pruebas realizadas con contrib_ode,  Next: Referencias para contrib_ode,  Prev: Posibles mejoras a contrib_ode,  Up: contrib_ode

44.4 Pruebas realizadas con contrib_ode
=======================================

Los procedimientos fueron probados con cerca de mil ecuaciones tomadas
de Murphy, Kamke, Zwillinger y otros. Éstas se encuentran en el
directorio de pruebas.

   * La rutina de Clairault `ode1_clairault' encuentra todas las
     soluciones conocidas, incluídas las singulares, de las ecuaciones
     de Clairault en Murphy y Kamke.

   * Las otras rutinas a veces devuelven una sola solución cuando
     existen más.

   * Algunas de las soluciones devueltas por `ode1_lie' son demasiado
     complejas e imposibles de interpretar.

   * A veces se producen detenciones imprevistas del procedimiento.



File: maxima.info,  Node: Referencias para contrib_ode,  Prev: Pruebas realizadas con contrib_ode,  Up: contrib_ode

44.5 Referencias para contrib_ode
=================================

  1. E. Kamke, Differentialgleichungen Losungsmethoden und Losungen,
     Vol 1,     Geest & Portig, Leipzig, 1961

  2. G. M. Murphy, Ordinary Differential Equations and Their Solutions,
        Van Nostrand, New York, 1960

  3. D. Zwillinger, Handbook of Differential Equations, 3rd edition,
     Academic Press, 1998

  4. F. Schwarz, Symmetry Analysis of Abel's Equation, Studies in
     Applied Mathematics, 100:269-294 (1998)

  5. F. Schwarz, Algorithmic Solution of Abel's Equation,     Computing
     61, 39-49 (1998)

  6. E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order     ODE
     Patterns, Computer Physics Communications 113 (1998), p 239.
     (`http://lie.uwaterloo.ca/papers/ode_vii.pdf')

  7. E. S. Cheb-Terrab, T. Koloknikov,  First Order ODEs,
     Symmetries and Linear Transformations, European Journal of
     Applied Mathematics, Vol. 14, No. 2, pp. 231-246 (2003).
     (`http://arxiv.org/abs/math-ph/0007023')
     (`http://lie.uwaterloo.ca/papers/ode_iv.pdf')

  8. G. W. Bluman, S. C. Anco, Symmetry and Integration Methods for
     Differential Equations, Springer, (2002)

  9. M Bronstein, S Lafaille, Solutions of linear ordinary differential
     equations in terms of special functions, Proceedings of ISSAC
     2002, Lille, ACM Press, 23-28.
     (`http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf')


File: maxima.info,  Node: descriptive,  Next: diag,  Prev: contrib_ode,  Up: Top

45 descriptive
**************

* Menu:

* Introducción a descriptive::
* Funciones y variables para el tratamiento de datos::
* Funciones y variables de valores descriptivos::
* Funciones y variables de valores descriptivos multivariantes::
* Funciones y variables para gráficos estadísticos::


File: maxima.info,  Node: Introducción a descriptive,  Next: Funciones y variables para el tratamiento de datos,  Prev: descriptive,  Up: descriptive

45.1 Introducción a descriptive
===============================

El paquete `descriptive' contiene funciones para realizar cl'culos y
gráficos estadísticos descriptivos. Junto con el código fuente se
distribuyen tres conjuntos de datos: `pidigits.data', `wind.data' y
`biomed.data', los cuales también se pueden descargar desde el sitio
web `www.biomates.net'.

   Cualquier manual de estadística se puede utilizar como referencia al
paquete `descriptive'.

   Para comentarios, fallos y sugerencias, por favor contactar con
<'mario AT edu DOT xunta DOT es'>.

   Aquí un sencillo ejemplo sobre cómo operan las funciones de
`descriptive', dependiendo de la naturaleza de sus argumentos, listas o
matrices,

     (%i1) load (descriptive)$
     (%i2) /* muestra univariate */   mean ([a, b, c]);
                                 c + b + a
     (%o2)                       ---------
                                     3
     (%i3) matrix ([a, b], [c, d], [e, f]);
                                 [ a  b ]
                                 [      ]
     (%o3)                       [ c  d ]
                                 [      ]
                                 [ e  f ]
     (%i4) /* muestra multivariante */ mean (%);
                           e + c + a  f + d + b
     (%o4)                [---------, ---------]
                               3          3

   Nótese que en las muestras multivariantes la media se calcula para
cada columna.

   En caso de varias muestras de diferente tamaño, la función `map' de
Maxima puede utilizarse para obtener los resultados deseados para cada
muestra,

     (%i1) load (descriptive)$
     (%i2) map (mean, [[a, b, c], [d, e]]);
                             c + b + a  e + d
     (%o2)                  [---------, -----]
                                 3        2

   En este caso, dos muestras de tamaños 3 y 2 han sido almacenadas en
una lista.

   Muestras univariantes deben guardarse en listas como en

     (%i1) s1 : [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
     (%o1)           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

   y muestras multivariantes en matrices como las del siguiente ejemplo

     (%i1) s2 : matrix ([13.17, 9.29], [14.71, 16.88], [18.50, 16.88],
                  [10.58, 6.63], [13.33, 13.25], [13.21,  8.12]);
                             [ 13.17  9.29  ]
                             [              ]
                             [ 14.71  16.88 ]
                             [              ]
                             [ 18.5   16.88 ]
     (%o1)                   [              ]
                             [ 10.58  6.63  ]
                             [              ]
                             [ 13.33  13.25 ]
                             [              ]
                             [ 13.21  8.12  ]

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

   Los datos pueden suministrarse manualmente, pero las muestras
grandes se suelen almacenar en ficheros de texto. Por ejemplo, el
fichero `pidigits.data' contiene los 100 primeros dígitos del número
`%pi':
           3
           1
           4
           1
           5
           9
           2
           6
           5
           3 ...

   A fin de leer estos dígitos desde Maxima,

     (%i1) load (numericalio)$
     (%i2) s1 : read_list (file_search ("pidigits.data"))$
     (%i3) length (s1);
     (%o3)                          100

   Por otro lado, el archivo `wind.data' contiene los promedios diarios
de la velocidad del viento en cinco estaciones meteorológicas en
Irlanda (esta muestra es parte de un conjunto de datos correspondientes
a 12 estaciones meteorológicas. El fichero original se puede descargar
libremente del 'StatLib Data Repository' y se analiza en  Haslett, J.,
Raftery, A. E. (1989) <Space-time Modelling with Long-memory
Dependence: Assessing Ireland's Wind Power Resource, with Discussion>.
Applied Statistics 38, 1-50). Así se leen los datos:

     (%i1) load (numericalio)$
     (%i2) s2 : read_matrix (file_search ("wind.data"))$
     (%i3) length (s2);
     (%o3)                          100
     (%i4) s2 [%]; /* ultimo registro */
     (%o4)            [3.58, 6.0, 4.58, 7.62, 11.25]

   Algunas muestras contienen datos no numéricos. Como ejemplo, el
archivo `biomed.data' (el cual es parte de otro mayor descargado
también del 'StatLib Data Repository') contiene cuatro mediciones
sanguíneas tomadas a dos grupos de pacientes, `A' y `B', de diferentes
edades,

     (%i1) load (numericalio)$
     (%i2) s3 : read_matrix (file_search ("biomed.data"))$
     (%i3) length (s3);
     (%o3)                          100
     (%i4) s3 [1]; /* primer registro */
     (%o4)            [A, 30, 167.0, 89.0, 25.6, 364]

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

   Debe tenerse cuidado cuando se trabaje con datos categóricos. En el
siguiente ejemplo, se asigna al símbolo `a' cierto valor en algún
momento previo y luego se toma una muestra con el valor categórico `a',

     (%i1) a : 1$
     (%i2) matrix ([a, 3], [b, 5]);
                                 [ 1  3 ]
     (%o2)                       [      ]
                                 [ b  5 ]


File: maxima.info,  Node: Funciones y variables para el tratamiento de datos,  Next: Funciones y variables de valores descriptivos,  Prev: Introducción a descriptive,  Up: descriptive

45.2 Funciones y variables para el tratamiento de datos
=======================================================

 -- Función: continuous_freq (<list>)
 -- Función: continuous_freq (<list>, <m>)
     El argumento de `continuous_freq' debe ser una lista de números,
     los cuales serán luego agrupados en intervalos y hecho el recuento
     de cuántos hay en cada grupo. Opcionalmente, la función
     `continuous_freq' admite un segundo argumento para indicar el
     número de clases a considerar, siendo 10 su valor por defecto.

          (%i1) load (numericalio)$
          (%i2) load (descriptive)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) continuous_freq (s1, 5);
          (%o4) [[0, 1.8, 3.6, 5.4, 7.2, 9.0], [16, 24, 18, 17, 25]]

     La primera lista contiene los extremos de los intervalos y la
     segunda los resultados de los recuentos: hay 16 dígitos dentro del
     intervalo  `[0, 1.8]', esto es ceros y unos, 24 dígitos en `(1.8,
     3.6]', es decir doses y treses, y así sucesivamente.

 -- Función: discrete_freq (<list>)
     Calcula las frecuencias absolutas en muestras discretas, tanto
     numéricas como categóricas. Su único argumento debe ser una lista.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) discrete_freq (s1);
          (%o4) [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                                       [8, 8, 12, 12, 10, 8, 9, 8, 12, 13]]

     La primera lista son los valores de la muestra y la segunda sus
     frecuencias absolutas. Las instrucciones `? col' y `? transpose'
     pueden ayudar a comprender la última entrada.

 -- Función: subsample (<data_matrix>, <logical_expression>)
 -- Función: subsample (<data_matrix>, <logical_expression>, <col_num>,
          <col_num>, ...)
     Esta es una variante de la función `submatrix' de Maxima. El
     primer argumento es una matriz de datos, el segundo es una
     expresión lógica no evaluada y el resto de argumentos opcionales
     son los números de las columnas a tomar en consideración,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) subsample (s2, '(%c[1] > 18));
                        [ 19.38  15.37  15.12  23.09  25.25 ]
                        [                                   ]
                        [ 18.29  18.66  19.08  26.08  27.63 ]
          (%o4)         [                                   ]
                        [ 20.25  21.46  19.95  27.71  23.38 ]
                        [                                   ]
                        [ 18.79  18.96  14.46  26.38  21.84 ]

     Estos son los registros multivariantes en los que la velocidad del
     viento en la primera estación meteorológica fue menor que 18.
     Véase cómo en la expresión lógica no evaluada a la <i>-ésima
     componente se la referencia como `%c[i]'. El símbolo `%c[i]' es
     utilizado dentro de la función `subsample', por lo que si se
     utiliza también como variable categórica, Maxima puede dar
     resultados imprevistos. En el siguiente ejemplo, se solicitan
     únicamente la primera, segunda y quinta componentes de aquellos
     registros con velocidades del viento mayores o iguales que 16
     nudos en la estación número 1 y menores que 25 nudos en la
     estación número 4,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) subsample (s2, '(%c[1] >= 16 and %c[4] < 25), 1, 2, 5);
                               [ 19.38  15.37  25.25 ]
                               [                     ]
                               [ 17.33  14.67  19.58 ]
          (%o4)                [                     ]
                               [ 16.92  13.21  21.21 ]
                               [                     ]
                               [ 17.25  18.46  23.87 ]

     He aquí un ejemplo con las variables categóricas de `biomed.data'.
     Se piden los registros correspondientes a aquellos pacientes del
     grupo `B' mayores de 38 anños,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) subsample (s3, '(%c[1] = B and %c[2] > 38));
                          [ B  39  28.0  102.3  17.1  146 ]
                          [                               ]
                          [ B  39  21.0  92.4   10.3  197 ]
                          [                               ]
                          [ B  39  23.0  111.5  10.0  133 ]
                          [                               ]
                          [ B  39  26.0  92.6   12.3  196 ]
          (%o4)           [                               ]
                          [ B  39  25.0  98.7   10.0  174 ]
                          [                               ]
                          [ B  39  21.0  93.2   5.9   181 ]
                          [                               ]
                          [ B  39  18.0  95.0   11.3  66  ]
                          [                               ]
                          [ B  39  39.0  88.5   7.6   168 ]

     Es probable que el análisis estadístico requiera únicamente de las
     medidas sanguíneas,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) subsample (s3, '(%c[1] = B and %c[2] > 38), 3, 4, 5, 6);
                             [ 28.0  102.3  17.1  146 ]
                             [                        ]
                             [ 21.0  92.4   10.3  197 ]
                             [                        ]
                             [ 23.0  111.5  10.0  133 ]
                             [                        ]
                             [ 26.0  92.6   12.3  196 ]
          (%o4)              [                        ]
                             [ 25.0  98.7   10.0  174 ]
                             [                        ]
                             [ 21.0  93.2   5.9   181 ]
                             [                        ]
                             [ 18.0  95.0   11.3  66  ]
                             [                        ]
                             [ 39.0  88.5   7.6   168 ]

     Esta es la media multivariante de `s3',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) mean (s3);
                 65 B + 35 A  317          6 NA + 8145.0
          (%o4) [-----------, ---, 87.178, -------------, 18.123,
                     100      10                100
                                                              3 NA + 19587
                                                              ------------]
                                                                  100

     Aquí la primera componente carece de significado, ya que tanto `A'
     como `B' son categóricas, la segunda componente es la edad media
     de los individuos en forma racional, al tiempo que los valores
     cuarto y quinto muestran cierto comportamiento extraño; lo cual se
     debe a que el símbolo `NA' se utiliza para indicar datos no
     disponibles, por lo que ambas medias no tienen sentido. Una
     posible solución puede ser extraer de la matriz aquellas filas con
     símbolos `NA', lo que acarrearía cierta pérdida de información,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) mean (subsample (s3, '(%c[4] # NA and %c[6] # NA), 3, 4, 5, 6));
          (%o4) [79.4923076923077, 86.2032967032967, 16.93186813186813,
                                                                      2514
                                                                      ----]
                                                                       13


File: maxima.info,  Node: Funciones y variables de valores descriptivos,  Next: Funciones y variables de valores descriptivos multivariantes,  Prev: Funciones y variables para el tratamiento de datos,  Up: descriptive

45.3 Funciones y variables de valores descriptivos
==================================================

 -- Función: mean (<list>)
 -- Función: mean (<matrix>)
     Es la media muestral, definida como
                                 n
                               ====
                       _   1   \
                       x = -    >    x
                           n   /      i
                               ====
                               i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mean (s1);
                                         471
          (%o4)                          ---
                                         100
          (%i5) %, numer;
          (%o5)                         4.71
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) mean (s2);
          (%o7)     [9.9485, 10.1607, 10.8685, 15.7166, 14.8441]


 -- Función: var (<list>)
 -- Función: var (<matrix>)
     Es la varianza muestral, definida como
                               n
                             ====
                     2   1   \          _ 2
                    s  = -    >    (x - x)
                         n   /       i
                             ====
                             i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) var (s1), numer;
          (%o4)                   8.425899999999999

     Véase también `var1'.

 -- Función: var1 (<list>)
 -- Función: var1 (<matrix>)
     Es la cuasivarianza muestral, definida como
                               n
                             ====
                         1   \          _ 2
                        ---   >    (x - x)
                        n-1  /       i
                             ====
                             i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) var1 (s1), numer;
          (%o4)                    8.5110101010101
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) var1 (s2);
          (%o6) [17.39586540404041, 15.13912778787879, 15.63204924242424,
                                      32.50152569696971, 24.66977392929294]

     Véase también `var'.

 -- Función: std (<list>)
 -- Función: std (<matrix>)
     Es la desviación típica muestral, raíz cuadrada de `var'.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) std (s1), numer;
          (%o4)                   2.902740084816414
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) std (s2);
          (%o6) [4.149928523480858, 3.871399812729241, 3.933920277534866,
                                      5.672434260526957, 4.941970881136392]

     Véanse también `var' y `std1'.

 -- Función: std1 (<list>)
 -- Función: std1 (<matrix>)
     Es la cuasidesviación típica muestral, raíz cuadrada de `var1'.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) std1 (s1), numer;
          (%o4)                   2.917363553109228
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) std1 (s2);
          (%o6) [4.17083509672109, 3.89090320978032, 3.953738641137555,
                                      5.701010936401517, 4.966867617451963]

     Véanse también `var1' y `std'.

 -- Función: noncentral_moment (<list>, <k>)
 -- Función: noncentral_moment (<matrix>, <k>)
     Es el momento no central de orden k, definido como
                                 n
                               ====
                           1   \      k
                           -    >    x
                           n   /      i
                               ====
                               i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) noncentral_moment (s1, 1), numer; /* la media */
          (%o4)                         4.71
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) noncentral_moment (s2, 5);
          (%o7) [319793.8724761506, 320532.1923892463, 391249.5621381556,
                                      2502278.205988911, 1691881.797742255]

     Véase también `central_moment'.

 -- Función: central_moment (<list>, <k>)
 -- Función: central_moment (<matrix>, <k>)
     Es el momento central de orden k, definido como
                              n
                            ====
                        1   \          _ k
                        -    >    (x - x)
                        n   /       i
                            ====
                            i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) central_moment (s1, 2), numer; /* la varianza */
          (%o4)                   8.425899999999999
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) central_moment (s2, 3);
          (%o7) [11.29584771375004, 16.97988248298583, 5.626661952750102,
                                       37.5986572057918, 25.85981904394192]

     Véanse también `central_moment' y `mean'.

 -- Función: cv (<list>)
 -- Función: cv (<matrix>)
     Es el coeficiente de variación, o cociente entre la desviación
     típica muestral (`std') y la media (`mean'),

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) cv (s1), numer;
          (%o4)                   .6193977819764815
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) cv (s2);
          (%o6) [.4192426091090204, .3829365309260502, 0.363779605385983,
                                      .3627381836021478, .3346021393989506]

     Véanse también `std' y `mean'.

 -- Función: mini (<list>)
 -- Función: mini (<matrix>)
     Es el valor mínimo de la muestra <list>,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mini (s1);
          (%o4)                           0
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) mini (s2);
          (%o6)             [0.58, 0.5, 2.67, 5.25, 5.17]

     Véase también `maxi'.

 -- Función: maxi (<list>)
 -- Función: maxi (<matrix>)
     Es el valor máximo de la muestra <list>,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) maxi (s1);
          (%o4)                           9
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) maxi (s2);
          (%o6)          [20.25, 21.46, 20.04, 29.63, 27.63]

     Véase también `mini'.

 -- Función: range (<list>)
 -- Función: range (<matrix>)
     Es la diferencia entre los valores extremos.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) range (s1);
          (%o4)                           9
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) range (s2);
          (%o6)          [19.67, 20.96, 17.37, 24.38, 22.46]


 -- Función: quantile (<list>, <p>)
 -- Función: quantile (<matrix>, <p>)
     Es el <p>-cuantil, siendo <p> un número del intervalo [0, 1], de
     la muestra <list>.  Aunque existen varias definiciones para el
     cuantil muestral (Hyndman, R. J., Fan, Y. (1996) <Sample quantiles
     in statistical packages>. American Statistician, 50, 361-365), la
     programada en el paquete  `descriptive' es la basada en la
     interpolación lineal.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) /* 1er and 3er cuartiles */
                [quantile (s1, 1/4), quantile (s1, 3/4)], numer;
          (%o4)                      [2.0, 7.25]
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) quantile (s2, 1/4);
          (%o6)    [7.2575, 7.477500000000001, 7.82, 11.28, 11.48]


 -- Función: median (<list>)
 -- Función: median (<matrix>)
     Una vez ordenada una muestra, si el tamaño muestral es impar la
     mediana es el valor central, en caso contrario será la media de
     los dos valores centrales.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) median (s1);
                                          9
          (%o4)                           -
                                          2
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) median (s2);
          (%o6)         [10.06, 9.855, 10.73, 15.48, 14.105]

     La mediana es el cuantil 1/2.

     Véase también `quantile'.

 -- Función: qrange (<list>)
 -- Función: qrange (<matrix>)
     El rango intercuartílico es la diferencia entre el tercer y primer
     cuartil, `quantile(<list>,3/4) - quantile(<list>,1/4)',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) qrange (s1);
                                         21
          (%o4)                          --
                                         4
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) qrange (s2);
          (%o6) [5.385, 5.572499999999998, 6.0225, 8.729999999999999,
                                                         6.650000000000002]

     Véase también `quantile'.

 -- Función: mean_deviation (<list>)
 -- Función: mean_deviation (<matrix>)
     Es la desviación media, definida como
                               n
                             ====
                         1   \          _
                         -    >    |x - x|
                         n   /       i
                             ====
                             i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mean_deviation (s1);
                                         51
          (%o4)                          --
                                         20
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) mean_deviation (s2);
          (%o6) [3.287959999999999, 3.075342, 3.23907, 4.715664000000001,
                                                         4.028546000000002]

     Véase también `mean'.

 -- Función: median_deviation (<list>)
 -- Función: median_deviation (<matrix>)
     Es la desviación mediana, definida como
                           n
                         ====
                     1   \
                     -    >    |x - med|
                     n   /       i
                         ====
                         i = 1
     siendo `med' la mediana de <list>.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) median_deviation (s1);
                                          5
          (%o4)                           -
                                          2
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) median_deviation (s2);
          (%o6)           [2.75, 2.755, 3.08, 4.315, 3.31]

     Véase también `mean'.

 -- Función: harmonic_mean (<list>)
 -- Función: harmonic_mean (<matrix>)
     Es la media armónica, definida como
                            n
                         --------
                          n
                         ====
                         \     1
                          >    --
                         /     x
                         ====   i
                         i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$
          (%i4) harmonic_mean (y), numer;
          (%o4)                   3.901858027632205
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) harmonic_mean (s2);
          (%o6) [6.948015590052786, 7.391967752360356, 9.055658197151745,
                                      13.44199028193692, 13.01439145898509]

     Véanse también `mean' y `geometric_mean'.

 -- Función: geometric_mean (<list>)
 -- Función: geometric_mean (<matrix>)
     Es la media geométrica, definida como
                           /  n      \ 1/n
                           | /===\   |
                           |  ! !    |
                           |  ! !  x |
                           |  ! !   i|
                           | i = 1   |
                           \         /

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$
          (%i4) geometric_mean (y), numer;
          (%o4)                   4.454845412337012
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) geometric_mean (s2);
          (%o6) [8.82476274347979, 9.22652604739361, 10.0442675714889,
                                      14.61274126349021, 13.96184163444275]

     Véanse también `mean' y `harmonic_mean'.

 -- Función: kurtosis (<list>)
 -- Función: kurtosis (<matrix>)
     Es el coeficiente de curtosis, definido como
                              n
                            ====
                      1     \          _ 4
                     ----    >    (x - x)  - 3
                        4   /       i
                     n s    ====
                            i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) kurtosis (s1), numer;
          (%o4)                  - 1.273247946514421
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) kurtosis (s2);
          (%o6) [- .2715445622195385, 0.119998784429451,
             - .4275233490482866, - .6405361979019522, - .4952382132352935]

     Véanse también `mean', `var' y `skewness'.

 -- Función: skewness (<list>)
 -- Función: skewness (<matrix>)
     Es el coeficiente de asimetría, definido como
                              n
                            ====
                      1     \          _ 3
                     ----    >    (x - x)
                        3   /       i
                     n s    ====
                            i = 1

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) skewness (s1), numer;
          (%o4)                  .009196180476450306
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) skewness (s2);
          (%o6) [.1580509020000979, .2926379232061854, .09242174416107717,
                                      .2059984348148687, .2142520248890832]

     Véanse también `mean', `var' y `kurtosis'.

 -- Función: pearson_skewness (<list>)
 -- Función: pearson_skewness (<matrix>)
     Es el coeficiente de asimetría de Pearson, definido como
                          _
                       3 (x - med)
                       -----------
                            s
     siendo <med> la mediana de <list>.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) pearson_skewness (s1), numer;
          (%o4)                   .2159484029093895
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) pearson_skewness (s2);
          (%o6) [- .08019976629211892, .2357036272952649,
                   .1050904062491204, .1245042340592368, .4464181795804519]

     Véanse también `mean', `var' y `median'.

 -- Función: quartile_skewness (<list>)
 -- Función: quartile_skewness (<matrix>)
     Es el coeficiente de asimetría cuartílico, definido como
                         c    - 2 c    + c
                          3/4      1/2    1/4
                         --------------------
                             c    - c
                              3/4    1/4
     siendo c_p el <p>-cuantil de la muestra <list>.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) quartile_skewness (s1), numer;
          (%o4)                  .04761904761904762
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) quartile_skewness (s2);
          (%o6) [- 0.0408542246982353, .1467025572005382,
                 0.0336239103362392, .03780068728522298, 0.210526315789474]

     Véase también `quantile'.


File: maxima.info,  Node: Funciones y variables de valores descriptivos multivariantes,  Next: Funciones y variables para gráficos estadísticos,  Prev: Funciones y variables de valores descriptivos,  Up: descriptive

45.4 Funciones y variables de valores descriptivos multivariantes
=================================================================

 -- Función: cov (<matrix>)
     Es la matriz de covarianzas de una muestra multivariante, definida
     como
                        n
                       ====
                    1  \           _        _
                S = -   >    (X  - X) (X  - X)'
                    n  /       j        j
                       ====
                       j = 1
     siendo X_j la j-ésima fila de la matriz muestral.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) fpprintprec : 7$  /* cambia precision */
          (%i5) cov (s2);
                [ 17.22191  13.61811  14.37217  19.39624  15.42162 ]
                [                                                  ]
                [ 13.61811  14.98774  13.30448  15.15834  14.9711  ]
                [                                                  ]
          (%o5) [ 14.37217  13.30448  15.47573  17.32544  16.18171 ]
                [                                                  ]
                [ 19.39624  15.15834  17.32544  32.17651  20.44685 ]
                [                                                  ]
                [ 15.42162  14.9711   16.18171  20.44685  24.42308 ]

     Véase también `cov1'.

 -- Función: cov1 (<matrix>)
     Es la matriz de cuasivarianzas de una muestra multivariante,
     definida como
                        n
                       ====
                   1   \           _        _
             S  = ---   >    (X  - X) (X  - X)'
              1   n-1  /       j        j
                       ====
                       j = 1
     siendo X_j la j-ésima fila de la matriz muestral.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) fpprintprec : 7$ /* cambia precision */
          (%i5) cov1 (s2);
                [ 17.39587  13.75567  14.51734  19.59216  15.5774  ]
                [                                                  ]
                [ 13.75567  15.13913  13.43887  15.31145  15.12232 ]
                [                                                  ]
          (%o5) [ 14.51734  13.43887  15.63205  17.50044  16.34516 ]
                [                                                  ]
                [ 19.59216  15.31145  17.50044  32.50153  20.65338 ]
                [                                                  ]
                [ 15.5774   15.12232  16.34516  20.65338  24.66977 ]

     Véase también `cov'.

 -- Función: global_variances (<matrix>)
 -- Función: global_variances (<matrix>, <logical_value>)
     La función `global_variances' devuelve una lista de medidas
     globales de variabilidad:

        * <varianza total>: `trace(S_1)',

        * <varianza media>: `trace(S_1)/p',

        * <varianza generalizada>: `determinant(S_1)',

        * <desviación típica generalizada>: `sqrt(determinant(S_1))',

        * <varianza efectiva> `determinant(S_1)^(1/p)', (definida en:
          Peña, D. (2002) <Análisis de datos multivariantes>;
          McGraw-Hill, Madrid.)

        * <desviación típica efectiva>: `determinant(S_1)^(1/(2*p))'.
     donde <p> es la dimensión de la variable aleatoria multivariante y
     S_1 la matriz de covarianzas devuelta por la función `cov1'.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) global_variances (s2);
          (%o4) [105.338342060606, 21.06766841212119, 12874.34690469686,
                   113.4651792608502, 6.636590811800794, 2.576158149609762]

     La función `global_variances' tiene un argumento lógico opcional:
     `global_variances(x,true)' indica a Maxima que `x' es la matriz de
     datos, calculando entonces lo mismo que `global_variances(x)'. Por
     otro lado, `global_variances(x,false)' significa que  `x' no es la
     matriz de datos, sino la de covarianzas, evitando así recalcularla,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) s : cov1 (s2)$
          (%i5) global_variances (s, false);
          (%o5) [105.338342060606, 21.06766841212119, 12874.34690469686,
                   113.4651792608502, 6.636590811800794, 2.576158149609762]

     Véanse también `cov' y `cov1'.

 -- Función: cor (<matrix>)
 -- Función: cor (<matrix>, <logical_value>)
     Es la matriz de correlaciones de la muestra multivariante.

     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) fpprintprec: 7$
          (%i4) s2 : read_matrix (file_search ("wind.data"))$
          (%i5) cor (s2);
                [   1.0     .8476339  .8803515  .8239624  .7519506 ]
                [                                                  ]
                [ .8476339    1.0     .8735834  .6902622  0.782502 ]
                [                                                  ]
          (%o5) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
                [                                                  ]
                [ .8239624  .6902622  .7764065    1.0     .7293848 ]
                [                                                  ]
                [ .7519506  0.782502  .8323358  .7293848    1.0    ]

     La función `cor' tiene un argumento lógico opcional: `cor(x,true)'
     indica a Maxima que `x' es la matriz de datos, calculando entonces
     lo mismo que `cor(x)'. Por otro lado, `cor(x,false)' significa que
     `x' no es la matriz de datos, sino la de covarianzas, evitando
     así recalcularla,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) fpprintprec: 7$
          (%i4) s2 : read_matrix (file_search ("wind.data"))$
          (%i5) s : cov1 (s2)$
          (%i6) cor (s, false); /* mas rapido */
                [   1.0     .8476339  .8803515  .8239624  .7519506 ]
                [                                                  ]
                [ .8476339    1.0     .8735834  .6902622  0.782502 ]
                [                                                  ]
          (%o6) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
                [                                                  ]
                [ .8239624  .6902622  .7764065    1.0     .7293848 ]
                [                                                  ]
                [ .7519506  0.782502  .8323358  .7293848    1.0    ]

     Véanse también `cov' y `cov1'.

 -- Función: list_correlations (<matrix>)
 -- Función: list_correlations (<matrix>, <logical_value>)
     La función `list_correlations' devuelve una lista con medidas de
     correlación:

        * <matriz de precisión>: es la inversa de la matriz de
          covarianzas S_1,
                      -1     ij
                     S   = (s  )
                      1         i,j = 1,2,...,p

        * <vector de correlación múltiple>:  (R_1^2, R_2^2, ...,
          R_p^2), donde
                      2          1
                     R  = 1 - -------
                      i        ii
                              s   s
                                   ii
          es un indicador de la bondad de ajuste del modelo de
          regresión lineal multivariante de X_i cuando el resto de
          variables se utilizan como regresores.

        * <matriz de correlaciones parciales>: en la que el elemento
          (i, j) es
                                        ij
                                       s
                     r        = - ------------
                      ij.rest     / ii  jj\ 1/2
                                  |s   s  |
                                  \       /


     Ejemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) z : list_correlations (s2)$
          (%i5) fpprintprec : 5$ /* cambia precision */
          (%i6) z[1];  /* matriz de precision */
                [  .38486   - .13856   - .15626   - .10239    .031179  ]
                [                                                      ]
                [ - .13856   .34107    - .15233    .038447   - .052842 ]
                [                                                      ]
          (%o6) [ - .15626  - .15233    .47296    - .024816  - .10054  ]
                [                                                      ]
                [ - .10239   .038447   - .024816   .10937    - .034033 ]
                [                                                      ]
                [ .031179   - .052842  - .10054   - .034033   .14834   ]
          (%i7) z[2];  /* vector de correlacion multiple */
          (%o7)       [.85063, .80634, .86474, .71867, .72675]
          (%i8) z[3];  /* matriz de correlaciones parciales */
                 [  - 1.0     .38244   .36627   .49908   - .13049 ]
                 [                                                ]
                 [  .38244    - 1.0    .37927  - .19907   .23492  ]
                 [                                                ]
          (%o8)  [  .36627    .37927   - 1.0    .10911    .37956  ]
                 [                                                ]
                 [  .49908   - .19907  .10911   - 1.0     .26719  ]
                 [                                                ]
                 [ - .13049   .23492   .37956   .26719    - 1.0   ]

     La función `list_correlations' tiene un argumento lógico opcional:
     `list_correlations(x,true)' indica a Maxima que `x' es la matriz
     de datos, calculando entonces lo mismo que `list_correlations(x)'.
     Por otro lado, `list_correlations(x,false)' significa que  `x' no
     es la matriz de datos, sino la de covarianzas, evitando así
     recalcularla.

     Véanse también `cov' y `cov1'.


File: maxima.info,  Node: Funciones y variables para gráficos estadísticos,  Prev: Funciones y variables de valores descriptivos multivariantes,  Up: descriptive

45.5 Funciones y variables para gráficos estadísticos
=====================================================

 -- Función: dataplot (<list>)
 -- Función: dataplot (<list>, <option_1>, <option_2>, ...)
 -- Función: dataplot (<matrix>)
 -- Función: dataplot (<matrix>, <option_1>, <option_2>, ...)
     La función `dataplot' permite la visualización directa de datos
     muestrales, tanto univariantes (<list>) como multivariantes
     (<matrix>). Asignando valores a las siguientes opciones
     (<options>) se pueden controlar ciertos aspectos del gráfico:

        * `'outputdev', `"x"' por defecto, indica el dispositivo de
          salida; valores aceptados son `"x"', `"eps"' y `"png"', para
          la pantalla, y los formatos de ficheros postscript y png,
          respectivamente.

        * `'maintitle', `""' por defecto, es el título principal entre
          comillas dobles.

        * `'axisnames', `["x","y","z"]' por defecto, es una lista con
          nombres para los ejes `x', `y' y `z'.

        * `'joined', `false' por defecto, un valor lógico que indica si
          los puntos en 2D deben unirse por segmentos o no.

        * `'picturescales', `[1.0, 1.0]' por defecto, factores de
          escala para el tamaño del gráfico.

        * `'threedim', `true' por defecto, indica a Maxima si debe
          dibujar una matriz de tres columnas como un diagrama
          tridimensional o como un diagrama de dispersión
          multivariante. Véanse ejemplos más abajo.

        * `'axisrot', `[60, 30]' por defecto, cambia el punto de vista
          cuando `'threedim' toma el valor `true' y los datos se
          suministran en una matriz de tres columnas. El primer número
          es el ángulo de rotación del eje <x>, siendo el segundo el
          ángulo de rotación del eje <z>, ambos medidos en grados
          sexagesimales.

        * `'nclasses', `10' por defecto, es el número de clases a
          considerar en los histogramas de la diagonal de los diagramas
          de dispersión multivariantes.

        * `'pointstyle', `1' por defecto, es un entero que indica cómo
          dibujar los puntos muestrales.


     Por ejemplo, con el siguiente código se realiza un gráfico con los
     veinte primeros dígitos del número `%pi' y el resultado se guarda
     en un fichero en formato eps.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) dataplot (makelist (s1[k], k, 1, 20), 'pointstyle = 3)$

     Nótese que las muestras univariantes se representan como series
     temporales. En el siguiente ejemplo se utilizan más datos y con
     diferentes opciones,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) dataplot (makelist (s1[k], k, 1, 50),
                         'maintitle = "First pi digits",
                         'axisnames = ["digit order", "digit value"],
                         'pointstyle = 2,
                         'joined = true)$

     La función `dataplot' puede utilizarse para representar puntos del
     plano. El siguiente ejemplo es un diagrama de dispersión de los
     pares formados con las velocidades del viento correspondientes a
     las estaciones meteorológicas uno y cinco,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) dataplot (submatrix (s2, 2, 3, 4), 'pointstyle = 2,
           'maintitle = "Pairs of wind speeds measured in knots",
           'axisnames = ["Wind speed in A", "Wind speed in E"])$

     Si los puntos están almacenados en una matriz de dos columnas,
     `dataplot' los puede dibujar directamente, pero si están guardados
     como una lista de pares deben transformarse previamente a una
     matriz, tal como se hace en el siguiente ejemplo.

          (%i1) load (descriptive)$
          (%i2) x : [[-1, 2], [5, 7], [5, -3], [-6, -9], [-4, 6]]$
          (%i3) dataplot (apply ('matrix, x), 'maintitle = "Points",
           'joined = true, 'axisnames = ["", ""], 'picturescales = [0.5, 1.0])$

     Puntos del espacio tridimensional pueden verse como proyecciones
     sobre un plano. Es este ejemplo se piden gráficos de las
     velocidades del viento correspondientes a tres estaciones
     meteorológicas, primero una representación tridimensional y luego
     como diagrama de dispersión multivariante.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) /* grafico 3D */
                dataplot (
                   submatrix (s2, 4, 5),
                   'pointstyle = 2,
                   'maintitle = "Pairs of wind speeds measured in knots",
                   'axisnames = ["Station A", "Station B", "Station C"])$
          (%i5) /* Dispersion multivariante */
                dataplot (submatrix (s2, 4, 5),
                          'nclasses = 6,
                          'threedim = false)$

     Nótese que en este último ejemplo, el número de clases de los
     histogramas de la diagonal se ajusta a 6, y que a la opción
     `'threedim' se le da el valor `false'.

     Para más de tres dimensiones sólo son posibles los diagramas de
     dispersión multivariantes, como en

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) dataplot (s2)$


 -- Función: histogram (<list>)
 -- Función: histogram (<list>, <option_1>, <option_2>, ...)
 -- Función: histogram (<one_column_matrix>)
 -- Función: histogram (<one_column_matrix>, <option_1>, <option_2>,
          ...)
     Dibuja un histograma. Los datos muestrales deben suministrarse
     como una lista de números o como una matriz columna. Asignando
     valores a las siguientes opciones (<options>) se pueden controlar
     ciertos aspectos del gráfico:

        * `'outputdev', `"x"' por defecto, indica el dispositivo de
          salida; valores aceptados son `"x"', `"eps"' y `"png"', para
          la pantalla, y los formatos de ficheros postscript y png,
          respectivamente.

        * `'maintitle', `""' por defecto, es el título principal entre
          comillas dobles.

        * `'axisnames', `["x", "Fr."]' por defecto, es una lista con
          nombres para los ejes `x' e `y'.

        * `'picturescales', `[1.0, 1.0]' por defecto, factores de
          escala para el tamaño del gráfico.

        * `'nclasses', `10' por defecto, es el número de intervalos de
          clase.

        * `'relbarwidth', `0.9' por defecto, es un número decimal entre
          0 y 1 para controlar el ancho de las barras.

        * `'barcolor', `1' por defecto, es un entero que indica el
          color de las barras.

        * `'colorintensity', `1' por defecto, es un número decimal
          entre 0 y 1 para establecer la intensidad del color.


     En los siguientes dos ejemplos se solicitan sendos histogramas
     para los 100 primeros dígitos del número pi y para las velocidades
     del viento en la estación meteorológica número 3.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) histogram (s1,
                           'maintitle = "pi digits",
                           'axisnames = ["", "Absolute frequency"],
                           'relbarwidth = 0.2,
                           'barcolor = 3,
                           'colorintensity = 0.6)$
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) histogram (col (s2, 3), 'colorintensity = 0.3)$

     Nótese que en el primer caso, `s1' es una lista y que en el
     segundo `col(s2,3)' es una matriz.

     Véase también `barsplot'.

 -- Función: barsplot (<list>)
 -- Función: barsplot (<list>, <option_1>, <option_2>, ...)
 -- Función: barsplot (<one_column_matrix>)
 -- Función: barsplot (<one_column_matrix>, <option_1>, <option_2>, ...)
     Similar a `histogram' pero para muestras discretas, numéricas o
     categóricas. Estas son las variables,

        * `'outputdev', `"x"' por defecto, indica el dispositivo de
          salida; valores aceptados son `"x"', `"eps"' y `"png"', para
          la pantalla, y los formatos de ficheros postscript y png,
          respectivamente.

        * `'maintitle', `""' por defecto, es el título principal entre
          comillas dobles.

        * `'axisnames', `["x", "Fr."]' por defecto, es una lista con
          nombres para los ejes `x' e `y'.

        * `'picturescales', `[1.0, 1.0]' por defecto, factores de
          escala para el tamaño del gráfico.

        * `'relbarwidth', `0.9' por defecto, es un número decimal entre
          0 y 1 para controlar el ancho de las barras.

        * `'barcolor', `1' por defecto, es un entero que indica el
          color de las barras.

        * `'colorintensity', `1' por defecto, es un número decimal
          entre 0 y 1 para establecer la intensidad del color.


     En este ejemplo se representa el gráfico de barras correspondiente
     a los grupos `A' y `B' de los pacientes de la muestra `s3',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) barsplot (col (s3, 1), 'maintitle = "Groups of patients",
           'axisnames = ["Group", "# of individuals"], 'colorintensity = 0.2)$

     La primera columna de la muestra `s3' almacena los valores
     categóricos `A' y `B', llamados también factores. Por otro lado,
     los números enteros positivos en la segunda columna son las edades
     en años, que es una variable discreta, por lo que podemos
     representar las frecuencias absolutas de estos valores,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) barsplot (col (s3, 2), 'maintitle = "Ages",
           'axisnames = ["Years", "# of individuals"], 'colorintensity = 0.2,
           'relbarwidth = 0.6)$

     Véase también `histogram'.

 -- Función: boxplot (<data>)
 -- Función: boxplot (<data>, <option_1>, <option_2>, ...)
     Dibuja diagramas de cajas. El argumento <data> puede ser una
     lista, lo cual no es de gram interés puesto que estos gráficos se
     utilizan fundamentalmente para comparar varias muestras, o una
     matriz, de manera que es posible comparar dos o más componentes de
     una variable estadística multivariante. También se permite que
     <data> sea una lista de muestras con tamaños muestrales
     diferentes; de hecho esta es la única función del paquete
     `descriptive' que admite este tipo de estructura. Véase ejemplo
     más abajo. Estas son las opciones válidas:

        * `'outputdev', `"x"' por defecto, indica el dispositivo de
          salida; valores aceptados son `"x"', `"eps"' y `"png"', para
          la pantalla, y los formatos de ficheros postscript y png,
          respectivamente.

        * `'maintitle', `""' por defecto, es el título principal entre
          comillas dobles.

        * `'axisnames', `["sample", "y"]' por defecto, es una lista con
          nombres para los ejes `x' e `y'.

        * `'picturescales', `[1.0, 1.0]' por defecto, factores de
          escala para el tamaño del gráfico.


     Ejemplos:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) boxplot (s2, 'maintitle = "Windspeed in knots",
           'axisnames = ["Seasons", ""])$
          (%i5) A :
           [[6, 4, 6, 2, 4, 8, 6, 4, 6, 4, 3, 2],
            [8, 10, 7, 9, 12, 8, 10],
            [16, 13, 17, 12, 11, 18, 13, 18, 14, 12]]$
          (%i6) boxplot (A)$



File: maxima.info,  Node: diag,  Next: distrib,  Prev: descriptive,  Up: Top

46 diag
*******

* Menu:

* Funciones y variables para diag::


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

46.1 Funciones y variables para diag
====================================

 -- Función: diag (<lm>)
     Genera una matriz cuadrada con las matrices de <lm> en la
     diagonal, siendo <lm> una lista de matrices o de escalares.

     Ejemplo:
          (%i1) load("diag")$

          (%i2) a1:matrix([1,2,3],[0,4,5],[0,0,6])$

          (%i3) a2:matrix([1,1],[1,0])$

          (%i4) diag([a1,x,a2]);
                             [ 1  2  3  0  0  0 ]
                             [                  ]
                             [ 0  4  5  0  0  0 ]
                             [                  ]
                             [ 0  0  6  0  0  0 ]
          (%o4)              [                  ]
                             [ 0  0  0  x  0  0 ]
                             [                  ]
                             [ 0  0  0  0  1  1 ]
                             [                  ]
                             [ 0  0  0  0  1  0 ]

     Antes de hacer uso de esta función ejecútese  `load("diag")'.

 -- Función: JF (<lambda>,<n>)
     Devuelve la célula de Jordan de orden  <n> con valor propio
     <lambda>.

     Ejemplo:
          (%i1) load("diag")$

          (%i2) JF(2,5);
                              [ 2  1  0  0  0 ]
                              [               ]
                              [ 0  2  1  0  0 ]
                              [               ]
          (%o2)               [ 0  0  2  1  0 ]
                              [               ]
                              [ 0  0  0  2  1 ]
                              [               ]
                              [ 0  0  0  0  2 ]
          (%i3) JF(3,2);
                                   [ 3  1 ]
          (%o3)                    [      ]
                                   [ 0  3 ]

     Antes de hacer uso de esta función ejecútese  `load("diag")'.

 -- Función: jordan (<mat>)
     Devuelve la forma de Jordan de la matriz <mat>, pero en formato de
     lista de Maxima. Para obtener la matriz correspondiente, llámese a
     la función `dispJordan' utilizando como argumento la salida de
     `jordan'.

     Ejemplo:
          (%i1) load("diag")$

          (%i3) a:matrix([2,0,0,0,0,0,0,0],
                         [1,2,0,0,0,0,0,0],
                         [-4,1,2,0,0,0,0,0],
                         [2,0,0,2,0,0,0,0],
                         [-7,2,0,0,2,0,0,0],
                         [9,0,-2,0,1,2,0,0],
                         [-34,7,1,-2,-1,1,2,0],
                         [145,-17,-16,3,9,-2,0,3])$

          (%i34) jordan(a);
          (%o4)             [[2, 3, 3, 1], [3, 1]]
          (%i5) dispJordan(%);
                          [ 2  1  0  0  0  0  0  0 ]
                          [                        ]
                          [ 0  2  1  0  0  0  0  0 ]
                          [                        ]
                          [ 0  0  2  0  0  0  0  0 ]
                          [                        ]
                          [ 0  0  0  2  1  0  0  0 ]
          (%o5)           [                        ]
                          [ 0  0  0  0  2  1  0  0 ]
                          [                        ]
                          [ 0  0  0  0  0  2  0  0 ]
                          [                        ]
                          [ 0  0  0  0  0  0  2  0 ]
                          [                        ]
                          [ 0  0  0  0  0  0  0  3 ]

     Antes de hacer uso de esta función ejecútese  `load("diag")'.
     Véanse también `dispJordan' y `minimalPoly'.

 -- Función: dispJordan (<l>)
     Devuelve la matriz de Jordan asociada a la codificación dada por
     la lista <l>, que habitualmente será la salida de la función
     `jordan'.

     Ejemplo:
          (%i1) load("diag")$

          (%i2) b1:matrix([0,0,1,1,1],
                          [0,0,0,1,1],
                          [0,0,0,0,1],
                          [0,0,0,0,0],
                          [0,0,0,0,0])$

          (%i3) jordan(b1);
          (%o3)                  [[0, 3, 2]]
          (%i4) dispJordan(%);
                              [ 0  1  0  0  0 ]
                              [               ]
                              [ 0  0  1  0  0 ]
                              [               ]
          (%o4)               [ 0  0  0  0  0 ]
                              [               ]
                              [ 0  0  0  0  1 ]
                              [               ]
                              [ 0  0  0  0  0 ]

     Antes de hacer uso de esta función ejecútese  `load("diag")'.
     Véanse también `jordan' y `minimalPoly'.

 -- Función: minimalPoly (<l>)
     Devuelve el polinomio mínimo asociado a la codificación dada por
     la lista <l>, que habitualmente será la salida de la función
     `jordan'.

     Ejemplo:
          (%i1) load("diag")$

          (%i2) a:matrix([2,1,2,0],
                         [-2,2,1,2],
                         [-2,-1,-1,1],
                         [3,1,2,-1])$

          (%i3) jordan(a);
          (%o3)               [[- 1, 1], [1, 3]]
          (%i4) minimalPoly(%);
                                      3
          (%o4)                (x - 1)  (x + 1)

     Antes de hacer uso de esta función ejecútese  `load("diag")'.
     Véanse también `jordan' y `dispJordan'.

 -- Función: ModeMatrix (<A>,<l>)
     Devuelve la matriz <M> tal que (M^^-1).A.M=J, donde <J> es la
     forma de Jordan de <A>. La lista <l> es la forma codificada de la
     forma de Jordan tal como la devuelve la función `jordan'.

     Ejemplo:
          (%i1) load("diag")$

          (%i2) a:matrix([2,1,2,0],
                    [-2,2,1,2],
                    [-2,-1,-1,1],
                    [3,1,2,-1])$

          (%i3) jordan(a);
          (%o3)               [[- 1, 1], [1, 3]]
          (%i4) M: ModeMatrix(a,%);
                            [  1    - 1   1   1 ]
                            [                   ]
                            [   1               ]
                            [ - -   - 1   0   0 ]
                            [   9               ]
                            [                   ]
          (%o4)             [   13              ]
                            [ - --   1   - 1  0 ]
                            [   9               ]
                            [                   ]
                            [  17               ]
                            [  --   - 1   1   1 ]
                            [  9                ]
          (%i5) is(  (M^^-1).a.M = dispJordan(%o3)  );
          (%o5)                      true
     Nótese que `dispJordan(%o3)' es la forma de Jordan de la matriz
     `a'.

     Antes de hacer uso de esta función ejecútese  `load("diag")'.
     Véanse también `jordan' y `dispJordan'.

 -- Función: mat_function (<f>,<mat>)
     Devuelve  f(mat), siendo <f> una función analítica y <mat> una
     matriz. Este cálculo se basa en la fórmula integral de Cauchy, que
     establece que si `f(x)' es analítica y
          mat=diag([JF(m1,n1),...,JF(mk,nk)]),

     entonces

          f(mat)=ModeMatrix*diag([f(JF(m1,n1)),...,f(JF(mk,nk))])
                    * ModeMatrix^^(-1)

     Nótese que hay otros métodos alternativos para realizar este
     cálculo.

     Se presentan algunos ejemplos.

     Ejemplo 1:
          (%i1) load("diag")$

          (%i2) b2:matrix([0,1,0], [0,0,1], [-1,-3,-3])$

          (%i3) mat_function(exp,t*b2);
                         2   - t
                        t  %e          - t     - t
          (%o3) matrix([-------- + t %e    + %e   ,
                           2
                  - t     - t                           - t
           2    %e      %e        - t           - t   %e
          t  (- ----- - ----- + %e   ) + t (2 %e    - -----)
                  t       2                             t
                         t
                                   - t          - t     - t
                 - t       - t   %e        2  %e      %e
           + 2 %e   , t (%e    - -----) + t  (----- - -----)
                                   t            2       t
                         2   - t            - t     - t
               - t      t  %e        2    %e      %e        - t
           + %e   ], [- --------, - t  (- ----- - ----- + %e   ),
                           2                t       2
                                                   t
                  - t     - t      2   - t
             2  %e      %e        t  %e          - t
          - t  (----- - -----)], [-------- - t %e   ,
                  2       t          2
                  - t     - t                           - t
           2    %e      %e        - t           - t   %e
          t  (- ----- - ----- + %e   ) - t (2 %e    - -----),
                  t       2                             t
                         t
                - t     - t                 - t
           2  %e      %e            - t   %e
          t  (----- - -----) - t (%e    - -----)])
                2       t                   t
          (%i4) ratsimp(%);
                         [   2              - t ]
                         [ (t  + 2 t + 2) %e    ]
                         [ -------------------- ]
                         [          2           ]
                         [                      ]
                         [         2   - t      ]
          (%o4)  Col 1 = [        t  %e         ]
                         [      - --------      ]
                         [           2          ]
                         [                      ]
                         [     2          - t   ]
                         [   (t  - 2 t) %e      ]
                         [   ----------------   ]
                         [          2           ]
                   [      2        - t    ]
                   [    (t  + t) %e       ]
                   [                      ]
           Col 2 = [     2            - t ]
                   [ - (t  - t - 1) %e    ]
                   [                      ]
                   [     2          - t   ]
                   [   (t  - 3 t) %e      ]
                   [        2   - t       ]
                   [       t  %e          ]
                   [       --------       ]
                   [          2           ]
                   [                      ]
                   [      2          - t  ]
           Col 3 = [    (t  - 2 t) %e     ]
                   [  - ----------------  ]
                   [           2          ]
                   [                      ]
                   [   2              - t ]
                   [ (t  - 4 t + 2) %e    ]
                   [ -------------------- ]
                   [          2           ]

     Ejemplo 2:
          (%i5) b1:matrix([0,0,1,1,1],
                          [0,0,0,1,1],
                          [0,0,0,0,1],
                          [0,0,0,0,0],
                          [0,0,0,0,0])$

          (%i6) mat_function(exp,t*b1);
                            [              2     ]
                            [             t      ]
                            [ 1  0  t  t  -- + t ]
                            [             2      ]
                            [                    ]
          (%o6)             [ 0  1  0  t    t    ]
                            [                    ]
                            [ 0  0  1  0    t    ]
                            [                    ]
                            [ 0  0  0  1    0    ]
                            [                    ]
                            [ 0  0  0  0    1    ]
          (%i7) minimalPoly(jordan(b1));
                                       3
          (%o7)                       x
          (%i8) ident(5)+t*b1+1/2*(t^2)*b1^^2;
                            [              2     ]
                            [             t      ]
                            [ 1  0  t  t  -- + t ]
                            [             2      ]
                            [                    ]
          (%o8)             [ 0  1  0  t    t    ]
                            [                    ]
                            [ 0  0  1  0    t    ]
                            [                    ]
                            [ 0  0  0  1    0    ]
                            [                    ]
                            [ 0  0  0  0    1    ]
          (%i9) mat_function(exp,%i*t*b1);
                       [                           2 ]
                       [                          t  ]
                       [ 1  0  %i t  %i t  %i t - -- ]
                       [                          2  ]
                       [                             ]
          (%o9)        [ 0  1   0    %i t    %i t    ]
                       [                             ]
                       [ 0  0   1     0      %i t    ]
                       [                             ]
                       [ 0  0   0     1        0     ]
                       [                             ]
                       [ 0  0   0     0        1     ]
          (%i10) mat_function(cos,t*b1)+%i*mat_function(sin,t*b1);
                        [                           2 ]
                        [                          t  ]
                        [ 1  0  %i t  %i t  %i t - -- ]
                        [                          2  ]
                        [                             ]
          (%o10)        [ 0  1   0    %i t    %i t    ]
                        [                             ]
                        [ 0  0   1     0      %i t    ]
                        [                             ]
                        [ 0  0   0     1        0     ]
                        [                             ]
                        [ 0  0   0     0        1     ]

     Ejemplo 3:
          (%i11) a1:matrix([2,1,0,0,0,0],
                           [-1,4,0,0,0,0],
                           [-1,1,2,1,0,0],
                           [-1,1,-1,4,0,0],
                           [-1,1,-1,1,3,0],
                           [-1,1,-1,1,1,2])$

          (%i12) fpow(x):=block([k],declare(k,integer),x^k)$

          (%i13) mat_function(fpow,a1);
                          [  k      k - 1 ]         [      k - 1    ]
                          [ 3  - k 3      ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [  k      k - 1 ]
                          [  - k 3        ]         [ 3  + k 3      ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
          (%o13)  Col 1 = [               ] Col 2 = [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                   [       0       ]         [       0       ]
                   [               ]         [               ]
                   [       0       ]         [       0       ]
                   [               ]         [               ]
                   [  k      k - 1 ]         [      k - 1    ]
                   [ 3  - k 3      ]         [   k 3         ]
                   [               ]         [               ]
           Col 3 = [       k - 1   ] Col 4 = [  k      k - 1 ]
                   [  - k 3        ]         [ 3  + k 3      ]
                   [               ]         [               ]
                   [       k - 1   ]         [      k - 1    ]
                   [  - k 3        ]         [   k 3         ]
                   [               ]         [               ]
                   [       k - 1   ]         [      k - 1    ]
                   [  - k 3        ]         [   k 3         ]
                   [    0    ]
                   [         ]         [ 0  ]
                   [    0    ]         [    ]
                   [         ]         [ 0  ]
                   [    0    ]         [    ]
                   [         ]         [ 0  ]
           Col 5 = [    0    ] Col 6 = [    ]
                   [         ]         [ 0  ]
                   [    k    ]         [    ]
                   [   3     ]         [ 0  ]
                   [         ]         [    ]
                   [  k    k ]         [  k ]
                   [ 3  - 2  ]         [ 2  ]

     Antes de hacer uso de esta función ejecútese  `load("diag")'.


File: maxima.info,  Node: distrib,  Next: draw,  Prev: diag,  Up: Top

47 distrib
**********

* Menu:

* Introducción a distrib::
* Funciones y variables para distribuciones continuas::
* Funciones y variables para distribuciones discretas::


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

47.1 Introducción a distrib
===========================

El paquete `distrib' contiene un conjunto de funciones para la
realización de cálculos probabilísticos con modelos univariantes, tanto
discretos como continuos.

   A continuación un breve recordatorio de las deficiones básicas sobre
distribuciones de probabilidad.

   Sea f(x) la <función de densidad> de una variable aleatoria X
absolutamente continua. La <función de distribución> se define como
                            x
                           /
                           [
                    F(x) = I     f(u) du
                           ]
                           /
                            minf
   que es igual a la probabilidad <Pr(X <= x)>.

   La <media> es un parámetro de localización y se define como
                          inf
                         /
                         [
                E[X]  =  I   x f(x) dx
                         ]
                         /
                          minf

   La  <varianza> es una medida de dispersión,
                      inf
                     /
                     [                    2
              V[X] = I     f(x) (x - E[X])  dx
                     ]
                     /
                      minf
   que es un número real positivo. La raíz cuadrada de la varianza es
la <desviación típica>, D[X]=sqrt(V[X]), siendo otra medida de
dispersión.

   El <coeficiente de asimetría> es una medida de forma,
                      inf
                     /
                 1   [                    3
       SK[X] = ----- I     f(x) (x - E[X])  dx
                   3 ]
               D[X]  /
                      minf

   Y el <coeficiente de curtosis> mide el apuntamiento de la densidad,
                      inf
                     /
                 1   [                    4
       KU[X] = ----- I     f(x) (x - E[X])  dx - 3
                   4 ]
               D[X]  /
                      minf
   Si X es normal, KU[X]=0. De hecho, tanto la asimetría como la
curtosis son parámetros de forma para medir la no normalidad de una
distribución.

   Si la variable aleatoria X es discreta, su función de densidad, o de
<probabiliad>,  f(x) toma valores positivos dentro de un conjunto
numerable de valores x_i, y cero en cualquier otro lugar. En este caso,
la función de distribución es
                            ====
                            \
                     F(x) =  >    f(x )
                            /        i
                            ====
                           x <= x
                            i

   La media, varianza, desviación típica y los coeficientes de
asimetría y curtosis adquieren las formas
                            ====
                            \
                     E[X] =  >  x  f(x ) ,
                            /    i    i
                            ====
                             x
                              i

                     ====
                     \                     2
             V[X] =   >    f(x ) (x - E[X])  ,
                     /        i    i
                     ====
                      x
                       i

                    D[X] = sqrt(V[X]),

                          ====
                   1      \                     3
       SK[X] =  -------    >    f(x ) (x - E[X])
                D[X]^3    /        i    i
                          ====
                           x
                            i
   y
                          ====
                   1      \                     4
       KU[X] =  -------    >    f(x ) (x - E[X])   - 3 ,
                D[X]^4    /        i    i
                          ====
                           x
                            i
   respectivamente.

   El paquete `distrib' incluye funciones para la simulación de
variables aleatorias. Algunas de estas funciones hacen uso de variables
opcionales que indican el algoritmo a ejecutar. El método general de
inversión (basado en el hecho de que si <u> es un número aleatorio
generado uniformemente en (0,1), entonces <F^(-1)(u)> es una variable
aleatoria con distribución F) está implementado en la mayoría de los
casos, aunque se trate de una técnica subóptima en términos de tiempo,
pero útil para compararla con otros algoritmos. En el siguiente ejemplo
se compara mediante histogramas el comportamiento de los algoritmos
`ahrens_cheng' y `inverse' para la simulación de variables chi-cuadrada:

     (%i1) load(distrib)$
     (%i2) load(descriptive)$
     (%i3) showtime: true$
     Evaluation took 0.00 seconds (0.00 elapsed) using 32 bytes.
     (%i4) random_chi2_algorithm: 'ahrens_cheng$
           histogram(random_chi2(10,500))$
     Evaluation took 0.00 seconds (0.00 elapsed) using 40 bytes.
     Evaluation took 0.69 seconds (0.71 elapsed) using 5.694 MB.
     (%i6) random_chi2_algorithm: 'inverse$ histogram(random_chi2(10,500))$
     Evaluation took 0.00 seconds (0.00 elapsed) using 32 bytes.
     Evaluation took 10.15 seconds (10.17 elapsed) using 322.098 MB.

   A fin de hacer comparaciones visuales entre algoritmos para
variables discretas, se debería utilizar la función `barsplot' del
paquete `descriptive'.

   Nótese que aún queda trabajo por hacer, puesto que estas funciones
de simulación todavía no se han puesto a prueba con tests de bondad de
ajuste más rigurosos.

   Por favor, consúltese cualquier manual introductorio de probabilidad
y estadística para más información sobre toda esta parafernalia
matemática.

   Se sigue cierta convención a la hora de nombrar las funciones del
paquete `distrib'. Cada nombre tiene dos partes, el primero hace
referencia a la función o parámetro que se quiere calcular,
     Funciones:
        Función de densidad        (pdf_*)
        Función de distribución    (cdf_*)
        Cuantil                    (quantile_*)
        Media                      (mean_*)
        Varianza                   (var_*)
        Desviación típica          (std_*)
        Coeficiente de asimetría   (skewness_*)
        Coeficiente de curtosis    (kurtosis_*)
        Valor aleatorio            (random_*)

   La segunda parte hace referencia explícita al modelo probabilístico,
     Distribuciones continuas:
        Normal              (*normal)
        Student             (*student_t)
        Chi^2               (*chi2)
        F                   (*f)
        Exponencial         (*exp)
        Lognormal           (*lognormal)
        Gamma               (*gamma)
        Beta                (*beta)
        Continua uniforme   (*continuous_uniform)
        Logística           (*logistic)
        Pareto              (*pareto)
        Weibull             (*weibull)
        Rayleigh            (*rayleigh)
        Laplace             (*laplace)
        Cauchy              (*cauchy)
        Gumbel              (*gumbel)

     Distribuciones discretas:
        Binomial             (*binomial)
        Poisson              (*poisson)
        Bernoulli            (*bernoulli)
        Geométrica           (*geometric)
        Uniforme discreta    (*discrete_uniform)
        Hipergeométrica      (*hypergeometric)
        Binomial negativa    (*negative_binomial)

   Por ejemplo, `pdf_student_t(x,n)' es la función de densidad de la
distribución de Student con <n> grados de libertad, `std_pareto(a,b)'
es la desviación típica de la distribución de Pareto de parámetros <a>
y <b>, y `kurtosis_poisson(m)' es el coeficiente de curtosis de la
distribución de Poisson de media <m>.

   Para poder hacer uso del paquete `distrib' es necesario cargarlo
primero tecleando
     (%i1) load(distrib)$

   Para comentarios, errores o sugerencias, por favor contáctese
conmigo en <'mario ARROBA edu PUNTO xunta PUNTO es'>.


File: maxima.info,  Node: Funciones y variables para distribuciones continuas,  Next: Funciones y variables para distribuciones discretas,  Prev: Introducción a distrib,  Up: distrib

47.2 Funciones y variables para distribuciones continuas
========================================================

 -- Función: pdf_normal (<x>,<m>,<s>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de la variable aleatoria Normal(m,s), con s>0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_normal (<x>,<m>,<s>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de la variable aleatoria Normal(m,s), con s>0. Esta
     función se define en términos de la función de error,  `erf', de
     Maxima.

          (%i1) load (distrib)$
          (%i2) assume(s>0)$ cdf_normal(x,m,s);
                                       x - m
                                 erf(---------)
                                     sqrt(2) s    1
          (%o3)                  -------------- + -
                                       2          2

     Véase también `erf'.

 -- Función: quantile_normal (<q>,<m>,<s>)
     Devuelve el <q>-cuantil de una variable aleatoria Normal(m,s), con
     s>0; en otras palabras, es la inversa de  `cdf_normal'. El
     argumento <q> debe ser un número de [0,1]. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: mean_normal (<m>,<s>)
     Devuelve la media de  una variable aleatoria Normal(m,s), con s>0,
     es decir <m>. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_normal (<m>,<s>)
     Devuelve la varianza de  una variable aleatoria Normal(m,s), con
     s>0, es decir <s^2>.

 -- Función: std_normal (<m>,<s>)
     Devuelve la desviación típica de  una variable aleatoria
     Normal(m,s), con s>0, es decir <s>. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: skewness_normal (<m>,<s>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Normal(m,s), con s>0, que es siempre igual a 0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: kurtosis_normal (<m>,<s>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     Normal(m,s), con s>0, que es siempre igual a 0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Variable opcional: random_normal_algorithm
     Valor por defecto: `box_mueller'

     Este es el algoritmo seleccionado para simular variables
     aleatorias normales. Los algoritmos implementados son
     `box_mueller' y `inverse':
        * `box_mueller', basado en el algoritmo descrito en Knuth, D.E.
          (1981) <Seminumerical Algorithms. The Art of Computer
          Programming.> Addison-Wesley.

        * `inverse', basado en el método inverso.

     Véase también `random_normal'.

 -- Función: random_normal (<m>,<s>)
 -- Función: random_normal (<m>,<s>,<n>)
     Devuelve un valor aleatorio  Normal(m,s), con s>0. Llamando a
     `random_normal' con un tercer argumento <n>, se simula una muestra
     aleatoria de tamaño <n>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_normal_algorithm', cuyo valor por defecto
     es `box_mueller'.

     Véanse también `random_normal_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_student_t (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Student t(n), con n>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_student_t_t (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Student t(n), con n>0.
     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal.

          (%i1) load (distrib)$
          (%i2) cdf_student_t(1/2, 7/3);
                                               1  7
          (%o2)                  cdf_student_t(-, -)
                                               2  3
          (%i3) %,numer;
          (%o3)                   .6698450596140417

 -- Función: quantile_student_t (<q>,<n>)
     Devuelve el <q>-cuantil de una variable aleatoria de Student t(n),
     con n>0; en otras palabras, se trata de la inversa de
     `cdf_student_t'. El argumento <q> debe ser un número de [0,1].
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_student_t (<n>)
     Devuelve la media de una variable aleatoria de Student t(n), con
     n>0, que vale siempre 0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: var_student_t (<n>)
     Devuelve la varianza de una variable aleatoria de Student t(n),
     con n>2.

          (%i1) load (distrib)$
          (%i2) assume(n>2)$  var_student_t(n);
                                          n
          (%o3)                         -----
                                        n - 2

 -- Función: std_student_t (<n>)
     Devuelve la desviación típica de una variable aleatoria de Student
     t(n), con n>2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: skewness_student_t (<n>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Student t(n), con n>3, que vale siempre 0. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: kurtosis_student_t (<n>)
     Devuelve el coeficiente de curtosis una variable aleatoria de
     Student t(n), con n>4. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Variable opcional: random_student_t_algorithm
     Valor por defecto: `ratio'

     Es el algoritmo seleccionado para simular variables aleatorias de
     Student. Los métodos implementados son `inverse' y `ratio':
        * `inverse', basado en el método inverso.

        * `ratio', basado en el hecho de que si <Z> es una variable
          aleatoria normal N(0,1) y S^2 es una variable aleatoria chi
          cuadrada con <n> grados de libertad, Chi^2(n), entonces
                                          Z
                                X = -------------
                                    /   2  \ 1/2
                                    |  S   |
                                    | ---  |
                                    \  n   /
          es una variable aleatoria de Student con <n> grados de
          libertad, t(n).

     Véase también `random_student_t'.

 -- Función: random_student_t (<n>)
 -- Función: random_student_t (<n>,<m>)
     Devuelve un valor aleatorio t(n), con n>0. Llamando a
     `random_student_t' con un segundo argumento <m>, se obtiene una
     muestra aleatoria simulada de tamaño <m>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_student_t_algorithm', cuyo valor por
     defecto es `ratio'.

     Véase también `random_student_t_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_chi2 (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria chi-cuadrado Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en la función de
     densidad de la gamma.

          (%i1) load (distrib)$
          (%i2) pdf_chi2(x,n);
                                              n
          (%o2)                  pdf_gamma(x, -, 2)
                                              2
          (%i3) assume(x>0, n>0)$  pdf_chi2(x,n);
                                   n/2 - 1   - x/2
                                  x        %e
          (%o4)                   ----------------
                                    n/2       n
                                   2    gamma(-)
                                              2

 -- Función: cdf_chi2 (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria chi-cuadrado Chi^2(n), con
     n>0.

     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal basada en la distribución
     gamma, puesto que la variable aleatoria Chi^2(n) equivale a una
     Gamma(n/2,2).

          (%i1) load (distrib)$
          (%i2) cdf_chi2(3,4);
          (%o2)                  cdf_gamma(3, 2, 2)
          (%i3) cdf_chi2(3,4),numer;
          (%o3)                   .4421745996289249

 -- Función: quantile_chi2 (<q>,<n>)
     Devuelve el <q>-cuantil de una variable aleatoria Chi^2(n), con
     n>0; en otras palabras, se trata de la inversa de  `cdf_chi2'. El
     argumento <q> debe ser un número de [0,1].

     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal basada en la función cuantil
     de la gamma, puesto que la variable aleatoria Chi^2(n) equivale a
     una Gamma(n/2,2).

          (%i1) load (distrib)$
          (%i2) quantile_chi2(0.99,9);
          (%o2)                   21.66599433346194
          (%i3) quantile_chi2(0.99,n);
                                                  n
          (%o3)              quantile_gamma(0.99, -, 2)
                                                  2

 -- Función: mean_chi2 (<n>)
     Devuelve la media de  una variable aleatoria  Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en la media de la
     gamma.

          (%i1) load (distrib)$
          (%i2) mean_chi2(n);
                                             n
          (%o2)                   mean_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ mean_chi2(n);
          (%o4)                           n

 -- Función: var_chi2 (<n>)
     Devuelve la varianza de  una variable aleatoria  Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en la varianza de la
     gamma.

          (%i1) load (distrib)$
          (%i2) var_chi2(n);
                                             n
          (%o2)                    var_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ var_chi2(n);
          (%o4)                          2 n

 -- Función: std_chi2 (<n>)
     Devuelve la desviación típica de  una variable aleatoria
     Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en la desviación
     típica de la gamma.

          (%i1) load (distrib)$
          (%i2) std_chi2(n);
                                             n
          (%o2)                    std_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ std_chi2(n);
          (%o4)                    sqrt(2) sqrt(n)

 -- Función: skewness_chi2 (<n>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en el coeficiente de
     asimetría de la gamma.

          (%i1) load (distrib)$
          (%i2) skewness_chi2(n);
                                               n
          (%o2)                 skewness_gamma(-, 2)
                                               2
          (%i3) assume(n>0)$ skewness_chi2(n);
                                      2 sqrt(2)
          (%o4)                       ---------
                                       sqrt(n)

 -- Función: kurtosis_chi2 (<n>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Chi^2(n), con n>0.

     La variable aleatoria Chi^2(n) equivale a una Gamma(n/2,2), por lo
     que cuando Maxima no tiene suficiente información para obtener el
     resultado, devuelve una forma nominal basada en el coeficiente de
     curtosis de la gamma.

          (%i1) load (distrib)$
          (%i2) kurtosis_chi2(n);
                                               n
          (%o2)                 kurtosis_gamma(-, 2)
                                               2
          (%i3) assume(n>0)$ kurtosis_chi2(n);
                                         12
          (%o4)                          --
                                         n

 -- Variable opcional: random_chi2_algorithm
     Valor por defecto: `ahrens_cheng'

     Es el algoritmo seleccionado para simular variables aleatorias
     chi-cuadrado. Los métodos implementados son `ahrens_cheng' y
     `inverse':

        * `ahrens_cheng', basado en la simulación aleatoria de
          variables gamma. Véase `random_gamma_algorithm' para más
          detalles.

        * `inverse', basado en el método inverso.


     Véase también `random_chi2'.

 -- Función: random_chi2 (<n>)
 -- Función: random_chi2 (<n>,<m>)
     Devuelve un valor aleatorio  Chi^2(n), con n>0. Llamando a
     `random_chi2' con un segundo argumento <m>, se simulará una
     muestra aleatoria de tamaño <m>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_chi2_algorithm', cuyo valor por defecto es
     `ahrens_cheng'.

     Véase también `random_chi2_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_f (<x>,<m>,<n>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria  F(m,n), con m,n>0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_f (<x>,<m>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria  F(m,n), con m,n>0.

     Esta función no tiene expresión compacta, por lo que es evaluada
     numéricamente si la variable global `numer' vale `true', en caso
     contrario devuelve una forma nominal.

          (%i1) load (distrib)$
          (%i2) cdf_f(2,3,9/4);
                                               9
          (%o2)                    cdf_f(2, 3, -)
                                               4
          (%i3) %,numer;
          (%o3)                   0.66756728179008

 -- Función: quantile_f (<q>,<m>,<n>)
     Devuelve el <q>-cuantil de una variable aleatoria  F(m,n), con
     m,n>0; en otras palabras, se trata de la inversa de  `cdf_f'. El
     argumento <q> debe ser un número de [0,1].

     Esta función no tiene expresión compacta, por lo que es evaluada
     numéricamente si la variable global `numer' vale `true', en caso
     contrario devuelve una forma nominal.

          (%i1) load (distrib)$
          (%i2) quantile_f(2/5,sqrt(3),5);
                                         2
          (%o2)               quantile_f(-, sqrt(3), 5)
                                         5
          (%i3) %,numer;
          (%o3)                   0.518947838573693

 -- Función: mean_f (<m>,<n>)
     Devuelve la media de  una variable aleatoria  F(m,n), con m>0,
     n>2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_f (<m>,<n>)
     Devuelve la varianza de  una variable aleatoria  F(m,n), con m>0,
     n>4. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_f (<m>,<n>)
     Devuelve la desviación típica de  una variable aleatoria  F(m,n),
     con m>0, n>4. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: skewness_f (<m>,<n>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     F(m,n), con m>0, n>6. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_f (<m>,<n>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     F(m,n), con m>0, n>8. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Variable opcional: random_f_algorithm
     Valor por defecto: `inverse'

     Es el algoritmo seleccionado para simular variables aleatorias F.
     Los algoritmos programados son `ratio' y `inverse':
        * `ratio', basado en el hecho de que si <X> es una variable
          aleatoria Chi^2(m) y Y es una Chi^2(n), entonces
                                       n X
                                   F = ---
                                       m Y
          es una variable aleatoria F con <m> y <n> grados de libertad,
          F(m,n).

        * `inverse', basado en el método inverso.


     Véase también `random_f'.

 -- Función: random_f (<m>,<n>)
 -- Función: random_f (<m>,<n>,<k>)
     Devuelve un valor aleatorio  F(m,n), con m,n>0. Llamando a
     `random_f' con un tercer argumento <k>, se simulará una muestra
     aleatoria de tamaño <k>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_f_algorithm', cuyo valor por defecto es
     `inverse'.

     Véase también `random_f_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_exp (<x>,<m>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria Exponencial(m), con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en la densidad de Weibull.

          (%i1) load (distrib)$
          (%i2) pdf_exp(x,m);
                                                  1
          (%o2)                 pdf_weibull(x, 1, -)
                                                  m
          (%i3) assume(x>0,m>0)$  pdf_exp(x,m);
                                          - m x
          (%o4)                       m %e

 -- Función: cdf_exp (<x>,<m>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Exponencial(m), con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en la distribución de Weibull.

          (%i1) load (distrib)$
          (%i2) cdf_exp(x,m);
                                                  1
          (%o2)                 cdf_weibull(x, 1, -)
                                                  m
          (%i3) assume(x>0,m>0)$  cdf_exp(x,m);
                                           - m x
          (%o4)                      1 - %e

 -- Función: quantile_exp (<q>,<m>)
     Devuelve el <q>-cuantil de una variable aleatoria Exponencial(m),
     con m>0; en otras palabras, se trata de la inversa de  `cdf_exp'.
     El argumento <q> debe ser un número de [0,1].

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en el cuantil de la Weibull.

          (%i1) load (distrib)$
          (%i2) quantile_exp(0.56,5);
          (%o2)                   .1641961104139661
          (%i3) quantile_exp(0.56,m);
                                                      1
          (%o3)             quantile_weibull(0.56, 1, -)
                                                      m

 -- Función: mean_exp (<m>)
     Devuelve la media de  una variable aleatoria Exponencial(m), con
     m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en la media de la Weibull.

          (%i1) load (distrib)$
          (%i2) mean_exp(m);
                                                 1
          (%o2)                  mean_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  mean_exp(m);
                                          1
          (%o4)                           -
                                          m

 -- Función: var_exp (<m>)
     Devuelve la varianza de  una variable aleatoria Exponencial(m),
     con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en la varianza de la Weibull.

          (%i1) load (distrib)$
          (%i2) var_exp(m);
                                                 1
          (%o2)                   var_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  var_exp(m);
                                         1
          (%o4)                          --
                                          2
                                         m

 -- Función: std_exp (<m>)
     Devuelve la desviación típica de  una variable aleatoria
     Exponencial(m), con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en la desviación típica de la Weibull.

          (%i1) load (distrib)$
          (%i2) std_exp(m);
                                                 1
          (%o2)                   std_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  std_exp(m);
                                          1
          (%o4)                           -
                                          m

 -- Función: skewness_exp (<m>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Exponencial(m), con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en el coeficiente de asimetría de la Weibull.

          (%i1) load (distrib)$
          (%i2) skewness_exp(m);
                                                   1
          (%o2)                skewness_weibull(1, -)
                                                   m
          (%i3) assume(m>0)$  skewness_exp(m);
          (%o4)                           2

 -- Función: kurtosis_exp (<m>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Exponencial(m), con m>0.

     La variable aleatoria Exponencial(m) equivale a una
     Weibull(1,1/m), por lo que si Maxima no tiene suficiente
     información para calcular el resultado, devolverá una forma
     nominal basada en el coeficiente de curtosis de la Weibull.

          (%i1) load (distrib)$
          (%i2) kurtosis_exp(m);
                                                   1
          (%o2)                kurtosis_weibull(1, -)
                                                   m
          (%i3) assume(m>0)$  kurtosis_exp(m);
          (%o4)                           6

 -- Variable opcional: random_exp_algorithm
     Valor por defecto: `inverse'

     Es el algoritmo seleccionado para simular variables aleatoria
     exponenciales. Los algoritmos programados son `inverse',
     `ahrens_cheng' y `ahrens_dieter'
        * `inverse', basado en el método inverso.

        * `ahrens_cheng', basado en el hecho de que la variable
          aleatoria Exponencial(m) equivale a una Gamma(1,1/m). Véase
          `random_gamma_algorithm' para más detalles.

        * `ahrens_dieter', basada en el algoritmo descrito en Ahrens,
          J.H. y Dieter, U. (1972) <Computer methods for sampling from
          the exponential and normal distributions>. Comm, ACM, 15,
          Oct.,  873-882.


     Véase también `random_exp'.

 -- Función: random_exp (<m>)
 -- Función: random_exp (<m>,<k>)
     Devuelve un valor aleatorio  Exponencial(m), con m>0. Llamando a
     `random_exp2' con un segundo argumento <k>, se simulará una
     muestra aleatoria de tamaño <k>.

     Hay tres algoritmos programados para esta función, el que se vaya
     a utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_exp_algorithm', cuyo valor por defecto es
     `inverse'.

     Véase también `random_exp_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_lognormal (<x>,<m>,<s>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria Lognormal(m,s), con s>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_lognormal (<x>,<m>,<s>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Lognormal(m,s), con s>0.
     Esta función se define en términos de la función de error, `erf',
     de Maxima.

          (%i1) load (distrib)$
          (%i2) assume(x>0, s>0)$  cdf_lognormal(x,m,s);
                                     log(x) - m
                                 erf(----------)
                                     sqrt(2) s     1
          (%o3)                  --------------- + -
                                        2          2

     Véase también `erf'.

 -- Función: quantile_lognormal (<q>,<m>,<s>)
     Devuelve el <q>-cuantil de una variable aleatoria Lognormal(m,s),
     con s>0; en otras palabras, se trata de la inversa de
     `cdf_lognormal'. El argumento <q> debe ser un número de [0,1].
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_lognormal (<m>,<s>)
     Devuelve la media de  una variable aleatoria Lognormal(m,s), con
     s>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_lognormal (<m>,<s>)
     Devuelve la varianza de  una variable aleatoria Lognormal(m,s),
     con s>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_lognormal (<m>,<s>)
     Devuelve la desviación típica de  una variable aleatoria
     Lognormal(m,s), con s>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_lognormal (<m>,<s>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Lognormal(m,s), con s>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_lognormal (<m>,<s>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Lognormal(m,s), con s>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: random_lognormal (<m>,<s>)
 -- Función: random_lognormal (<m>,<s>,<n>)
     Devuelve un valor aleatorio  Lognormal(m,s), con s>0. Llamando a
     `random_lognormal' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño <n>.

     Las variables lognormales se simulan mediante variables normales.
     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_normal_algorithm', cuyo valor por defecto
     es `box_mueller'.

     Véase también `random_normal_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_gamma (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria Gamma(a,b), con a,b>0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_gamma (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Gamma(a,b), con a,b>0.

     Esta función no tiene expresión compacta, por lo que es evaluada
     numéricamente si la variable global `numer' vale `true', en caso
     contrario devuelve una forma nominal.

          (%i1) load (distrib)$
          (%i2) cdf_gamma(3,5,21);
          (%o2)                  cdf_gamma(3, 5, 21)
          (%i3) %,numer;
          (%o3)                 4.402663157135039E-7

 -- Función: quantile_gamma (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria Gamma(a,b), con
     a,b>0; en otras palabras, se trata de la inversa de  `cdf_gamma'.
     El argumento <q> debe ser un número de [0,1]. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_gamma (<a>,<b>)
     Devuelve la media de  una variable aleatoria Gamma(a,b), con
     a,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_gamma (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria Gamma(a,b), con
     a,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_gamma (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria
     Gamma(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_gamma (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Gamma(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_gamma (<a>,<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Gamma(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Variable opcional: random_gamma_algorithm
     Valor por defecto: `ahrens_cheng'

     Es el algoritmo seleccionado para simular variables aleatorias
     gamma. Algoritmos programados son `ahrens_cheng' y `inverse'
        * `ahrens_cheng', se trata de una combinación de dos
          procedimientos, según sea el valor del parámetro <a>:

          Para a>=1, Cheng, R.C.H. y Feast, G.M. (1979). <Some simple
          gamma variate generators>. Appl. Stat., 28, 3, 290-295.

          Para 0<a<1, Ahrens, J.H. y Dieter, U. (1974). <Computer
          methods for sampling from gamma, beta, poisson and binomial
          distributions>. Computing, 12, 223-246.

        * `inverse', basado en el método inverso.


     Véase también `random_gamma'.

 -- Función: random_gamma (<a>,<b>)
 -- Función: random_gamma (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Gamma(a,b), con a,b>0. Llamando a
     `random_gamma' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño <n>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_gamma_algorithm', cuyo valor por defecto
     es `ahrens_cheng'.

     Véase también `random_gamma_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_beta (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria Beta(a,b), con a,b>0. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_beta (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Beta(a,b), con a,b>0.

     Esta función no tiene expresión compacta, por lo que es evaluada
     numéricamente si la variable global `numer' vale `true', en caso
     contrario devuelve una forma nominal.

          (%i1) load (distrib)$
          (%i2) cdf_beta(1/3,15,2);
                                           1
          (%o2)                   cdf_beta(-, 15, 2)
                                           3
          (%i3) %,numer;
          (%o3)                 7.666089131388224E-7

 -- Función: quantile_beta (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria Beta(a,b), con
     a,b>0; en otras palabras, se trata de la inversa de  `cdf_beta'.
     El argumento <q> debe ser un número de [0,1]. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_beta (<a>,<b>)
     Devuelve la media de  una variable aleatoria Beta(a,b), con a,b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: var_beta (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria Beta(a,b), con
     a,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_beta (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria
     Beta(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_beta (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Beta(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_beta (<a>,<b>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     Beta(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Variable opcional: random_beta_algorithm
     Valor por defecto: `cheng'

     Es el algoritmo seleccionado para simular variables aleatorias
     beta. Algoritmos programados son `cheng', `inverse' y `ratio'
        * `cheng', es el algoritmo definido en Cheng, R.C.H.  (1978).
          <Generating Beta Variates with Nonintegral Shape Parameters>.
          Communications of the ACM, 21:317-322

        * `inverse', basado en el método inverso.

        * `ratio', basado en el hecho de que si <X> es una variable
          aleatoria Gamma(a,1) y <Y> es una Gamma(b,1), entonces el
          cociente X/(X+Y) se distribuye como una Beta(a,b).


     Véase también `random_beta'.

 -- Función: random_beta (<a>,<b>)
 -- Función: random_beta (<a>,<b>,<n>)
     Devuelve un valor aleatorio Beta(a,b), con a,b>0. Llamando a
     `random_beta' con un tercer argumento <n>, se simulará una muestra
     aleatoria de tamaño  <n>.

     Hay tres algoritmos programados para esta función, el que se vaya
     a utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_beta_algorithm', cuyo valor por defecto es
     `cheng'.

     Véase también `random_beta_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_continuous_uniform (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria  Uniforme Continua(a,b), con a<b. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_continuous_uniform (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria  Uniforme Continua(a,b),
     con a<b. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: quantile_continuous_uniform (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria  Uniforme
     Continua(a,b), con a<b; en otras palabras, se trata de la inversa
     de  `cdf_continuous_uniform'. El argumento <q> debe ser un número
     de [0,1]. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: mean_continuous_uniform (<a>,<b>)
     Devuelve la media de  una variable aleatoria  Uniforme
     Continua(a,b), con a<b. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: var_continuous_uniform (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria  Uniforme
     Continua(a,b), con a<b. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: std_continuous_uniform (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria  Uniforme
     Continua(a,b), con a<b. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_continuous_uniform (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Uniforme Continua(a,b), con a<b. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: kurtosis_continuous_uniform (<a>,<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Uniforme Continua(a,b), con a<b. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: random_continuous_uniform (<a>,<b>)
 -- Función: random_continuous_uniform (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Uniforme Continuo(a,b), con a<b.
     Llamando a `random_continuous_uniform' con un tercer argumento
     <n>, se simulará una muestra aleatoria de tamaño  <n>.

     Esta función es una aplicación directa de la función  `random' de
     Maxima.

     Véase también `random'. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: pdf_logistic (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria Logística(a,b), con b>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_logistic (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Logística(a,b), con b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_logistic (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria Logística(a,b),
     con b>0; en otras palabras, se trata de la inversa de
     `cdf_logistic'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_logistic (<a>,<b>)
     Devuelve la media de  una variable aleatoria Logística(a,b), con
     b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_logistic (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria Logística(a,b),
     con b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_logistic (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria
     Logística(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_logistic (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Logística(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_logistic (<a>,<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     Logística(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: random_logistic (<a>,<b>)
 -- Función: random_logistic (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Logístico(a,b), con b>0. Llamando a
     `random_logistic' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_pareto (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Pareto(a,b), con a,b>0. Para hacer
     uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_pareto (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Pareto(a,b), con a,b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_pareto (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Pareto(a,b),
     con a,b>0; en otras palabras, se trata de la inversa de
     `cdf_pareto'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_pareto (<a>,<b>)
     Devuelve la media de  una variable aleatoria de Pareto(a,b), con
     a>1,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_pareto (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria de Pareto(a,b),
     con a>2,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_pareto (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria de
     Pareto(a,b), con a>2,b>0. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: skewness_pareto (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Pareto(a,b), con a>3,b>0. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: kurtosis_pareto (<a>,<b>)
     Devuelve el coeficiente de curtosis de una variable aleatoria de
     Pareto(a,b), con a>4,b>0. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: random_pareto (<a>,<b>)
 -- Función: random_pareto (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Pareto(a,b), con a>0,b>0. Llamando a
     `random_pareto' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_weibull (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Weibull(a,b), con a,b>0. Para hacer
     uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_weibull (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Weibull(a,b), con a,b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_weibull (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Weibull(a,b),
     con a,b>0; en otras palabras, se trata de la inversa de
     `cdf_weibull'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_weibull (<a>,<b>)
     Devuelve la media de  una variable aleatoria de Weibull(a,b), con
     a,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_weibull (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria de Weibull(a,b),
     con a,b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_weibull (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria de
     Weibull(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_weibull (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Weibull(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_weibull (<a>,<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria de
     Weibull(a,b), con a,b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: random_weibull (<a>,<b>)
 -- Función: random_weibull (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Weibull(a,b), con a,b>0. Llamando a
     `random_weibull' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_rayleigh (<x>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Rayleigh(b), con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la densidad de
     la Weibull.

          (%i1) load (distrib)$
          (%i2) pdf_rayleigh(x,b);
                                                  1
          (%o2)                 pdf_weibull(x, 2, -)
                                                  b
          (%i3) assume(x>0,b>0)$ pdf_rayleigh(x,b);
                                              2  2
                                     2     - b  x
          (%o4)                   2 b  x %e

 -- Función: cdf_rayleigh (<x>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Rayleigh(b), con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la
     distribución de la Weibull.

          (%i1) load (distrib)$
          (%i2) cdf_rayleigh(x,b);
                                                  1
          (%o2)                 cdf_weibull(x, 2, -)
                                                  b
          (%i3) assume(x>0,b>0)$ cdf_rayleigh(x,b);
                                             2  2
                                          - b  x
          (%o4)                     1 - %e

 -- Función: quantile_rayleigh (<q>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Rayleigh(b),
     con b>0; en otras palabras, se trata de la inversa de
     `cdf_rayleigh'. El argumento <q> debe ser un número de [0,1].

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en los cuantiles
     de la Weibull.

          (%i1) load (distrib)$
          (%i2) quantile_rayleigh(0.99,b);
                                                      1
          (%o2)             quantile_weibull(0.99, 2, -)
                                                      b
          (%i3) assume(x>0,b>0)$ quantile_rayleigh(0.99,b);
                                  2.145966026289347
          (%o4)                   -----------------
                                          b

 -- Función: mean_rayleigh (<b>)
     Devuelve la media de  una variable aleatoria de Rayleigh(b), con
     b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la media de la
     Weibull.

          (%i1) load (distrib)$
          (%i2) mean_rayleigh(b);
                                                 1
          (%o2)                  mean_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ mean_rayleigh(b);
                                      sqrt(%pi)
          (%o4)                       ---------
                                         2 b

 -- Función: var_rayleigh (<b>)
     Devuelve la varianza de  una variable aleatoria de Rayleigh(b),
     con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la varianza de
     la Weibull.

          (%i1) load (distrib)$
          (%i2) var_rayleigh(b);
                                                 1
          (%o2)                   var_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ var_rayleigh(b);
                                           %pi
                                       1 - ---
                                            4
          (%o4)                        -------
                                          2
                                         b

 -- Función: std_rayleigh (<b>)
     Devuelve la desviación típica de  una variable aleatoria de
     Rayleigh(b), con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la desviación
     típica de la Weibull.

          (%i1) load (distrib)$
          (%i2) std_rayleigh(b);
                                                 1
          (%o2)                   std_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ std_rayleigh(b);
                                             %pi
                                    sqrt(1 - ---)
                                              4
          (%o4)                     -------------
                                          b

 -- Función: skewness_rayleigh (<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Rayleigh(b), con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en el coeficiente
     de asimetría de la Weibull.

          (%i1) load (distrib)$
          (%i2) skewness_rayleigh(b);
                                                   1
          (%o2)                skewness_weibull(2, -)
                                                   b
          (%i3) assume(b>0)$ skewness_rayleigh(b);
                                   3/2
                                %pi      3 sqrt(%pi)
                                ------ - -----------
                                  4           4
          (%o4)                 --------------------
                                         %pi 3/2
                                    (1 - ---)
                                          4

 -- Función: kurtosis_rayleigh (<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria de
     Rayleigh(b), con b>0.

     La variable aleatoria Rayleigh(b) equivale a una Weibull(2,1/b),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en el coeficiente
     de curtosis de la Weibull.

          (%i1) load (distrib)$
          (%i2) kurtosis_rayleigh(b);
                                                   1
          (%o2)                kurtosis_weibull(2, -)
                                                   b
          (%i3) assume(b>0)$ kurtosis_rayleigh(b);
                                            2
                                       3 %pi
                                   2 - ------
                                         16
          (%o4)                    ---------- - 3
                                        %pi 2
                                   (1 - ---)
                                         4

 -- Función: random_rayleigh (<b>)
 -- Función: random_rayleigh (<b>,<n>)
     Devuelve un valor aleatorio  Rayleigh(b), con b>0. Llamando a
     `random_rayleigh' con un segundo argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_laplace (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Laplace(a,b), con b>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_laplace (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Laplace(a,b), con b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_laplace (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Laplace(a,b),
     con b>0; en otras palabras, se trata de la inversa de
     `cdf_laplace'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_laplace (<a>,<b>)
     Devuelve la media de  una variable aleatoria de Laplace(a,b), con
     b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_laplace (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria de Laplace(a,b),
     con b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_laplace (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria de
     Laplace(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_laplace (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Laplace(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_laplace (<a>,<b>)
     Devuelve el coeficiente de curtosis una variable aleatoria de
     Laplace(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: random_laplace (<a>,<b>)
 -- Función: random_laplace (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Laplace(a,b), con b>0. Llamando a
     `random_laplace' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_cauchy (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Cauchy(a,b), con b>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_cauchy (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Cauchy(a,b), con b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_cauchy (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Cauchy(a,b),
     con b>0; en otras palabras, se trata de la inversa de
     `cdf_cauchy'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: random_cauchy (<a>,<b>)
 -- Función: random_cauchy (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Cauchy(a,b), con b>0. Llamando a
     `random_cauchy' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_gumbel (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de densidad
     de una variable aleatoria de Gumbel(a,b), con b>0. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_gumbel (<x>,<a>,<b>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Gumbel(a,b), con b>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_gumbel (<q>,<a>,<b>)
     Devuelve el <q>-cuantil de una variable aleatoria de Gumbel(a,b),
     con b>0; en otras palabras, se trata de la inversa de
     `cdf_gumbel'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_gumbel (<a>,<b>)
     Devuelve la media de  una variable aleatoria de Gumbel(a,b), con
     b>0.

          (%i1) load (distrib)$
          (%i2) assume(b>0)$  mean_gumbel(a,b);
          (%o3)                     %gamma b + a
     donde el símbolo `%gamma' representa la constante de
     Euler-Mascheroni. Véase también `%gamma'.

 -- Función: var_gumbel (<a>,<b>)
     Devuelve la varianza de  una variable aleatoria de Gumbel(a,b),
     con b>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_gumbel (<a>,<b>)
     Devuelve la desviación típica de  una variable aleatoria de
     Gumbel(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_gumbel (<a>,<b>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Gumbel(a,b), con b>0.

          (%i1) load (distrib)$
          (%i2) assume(b>0)$ skewness_gumbel(a,b);
                                 12 sqrt(6) zeta(3)
          (%o3)                  ------------------
                                           3
                                        %pi
          (%i4) numer:true$ skewness_gumbel(a,b);
          (%o5)                   1.139547099404649
     donde `zeta' representa la función zeta de Riemann.

 -- Función: kurtosis_gumbel (<a>,<b>)
     Devuelve el coeficiente de curtosis de una variable aleatoria de
     Gumbel(a,b), con b>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: random_gumbel (<a>,<b>)
 -- Función: random_gumbel (<a>,<b>,<n>)
     Devuelve un valor aleatorio  Gumbel(a,b), con b>0. Llamando a
     `random_gumbel' con un tercer argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Sólo se ha programado el método inverso. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.


File: maxima.info,  Node: Funciones y variables para distribuciones discretas,  Prev: Funciones y variables para distribuciones continuas,  Up: distrib

47.3 Funciones y variables para distribuciones discretas
========================================================

 -- Función: pdf_binomial (<x>,<n>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria Binomial(n,p), con 0<p<1 y
     n entero positivo. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: cdf_binomial (<x>,<n>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Binomial(n,p), con 0<p<1 y
     n entero positivo.

     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal.

          (%i1) load (distrib)$
          (%i2) cdf_binomial(5,7,1/6);
                                                   1
          (%o2)                 cdf_binomial(5, 7, -)
                                                   6
          (%i3) cdf_binomial(5,7,1/6), numer;
          (%o3)                   .9998713991769548

 -- Función: quantile_binomial (<q>,<n>,<p>)
     Devuelve el <q>-cuantil de una variable aleatoria Binomial(n,p),
     con 0<p<1 y n entero positivo; en otras palabras, se trata de la
     inversa de  `cdf_binomial'. El argumento <q> debe ser un número de
     [0,1]. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: mean_binomial (<n>,<p>)
     Devuelve la media de  una variable aleatoria Binomial(n,p), con
     0<p<1 y n entero positivo. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: var_binomial (<n>,<p>)
     Devuelve la varianza de  una variable aleatoria Binomial(n,p), con
     0<p<1 y n entero positivo. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: std_binomial (<n>,<p>)
     Devuelve la desviación típica de  una variable aleatoria
     Binomial(n,p), con 0<p<1 y n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: skewness_binomial (<n>,<p>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Binomial(n,p), con 0<p<1 y n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: kurtosis_binomial (<n>,<p>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     binomial  Binomial(n,p), con 0<p<1 y n entero positivo. Para hacer
     uso de esta función, ejecútese primero `load(distrib)'.

 -- Variable opcional: random_binomial_algorithm
     Valor por defecto: `kachit'

     Es el algoritmo seleccionado para simular variables binomiales.
     Los algoritmos programados son `kachit', `bernoulli' y `inverse':
        * `kachit', basado en el algoritmo descrito en
          Kachitvichyanukul, V. y Schmeiser, B.W. (1988) <Binomial
          Random Variate Generation>. Communications of the ACM, 31,
          Feb., 216.

        * `bernoulli', basado en la simulación de ensayos de Bernoulli.

        * `inverse', basado en el método inverso.


     Véase también `random_binomial'.

 -- Función: random_binomial (<n>,<p>)
 -- Función: random_binomial (<n>,<p>,<m>)
     Devuelve un valor aleatorio  Binomial(n,p), con 0<p<1 y n entero
     positivo. Llamando a  `random_binomial' con un tercer argumento
     <m>, se simulará una muestra aleatoria de tamaño  <m>.

     Hay tres algoritmos programados para esta función, el que se vaya
     a utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_binomial_algorithm', cuyo valor por
     defecto es `kachit'.

     Véase también `random_binomial_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_poisson (<x>,<m>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria de Poisson(m), con m>0.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_poisson (<x>,<m>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Poisson(m), con m>0.

     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal.

          (%i1) load (distrib)$
          (%i2) cdf_poisson(3,5);
          (%o2)                   cdf_poisson(3, 5)
          (%i3) cdf_poisson(3,5), numer;
          (%o3)                   .2650259152973617

 -- Función: quantile_poisson (<q>,<m>)
     Devuelve el <q>-cuantil de una variable aleatoria de Poisson(m),
     con m>0; en otras palabras, se trata de la inversa de
     `cdf_poisson'. El argumento <q> debe ser un número de [0,1]. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_poisson (<m>)
     Devuelve la media de una variable aleatoria de Poisson(m), con
     m>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_poisson (<m>)
     Devuelve la varianza de  una variable aleatoria de Poisson(m), con
     m>0. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_poisson (<m>)
     Devuelve la desviación típica de  una variable aleatoria de
     Poisson(m), con m>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: skewness_poisson (<m>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Poisson(m), con m>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: kurtosis_poisson (<m>)
     Devuelve el coeficiente de curtosis de una variable aleatoria de
     Poisson(m), con m>0. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Variable opcional: random_poisson_algorithm
     Valor por defecto: `ahrens_dieter'

     Es el algoritmo seleccionado para simular variables de Poisson.
     Los algoritmos programados son `ahrens_dieter' y `inverse':
        * `ahrens_dieter', basado en el algoritmo descrito en Ahrens,
          J.H. and Dieter, U. (1982) <Computer Generation of Poisson
          Deviates From Modified Normal Distributions>. ACM Trans.
          Math. Software, 8, 2, June,163-179.

        * `inverse', basado en el método inverso.


     Véase también `random_poisson'.

 -- Función: random_poisson (<m>)
 -- Función: random_poisson (<m>,<n>)
     Devuelve un valor aleatorio  Poisson(m), con m>0. Llamando a
     `random_poisson' con un segundo argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_poisson_algorithm', cuyo valor por defecto
     es `ahrens_dieter'.

     Véase también `random_poisson_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_bernoulli (<x>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria de Bernoulli(p), con 0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la función de
     probabilidad de la binomial.

          (%i1) load (distrib)$
          (%i2) pdf_bernoulli(1,p);
          (%o2)                 pdf_binomial(1, 1, p)
          (%i3) assume(0<p,p<1)$ pdf_bernoulli(1,p);
          (%o4)                           p

 -- Función: cdf_bernoulli (<x>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria de Bernoulli(p), con 0<p<1.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_bernoulli (<q>,<p>)
     Devuelve el <q>-cuantil de una variable aleatoria de Bernoulli(p),
     con 0<p<1; en otras palabras, se trata de la inversa de
     `cdf_bernoulli'. El argumento <q> debe ser un número de [0,1].
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_bernoulli (<p>)
     Devuelve la media de  una variable aleatoria de Bernoulli(p), con
     0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la media de la
     binomial.

          (%i1) load (distrib)$
          (%i2) mean_bernoulli(p);
          (%o2)                  mean_binomial(1, p)
          (%i3) assume(0<p,p<1)$ mean_bernoulli(p);
          (%o4)                           p

 -- Función: var_bernoulli (<p>)
     Devuelve la varianza de  una variable aleatoria de Bernoulli(p),
     con 0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la varianza de
     la binomial.

          (%i1) load (distrib)$
          (%i2) var_bernoulli(p);
          (%o2)                  var_binomial(1, p)
          (%i3) assume(0<p,p<1)$ var_bernoulli(p);
          (%o4)                       (1 - p) p

 -- Función: std_bernoulli (<p>)
     Devuelve la desviación típica de  una variable aleatoria de
     Bernoulli(p), con 0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en la desviación
     típica de la binomial.

          (%i1) load (distrib)$
          (%i2) std_bernoulli(p);
          (%o2)                  std_binomial(1, p)
          (%i3) assume(0<p,p<1)$ std_bernoulli(p);
          (%o4)                  sqrt(1 - p) sqrt(p)

 -- Función: skewness_bernoulli (<p>)
     Devuelve el coeficiente de asimetría de una variable aleatoria de
     Bernoulli(p), con 0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en el coeficiente
     de asimetría de la binomial.

          (%i1) load (distrib)$
          (%i2) skewness_bernoulli(p);
          (%o2)                skewness_binomial(1, p)
          (%i3) assume(0<p,p<1)$ skewness_bernoulli(p);
                                       1 - 2 p
          (%o4)                  -------------------
                                 sqrt(1 - p) sqrt(p)

 -- Función: kurtosis_bernoulli (<p>)
     Devuelve el coeficiente de curtosis una variable aleatoria de
     Bernoulli(p), con 0<p<1.

     La variable aleatoria Bernoulli(p) equivale a una Binomial(1,p),
     por lo que si Maxima no tiene suficiente información para calcular
     el resultado, devolverá una forma nominal basada en el coeficiente
     de curtosis de la binomial.

          (%i1) load (distrib)$
          (%i2) kurtosis_bernoulli(p);
          (%o2)                kurtosis_binomial(1, p)
          (%i3) assume(0<p,p<1)$ kurtosis_bernoulli(p);
                                   1 - 6 (1 - p) p
          (%o4)                    ---------------
                                      (1 - p) p

 -- Función: random_bernoulli (<p>)
 -- Función: random_bernoulli (<p>,<n>)
     Devuelve un valor aleatorio  Bernoulli(p), con 0<p<1. Llamando a
     `random_bernoulli' con un segundo argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Es aplicación directa de la función `random' de Maxima.

     Véase también `random'. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: pdf_geometric (<x>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria Geométrica(p), con 0<p<1.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_geometric (<x>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Geométrica(p), con 0<p<1.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_geometric (<q>,<p>)
     Devuelve el <q>-cuantil de una variable aleatoria Geométrica(p),
     con 0<p<1; en otras palabras, se trata de la inversa de
     `cdf_geometric'. El argumento <q> debe ser un número de [0,1].
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: mean_geometric (<p>)
     Devuelve la media de  una variable aleatoria Geométrica(p), con
     0<p<1. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: var_geometric (<p>)
     Devuelve la varianza de  una variable aleatoria Geométrica(p), con
     0<p<1. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_geometric (<p>)
     Devuelve la desviación típica de  una variable aleatoria
     Geométrica(p), con 0<p<1. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: skewness_geometric (<p>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Geométrica(p), con 0<p<1. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: kurtosis_geometric (<p>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     Geométrica(p), con 0<p<1. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Variable opcional: random_geometric_algorithm
     Valor por defecto: `bernoulli'

     Es el algoritmo seleccionado para simular variables geométricas.
     Los algoritmos programados son `bernoulli', `devroye' y `inverse':
        * `bernoulli', basado en la simulación de ensayos de Bernoulli.

        * `devroye', basado en el algoritmo descrito en Devroye, L.
          (1986) <Non-Uniform Random Variate Generation.> Springer
          Verlag, p. 480.

        * `inverse', basado en el método inverso.


     Véase también `random_geometric'.

 -- Función: random_geometric (<p>)
 -- Función: random_geometric (<p>,<n>)
     Devuelve un valor aleatorio Geométrico(p), con 0<p<1. Llamando a
     `random_geometric' con un segundo argumento <n>, se simulará una
     muestra aleatoria de tamaño  <n>.

     Hay tres algoritmos programados para esta función, el que se vaya
     a utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_geometric_algorithm', cuyo valor por
     defecto es `bernoulli'.

     Véase también `random_geometric_algorithm'. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: pdf_discrete_uniform (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria Uniforme Discreta(n), con n
     entero positivo. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: cdf_discrete_uniform (<x>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Uniforme Discreta(n), con n
     entero positivo. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: quantile_discrete_uniform (<q>,<n>)
     Devuelve el <q>-cuantil de una variable aleatoria Uniforme
     Discreta(n), con n entero positivo; en otras palabras, se trata de
     la inversa de  `cdf_discrete_uniform'. El argumento <q> debe ser
     un número de [0,1]. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: mean_discrete_uniform (<n>)
     Devuelve la media de  una variable aleatoria Uniforme Discreta(n),
     con n entero positivo. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: var_discrete_uniform (<n>)
     Devuelve la varianza de  una variable aleatoria Uniforme
     Discreta(n), con n entero positivo. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: std_discrete_uniform (<n>)
     Devuelve la desviación típica de  una variable aleatoria Uniforme
     Discreta(n), con n entero positivo. Para hacer uso de esta
     función, ejecútese primero `load(distrib)'.

 -- Función: skewness_discrete_uniform (<n>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Uniforme Discreta(n), con n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: kurtosis_discrete_uniform (<n>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     Uniforme Discreta(n), con n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: random_discrete_uniform (<n>)
 -- Función: random_discrete_uniform (<n>,<m>)
     Devuelve un valor aleatorio  Uniforme Discreto(n), con n entero
     positivo. Llamando a  `random_discrete_uniform' con un segundo
     argumento <m>, se simulará una muestra aleatoria de tamaño  <m>.

     Se trata de una aplicación directa de la función `random' de
     Maxima.

     Véase también `random'. Para hacer uso de esta función, ejecútese
     primero `load(distrib)'.

 -- Función: pdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria Hipergeométrica(n1,n2,n),
     con <n1>, <n2> y <n> enteros positivos y n<=n1+n2. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: cdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución of una variable aleatoria Hipergeométrica(n1,n2,n),
     con <n1>, <n2> y <n> enteros positivos y n<=n1+n2. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.

 -- Función: quantile_hypergeometric (<q>,<n1>,<n2>,<n>)
     Devuelve el <q>-cuantil de una variable aleatoria
     Hipergeométrica(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y
     n<=n1+n2; en otras palabras, se trata de la inversa de
     `cdf_hypergeometric'. El argumento <q> debe ser un número de
     [0,1]. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: mean_hypergeometric (<n1>,<n2>,<n>)
     Devuelve la media de  una variable aleatoria uniforme discreta
     Hyp(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y n<=n1+n2.
     Para hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: var_hypergeometric (<n1>,<n2>,<n>)
     Devuelve la varianza de  una variable aleatoria
     Hipergeométrica(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y
     n<=n1+n2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: std_hypergeometric (<n1>,<n2>,<n>)
     Devuelve la desviación típica de  una variable aleatoria
     Hipergeométrica(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y
     n<=n1+n2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: skewness_hypergeometric (<n1>,<n2>,<n>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Hipergeométrica(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y
     n<=n1+n2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Función: kurtosis_hypergeometric (<n1>,<n2>,<n>)
     Devuelve el coeficiente de curtosis de una variable aleatoria
     Hipergeométrica(n1,n2,n), con <n1>, <n2> y <n> enteros positivos y
     n<=n1+n2. Para hacer uso de esta función, ejecútese primero
     `load(distrib)'.

 -- Variable opcional: random_hypergeometric_algorithm
     Valor por defecto: `kachit'

     Es el algoritmo seleccionado para simular variables
     hipergeométricas. Los algoritmos programados son `kachit' and
     `inverse':
        * `kachit', basado en el algoritmo descrito en
          Kachitvichyanukul, V., Schmeiser, B.W. (1985) <Computer
          generation of hypergeometric random variates.> Journal of
          Statistical Computation and Simulation 22, 127-145.

        * `inverse', basado en el método inverso.


     Véase también `random_hypergeometric'.

 -- Función: random_hypergeometric (<n1>,<n2>,<n>)
 -- Función: random_hypergeometric (<n1>,<n2>,<n>,<m>)
     Devuelve un valor aleatorio Hipergeométrico(n1,n2,n), con <n1>,
     <n2> y <n> enteros positivos y n<=n1+n2. Llamando a
     `random_hypergeometric' con un cuarto argumento <m>, se simulará
     una muestra aleatoria de tamaño  <m>.

     Hay dos algoritmos programados para esta función, el que se vaya a
     utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_hypergeometric_algorithm', cuyo valor por
     defecto es `kachit'.

     Véase también `random_hypergeometric_algorithm'. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: pdf_negative_binomial (<x>,<n>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     probabilidad de una variable aleatoria Binomial Negativa(n,p), con
     0<p<1 y n entero positivo. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: cdf_negative_binomial (<x>,<n>,<p>)
     Devuelve el valor correspondiente a <x> de la función de
     distribución de una variable aleatoria Binomial Negativa(n,p), con
     0<p<1 y n entero positivo.

     Esta función no tiene expresión compacta y se calcula
     numéricamente si la variable global `numer' vale `true', en otro
     caso devuelve una expresión nominal.

          (%i1) load (distrib)$
          (%i2) cdf_negative_binomial(3,4,1/8);
                                                       1
          (%o2)            cdf_negative_binomial(3, 4, -)
                                                       8
          (%i3) cdf_negative_binomial(3,4,1/8), numer;
          (%o3)                  .006238937377929698

 -- Función: quantile_negative_binomial (<q>,<n>,<p>)
     Devuelve el <q>-cuantil de una variable aleatoria Binomial
     Negativa(n,p), con 0<p<1 y n entero positivo; en otras palabras,
     se trata de la inversa de  `cdf_negative_binomial'. El argumento
     <q> debe ser un número de [0,1]. Para hacer uso de esta función,
     ejecútese primero `load(distrib)'.

 -- Función: mean_negative_binomial (<n>,<p>)
     Devuelve la media de  una variable aleatoria Binomial
     Negativa(n,p), con 0<p<1 and n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: var_negative_binomial (<n>,<p>)
     Devuelve la varianza de  una variable aleatoria Binomial
     Negativa(n,p), con 0<p<1 and n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: std_negative_binomial (<n>,<p>)
     Devuelve la desviación típica de  una variable aleatoria Binomial
     Negativa(n,p), con 0<p<1 and n entero positivo. Para hacer uso de
     esta función, ejecútese primero `load(distrib)'.

 -- Función: skewness_negative_binomial (<n>,<p>)
     Devuelve el coeficiente de asimetría de una variable aleatoria
     Binomial Negativa(n,p), con 0<p<1 and n entero positivo. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Función: kurtosis_negative_binomial (<n>,<p>)
     Devuelve el coeficiente de curtosis una variable aleatoria
     binomial negativa  NB(n,p), con 0<p<1 and n entero positivo. Para
     hacer uso de esta función, ejecútese primero `load(distrib)'.

 -- Variable opcional: random_negative_binomial_algorithm
     Valor por defecto: `bernoulli'

     Es el algoritmo seleccionado para simular variables aleatorias
     binomiales negativas. Los algoritmos programados son `devroye',
     `bernoulli' y `inverse':
        * `devroye', basado en el algoritmo descrito en Devroye, L.
          (1986) <Non-Uniform Random Variate Generation>. Springer
          Verlag, p. 480.

        * `bernoulli', basado en la simulación de ensayos de Bernoulli.

        * `inverse', basado en el método inverso.


     Véase también `random_negative_binomial'.

 -- Función: random_negative_binomial (<n>,<p>)
 -- Función: random_negative_binomial (<n>,<p>,<m>)
     Devuelve un valor aleatorio Binomial Negativo(n,p), con 0<p<1 y n
     entero positivo. Llamando a  `random_negative_binomial' con un
     tercer argumento <m>, se simulará una muestra aleatoria de tamaño
     <m>.

     Hay tres algoritmos programados para esta función, el que se vaya
     a utilizar tendrá que ser seleccionado dándole un valor a la
     variable global `random_negative_binomial_algorithm', cuyo valor
     por defecto es `bernoulli'.

     Véase también `random_negative_binomial_algorithm'. Para hacer uso
     de esta función, ejecútese primero `load(distrib)'.


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

48 draw
*******

* Menu:

* Introducción a draw::
* Funciones y variables para draw::
* Funciones y variables para picture::
* Funciones y variables para worldmap::


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

48.1 Introducción a draw
========================

`draw' es un interfaz para comunicar Maxima con Gnuplot.

   Tres son las funciones principales a utilizar a nivel de Maxima:
`draw2d', `draw3d' y `draw'.

   Sígase este enlace para ver ejemplos más elaborados de este paquete:

   `http://www.telefonica.net/web2/biomates/maxima/gpdraw'

   Se necesita tener instalado Gnuplot 4.2 para ejecutar este paquete.



Local Variables:
coding: iso-8859-1
End: