@c English version 2013-08-03
@menu
* Documentación::
* Funciones y variables para la ayuda::
@end menu


@node Documentación, Funciones y variables para la ayuda, Ayuda, Ayuda
@section Documentación

El manual en línea del usuario de Maxima puede ser visto en diferentes formas. 
Desde el prompt interactivo de Maxima, el manual de usuario
es visto como texto plano por medio del comando  @code{?} (i.e., la función @code{describe}). 
El manual de usuario también puede ser visto como hipertexto tipo @code{info} por medio del programa @code{info} y como una página web a través de cualquier navegador. 

El comando @code{example} muestra ejemplos para muchas funciones Maxima. 
Por ejemplo: 

@example
(%i1) example (integrate);
@end example

produce: 

@example
(%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
(%o2) test(f) := block([u], u : integrate(f, x), 

                                         ratsimp(f - diff(u, x)))
(%i3) test(sin(x))
(%o3)                           0
(%i4) test(1/(x+1))
(%o4)                           0
(%i5) test(1/(x^2+1))
(%o5)                           0
@end example

y salidas adicionales. 








@node Funciones y variables para la ayuda,  , Documentación, Ayuda
@section Funciones y variables para la ayuda



@deffn {Función} apropos (@var{string})

Busca los símbolos de Maxima en los cuales aparezca 
@var{cadena} en cualquier lugar dentro de su nombre. Así, 
@code{apropos (exp)} devuelve una lista con todas las variables y 
funciones que tengan  @code{exp} formando parte de sus nombres, 
como  @code{expand}, @code{exp} y @code{exponentialize}. 
De esta forma, si el usuario tan solo recuerda parte del nombre de algo, 
puede utilizar este comando para encontrar el resto del nombre. 
De manera semejante, también se puede hacer @code{apropos (tr_)} 
para encontrar una lista de muchas de las variables relacionadas 
con el traductor, buena parte de las cuales comienzan con @code{tr_}.

@code{apropos("")} devuelve una lista con todos los nombres de Maxima. 

En caso de no encontrar información relevante, @code{apropos} 
devuelve la lista vacía @code{[]}.

Ejemplo:

Devuelve todos los símbolos de Maxima que
contienen la subcadena @code{"gamma"} en su nombre:

@c ===beg===
@c apropos("gamma");
@c ===end===
@example
(%i1) apropos("gamma");
(%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_incomplete_lower, 
gamma_incomplete, gamma_incomplete_generalized, 
gamma_incomplete_regularized, Gamma, log_gamma, makegamma, 
prefer_gamma_incomplete, 
gamma_incomplete_generalized_regularized]
@end example


@end deffn



@deffn {Función} demo (@var{archivo})
Evalua las expresiones Maxima contenidas en @var{archivo} y muestra los resultados. 
@code{demo} hace pausas después de evaluar  cada expresión
y continua después de que el usuario ingrese un retorno de carro. 
(Si se ejecuta en Xmaxima, @code{demo} puede que necesite un punto y coma
@code{;} a continuación del retorno de carro.)

@code{demo} busca la lista de directorios 
@code{file_search_demo} para encontrar @code{archivo}.
Si el archivo tiene el sufijo @code{dem}, 
el sufijo puede ser omitido. 
Ver también @code{file_search}.

@code{demo} evalua su argumento. 
@code{demo} retorna el nombre del archivo demostración. 

Ejemplo:

@example
(%i1) demo ("disol");

batching /home/wfs/maxima/share/simplification/disol.dem
 At the _ prompt, type ';' followed by enter to get next demo
(%i2)                      load("disol")

_
(%i3)           exp1 : a (e (g + f) + b (d + c))
(%o3)               a (e (g + f) + b (d + c))

_
(%i4)                disolate(exp1, a, b, e)
(%t4)                         d + c

(%t5)                         g + f

(%o5)                   a (%t5 e + %t4 b)

_
(%i5) demo ("rncomb");

batching /home/wfs/maxima/share/simplification/rncomb.dem
 At the _ prompt, type ';' followed by enter to get next demo
(%i6)                     load("rncomb")

_
                             z         x
(%i7)               exp1 : ----- + ---------
                           y + x   2 (y + x)
                          z         x
(%o7)                   ----- + ---------
                        y + x   2 (y + x)

_
(%i8)                     combine(exp1)
                          z         x
(%o8)                   ----- + ---------
                        y + x   2 (y + x)

_
(%i9)                     rncombine(%)
                             2 z + x
(%o9)                       ---------
                            2 (y + x)

_
                             d   c   b   a
(%i10)                exp2 : - + - + - + -
                             3   3   2   2
                          d   c   b   a
(%o10)                    - + - + - + -
                          3   3   2   2

_
(%i11)                    combine(exp2)
                      2 d + 2 c + 3 (b + a)
(%o11)                ---------------------
                                6

_
(%i12)                   rncombine(exp2)
                      2 d + 2 c + 3 b + 3 a
(%o12)                ---------------------
                                6

_
(%i13) 
@end example
@end deffn


@deffn {Función} describe (@var{string})
@deffnx {Función} describe (@var{string}, exact)
@deffnx {Función} describe (@var{string}, inexact)
@ifinfo
@fnindex Ayuda
@end ifinfo
La sentencia @code{describe(@var{string})} equivale a @code{describe(@var{string}, exact)}.

La sentencia @code{describe(@var{string}, exact)} encuentra el elemento, si
existe, cuyo título coincide exactamente con @var{string}
(ignorando la diferencia entre mayúsculas y minúsculas).

La sentencia @code{describe(@var{string}, inexact)} encuentra todos los elementos
documentados que contengan @var{string} en sus títulos.

Si hay más de una opción, Maxima preguntará al usuario para que
seleccione las opciones que desee consultar.

La sentencia @code{? foo} (con espacio entre @code{?} y @code{foo})
equivale a  @code{describe("foo", exact)}, mientras que @code{?? foo}
equivale a @code{describe("foo", inexact)}.

@code{describe ("", inexact)} produce una lista de todos los temas documentados en
el manual en línea. 

@code{describe} no evalúa su argumento. La función @code{describe} devuelve
@code{true} si encuentra la documentación solicitada y @code{false} en caso
contrario.

Véase también @code{Documentación}.

Ejemplo:

@example
(%i1) ?? integ
 0: Functions and Variables for Elliptic Integrals
 1: Functions and Variables for Integration
 2: Introduction to Elliptic Functions and Integrals
 3: Introduction to Integration
 4: askinteger  (Functions and Variables for Simplification)
 5: integerp  (Functions and Variables for Miscellaneous Options)
 6: integer_partitions  (Functions and Variables for Sets)
 7: integrate  (Functions and Variables for Integration)
 8: integrate_use_rootsof  (Functions and Variables for
    Integration)
 9: integration_constant_counter  (Functions and Variables for
    Integration)
 10: nonnegintegerp  (Functions and Variables for linearalgebra)
Enter space-separated numbers, `all' or `none': 7 8

 -- Function: integrate (<expr>, <x>)
 -- Function: integrate (<expr>, <x>, <a>, <b>)
     Attempts to symbolically compute the integral of <expr> with
     respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
     integral, while `integrate (<expr>, <x>, <a>, <b>)' is a
     definite integral, [...]
     
 -- Option variable: integrate_use_rootsof
     Default value: `false'

     When `integrate_use_rootsof' is `true' and the denominator of
     a rational function cannot be factored, `integrate' returns
     the integral in a form which is a sum over the roots (not yet
     known) of the denominator.
     [...]
@end example

En este ejemplo fueron seleccionadas las opciones 7 y 8 
(la salida ha sido recortada, tal como indica @code{[...]}).
Todas o ninguna de las opciones pueden ser seleccionadas escribiendo
@code{all} o @code{none}, las cuales pueden ser abreviadas por
@code{a} o @code{n}, respectivamente. 


@end deffn



@deffn {Función} example (@var{topic})
@deffnx {Función} example ()

@code{example (@var{topic})} muestra algunos ejemplos sobre @var{topic},
el cual debe ser un símbolo o cadena de texto. Para ver
ejemplos sobre operadores como @code{if}, @code{do} o @code{lambda}
el argumento debe ser necesariamente una cadena de texto, como
@code{example ("do")}. La función @code{example} no distingue entre minúsculas
y mayúsculas. La mayor parte de ejemplos versan sobre funciones.

La sentencia @code{example ()} devuelve la lista de todos los ejemplos
existentes.

El nombre del fichero que contine los ejemplos existentes se guarda en
la variable global @code{manual_demo}, cuyo valor por defecto es
@code{"manual.demo"}.

La función @code{example} no evalúa su argumento.

Ejemplos:

@c ===beg===
@c example(append);
@c example("lambda");
@c example("allROOTS");
@c ===end===
@example
(%i1) example(append);
(%i2) append([x+y,0,-3.2],[2.5E+20,x])
(%o2)                    [y + x, 0, - 3.2, 2.5E+20, x]
(%o2)                                done
(%i3) example("lambda");
(%i4) lambda([x,y,z],z^2+y^2+x^2)
                                           2    2    2
(%o4)                   lambda([x, y, z], z  + y  + x )
(%i5) %(1,2,a)
                                     2
(%o5)                               a  + 5
(%i6) a+2+1
(%o6)                                a + 3
(%o6)                                done
(%i7) example("allROOTS");
(%i8) (1+2*x)^3 = 13.5*(1+x^5)
                                   3          5
(%o8)                     (2 x + 1)  = 13.5 (x  + 1)
(%i9) allroots(%)
(%o9) [x = .8296749902129361, x = - 1.015755543828121, 
x = .9659625152196369 %i - .4069597231924075, 
x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
(%o9)                                done
@end example

@end deffn

@defvr {Variable opcional} manual_demo
Valor por defecto: @code{"manual.demo"}

@code{manual_demo} especifica el nombre del fichero que contiene
los ejemplo para la función @code{example}. 

Véase @code{example}.

@end defvr

