doc/info/es/Help.es.texi

   1 @c English version 2013-08-03
   2 @menu
   3 * Documentación::
   4 * Funciones y variables para la ayuda::
   5 @end menu
   6
   7
   8 @node Documentación, Funciones y variables para la ayuda, Ayuda, Ayuda
   9 @section Documentación
  10
  11 El manual en línea del usuario de Maxima puede ser visto en diferentes formas.
  12 Desde el prompt interactivo de Maxima, el manual de usuario
  13 es visto como texto plano por medio del comando  @code{?} (i.e., la función @code{describe}).
  14 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.
  15
  16 El comando @code{example} muestra ejemplos para muchas funciones Maxima.
  17 Por ejemplo:
  18
  19 @example
  20 (%i1) example (integrate);
  21 @end example
  22
  23 produce:
  24
  25 @example
  26 (%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
  27 (%o2) test(f) := block([u], u : integrate(f, x),
  28
  29                                          ratsimp(f - diff(u, x)))
  30 (%i3) test(sin(x))
  31 (%o3)                           0
  32 (%i4) test(1/(x+1))
  33 (%o4)                           0
  34 (%i5) test(1/(x^2+1))
  35 (%o5)                           0
  36 @end example
  37
  38 y salidas adicionales.
  39
  40
  41
  42
  43
  44
  45
  46
  47 @node Funciones y variables para la ayuda,  , Documentación, Ayuda
  48 @section Funciones y variables para la ayuda
  49
  50
  51
  52 @deffn {Función} apropos (@var{string})
  53
  54 Busca los símbolos de Maxima en los cuales aparezca
  55 @var{cadena} en cualquier lugar dentro de su nombre. Así,
  56 @code{apropos (exp)} devuelve una lista con todas las variables y
  57 funciones que tengan  @code{exp} formando parte de sus nombres,
  58 como  @code{expand}, @code{exp} y @code{exponentialize}.
  59 De esta forma, si el usuario tan solo recuerda parte del nombre de algo,
  60 puede utilizar este comando para encontrar el resto del nombre.
  61 De manera semejante, también se puede hacer @code{apropos (tr_)}
  62 para encontrar una lista de muchas de las variables relacionadas
  63 con el traductor, buena parte de las cuales comienzan con @code{tr_}.
  64
  65 @code{apropos("")} devuelve una lista con todos los nombres de Maxima.
  66
  67 En caso de no encontrar información relevante, @code{apropos}
  68 devuelve la lista vacía @code{[]}.
  69
  70 Ejemplo:
  71
  72 Devuelve todos los símbolos de Maxima que
  73 contienen la subcadena @code{"gamma"} en su nombre:
  74
  75 @c ===beg===
  76 @c apropos("gamma");
  77 @c ===end===
  78 @example
  79 (%i1) apropos("gamma");
  80 (%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_incomplete_lower,
  81 gamma_incomplete, gamma_incomplete_generalized,
  82 gamma_incomplete_regularized, Gamma, log_gamma, makegamma,
  83 prefer_gamma_incomplete,
  84 gamma_incomplete_generalized_regularized]
  85 @end example
  86
  87
  88 @end deffn
  89
  90
  91
  92 @deffn {Función} demo (@var{archivo})
  93 Evalua las expresiones Maxima contenidas en @var{archivo} y muestra los resultados.
  94 @code{demo} hace pausas después de evaluar  cada expresión
  95 y continua después de que el usuario ingrese un retorno de carro.
  96 (Si se ejecuta en Xmaxima, @code{demo} puede que necesite un punto y coma
  97 @code{;} a continuación del retorno de carro.)
  98
  99 @code{demo} busca la lista de directorios
 100 @code{file_search_demo} para encontrar @code{archivo}.
 101 Si el archivo tiene el sufijo @code{dem},
 102 el sufijo puede ser omitido.
 103 Ver también @code{file_search}.
 104
 105 @code{demo} evalua su argumento.
 106 @code{demo} retorna el nombre del archivo demostración.
 107
 108 Ejemplo:
 109
 110 @example
 111 (%i1) demo ("disol");
 112
 113 batching /home/wfs/maxima/share/simplification/disol.dem
 114  At the _ prompt, type ';' followed by enter to get next demo
 115 (%i2)                      load("disol")
 116
 117 _
 118 (%i3)           exp1 : a (e (g + f) + b (d + c))
 119 (%o3)               a (e (g + f) + b (d + c))
 120
 121 _
 122 (%i4)                disolate(exp1, a, b, e)
 123 (%t4)                         d + c
 124
 125 (%t5)                         g + f
 126
 127 (%o5)                   a (%t5 e + %t4 b)
 128
 129 _
 130 (%i5) demo ("rncomb");
 131
 132 batching /home/wfs/maxima/share/simplification/rncomb.dem
 133  At the _ prompt, type ';' followed by enter to get next demo
 134 (%i6)                     load("rncomb")
 135
 136 _
 137                              z         x
 138 (%i7)               exp1 : ----- + ---------
 139                            y + x   2 (y + x)
 140                           z         x
 141 (%o7)                   ----- + ---------
 142                         y + x   2 (y + x)
 143
 144 _
 145 (%i8)                     combine(exp1)
 146                           z         x
 147 (%o8)                   ----- + ---------
 148                         y + x   2 (y + x)
 149
 150 _
 151 (%i9)                     rncombine(%)
 152                              2 z + x
 153 (%o9)                       ---------
 154                             2 (y + x)
 155
 156 _
 157                              d   c   b   a
 158 (%i10)                exp2 : - + - + - + -
 159                              3   3   2   2
 160                           d   c   b   a
 161 (%o10)                    - + - + - + -
 162                           3   3   2   2
 163
 164 _
 165 (%i11)                    combine(exp2)
 166                       2 d + 2 c + 3 (b + a)
 167 (%o11)                ---------------------
 168                                 6
 169
 170 _
 171 (%i12)                   rncombine(exp2)
 172                       2 d + 2 c + 3 b + 3 a
 173 (%o12)                ---------------------
 174                                 6
 175
 176 _
 177 (%i13)
 178 @end example
 179 @end deffn
 180
 181
 182 @deffn {Función} describe (@var{string})
 183 @deffnx {Función} describe (@var{string}, exact)
 184 @deffnx {Función} describe (@var{string}, inexact)
 185 @ifinfo
 186 @fnindex Ayuda
 187 @end ifinfo
 188 La sentencia @code{describe(@var{string})} equivale a @code{describe(@var{string}, exact)}.
 189
 190 La sentencia @code{describe(@var{string}, exact)} encuentra el elemento, si
 191 existe, cuyo título coincide exactamente con @var{string}
 192 (ignorando la diferencia entre mayúsculas y minúsculas).
 193
 194 La sentencia @code{describe(@var{string}, inexact)} encuentra todos los elementos
 195 documentados que contengan @var{string} en sus títulos.
 196
 197 Si hay más de una opción, Maxima preguntará al usuario para que
 198 seleccione las opciones que desee consultar.
 199
 200 La sentencia @code{? foo} (con espacio entre @code{?} y @code{foo})
 201 equivale a  @code{describe("foo", exact)}, mientras que @code{?? foo}
 202 equivale a @code{describe("foo", inexact)}.
 203
 204 @code{describe ("", inexact)} produce una lista de todos los temas documentados en
 205 el manual en línea.
 206
 207 @code{describe} no evalúa su argumento. La función @code{describe} devuelve
 208 @code{true} si encuentra la documentación solicitada y @code{false} en caso
 209 contrario.
 210
 211 Véase también @code{Documentación}.
 212
 213 Ejemplo:
 214
 215 @example
 216 (%i1) ?? integ
 217  0: Functions and Variables for Elliptic Integrals
 218  1: Functions and Variables for Integration
 219  2: Introduction to Elliptic Functions and Integrals
 220  3: Introduction to Integration
 221  4: askinteger  (Functions and Variables for Simplification)
 222  5: integerp  (Functions and Variables for Miscellaneous Options)
 223  6: integer_partitions  (Functions and Variables for Sets)
 224  7: integrate  (Functions and Variables for Integration)
 225  8: integrate_use_rootsof  (Functions and Variables for
 226     Integration)
 227  9: integration_constant_counter  (Functions and Variables for
 228     Integration)
 229  10: nonnegintegerp  (Functions and Variables for linearalgebra)
 230 Enter space-separated numbers, `all' or `none': 7 8
 231
 232  -- Function: integrate (<expr>, <x>)
 233  -- Function: integrate (<expr>, <x>, <a>, <b>)
 234      Attempts to symbolically compute the integral of <expr> with
 235      respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
 236      integral, while `integrate (<expr>, <x>, <a>, <b>)' is a
 237      definite integral, [...]
 238
 239  -- Option variable: integrate_use_rootsof
 240      Default value: `false'
 241
 242      When `integrate_use_rootsof' is `true' and the denominator of
 243      a rational function cannot be factored, `integrate' returns
 244      the integral in a form which is a sum over the roots (not yet
 245      known) of the denominator.
 246      [...]
 247 @end example
 248
 249 En este ejemplo fueron seleccionadas las opciones 7 y 8
 250 (la salida ha sido recortada, tal como indica @code{[...]}).
 251 Todas o ninguna de las opciones pueden ser seleccionadas escribiendo
 252 @code{all} o @code{none}, las cuales pueden ser abreviadas por
 253 @code{a} o @code{n}, respectivamente.
 254
 255
 256 @end deffn
 257
 258
 259
 260 @deffn {Función} example (@var{topic})
 261 @deffnx {Función} example ()
 262
 263 @code{example (@var{topic})} muestra algunos ejemplos sobre @var{topic},
 264 el cual debe ser un símbolo o cadena de texto. Para ver
 265 ejemplos sobre operadores como @code{if}, @code{do} o @code{lambda}
 266 el argumento debe ser necesariamente una cadena de texto, como
 267 @code{example ("do")}. La función @code{example} no distingue entre minúsculas
 268 y mayúsculas. La mayor parte de ejemplos versan sobre funciones.
 269
 270 La sentencia @code{example ()} devuelve la lista de todos los ejemplos
 271 existentes.
 272
 273 El nombre del fichero que contine los ejemplos existentes se guarda en
 274 la variable global @code{manual_demo}, cuyo valor por defecto es
 275 @code{"manual.demo"}.
 276
 277 La función @code{example} no evalúa su argumento.
 278
 279 Ejemplos:
 280
 281 @c ===beg===
 282 @c example(append);
 283 @c example("lambda");
 284 @c example("allROOTS");
 285 @c ===end===
 286 @example
 287 (%i1) example(append);
 288 (%i2) append([x+y,0,-3.2],[2.5E+20,x])
 289 (%o2)                    [y + x, 0, - 3.2, 2.5E+20, x]
 290 (%o2)                                done
 291 (%i3) example("lambda");
 292 (%i4) lambda([x,y,z],z^2+y^2+x^2)
 293                                            2    2    2
 294 (%o4)                   lambda([x, y, z], z  + y  + x )
 295 (%i5) %(1,2,a)
 296                                      2
 297 (%o5)                               a  + 5
 298 (%i6) a+2+1
 299 (%o6)                                a + 3
 300 (%o6)                                done
 301 (%i7) example("allROOTS");
 302 (%i8) (1+2*x)^3 = 13.5*(1+x^5)
 303                                    3          5
 304 (%o8)                     (2 x + 1)  = 13.5 (x  + 1)
 305 (%i9) allroots(%)
 306 (%o9) [x = .8296749902129361, x = - 1.015755543828121,
 307 x = .9659625152196369 %i - .4069597231924075,
 308 x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
 309 (%o9)                                done
 310 @end example
 311
 312 @end deffn
 313
 314 @defvr {Variable opcional} manual_demo
 315 Valor por defecto: @code{"manual.demo"}
 316
 317 @code{manual_demo} especifica el nombre del fichero que contiene
 318 los ejemplo para la función @code{example}.
 319
 320 Véase @code{example}.
 321
 322 @end defvr
 323