Funciones y variables para la línea de comandos (Manual de Maxima 5.45.0)

Siguiente: Funciones y variables para la impresión, Anterior: Introducción a la línea de comandos, Subir: Línea de comandos [Índice general][Índice]

### 4.2 Funciones y variables para la línea de comandos

Variable del sistema: __

  `__` es la expresión de entrada que está siendo actualmente evaluada. Esto es, mientras se está evaluando una expresión de entrada, `__` es igual a expr.

  A `__` se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de `__` es simplificado, pero no evaluado, cuando su valor es mostrado en el terminal.

  La variable `__` es reconocida por `batch` y por `load`. Cuando un fichero es procesado por `batch`, la variable `__` tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load`, a la variable `__` se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `__` una expresión de entrada del fichero que está siendo procesado. En particular, si `load (filename)` es ejecutado desde el modo interactivo, entonces `__` almacena la expresión `load (filename)` mientras el fichero está siendo procesado.

  Véanse también `_` y `%`.

  Ejemplos:

      (%i1) print ("I was called as", __);
      I was called as print(I was called as, __)
      (%o1)              print(I was called as, __)
      (%i2) foo (__);
      (%o2)                     foo(foo(__))
      (%i3) g (x) := (print ("Current input expression =", __), 0);
      (%o3) g(x) := (print("Current input expression =", __), 0)
      (%i4) [aa : 1, bb : 2, cc : 3];
      (%o4)                       [1, 2, 3]
      (%i5) (aa + bb + cc)/(dd + ee + g(x));
                                  cc + bb + aa
      Current input expression = --------------
                                 g(x) + ee + dd
                                      6
      (%o5)                        -------
                                   ee + dd

Variable del sistema: _

  El símbolo `_` representa la última expresión de entrada (esto es, `%i1`, `%i2`, `%i3`, ...).

  Al símbolo `_` se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de `_` se simplifica (pero no se evalúa) cuando se muestra en el terminal.

  La variable `_` es reconocida por `batch` y por `load`. Cuando un fichero es procesado por `batch`, la variable `_` tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load`, a la variable `_` se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `_` una expresión de entrada del fichero que está siendo procesado.

  Véanse también `__` y `%`.

  Ejemplos:

      (%i1) 13 + 29;
      (%o1)                          42
      (%i2) :lisp $_
      ((MPLUS) 13 29)
      (%i2) _;
      (%o2)                          42
      (%i3) sin (%pi/2);
      (%o3)                           1
      (%i4) :lisp $_
      ((%SIN) ((MQUOTIENT) $%PI 2))
      (%i4) _;
      (%o4)                           1
      (%i5) a: 13$
      (%i6) b: 29$
      (%i7) a + b;
      (%o7)                          42
      (%i8) :lisp $_
      ((MPLUS) $A $B)
      (%i8) _;
      (%o8)                         b + a
      (%i9) a + b;
      (%o9)                          42
      (%i10) ev (_);
      (%o10)                         42

Variable del sistema: %

  El símbolo `%` representa la expresión de salida (esto es, `%o1`, `%o2`, `%o3`, ...) más reciente calculada por Maxima, independientemente de que la haya mostrado o no.

  La variable `%` es reconocida por `batch` y por `load`. Cuando un fichero es procesado por `batch`, la variable `%` tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por `load`, a la variable `%` se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a `%` una expresión de entrada del fichero que está siendo procesado.

  Véanse también `_`, `%%` y `%th`.

Variable del sistema: %%

  En una sentencia compuesta, como `block`, `lambda` o `(s_1, ..., s_n)`, `%%` es el valor de la sentencia previa.

  La variable `%%` no estÃ¡ definida cuando se utiliza en la primera sentencia, o fuera de una sentencia compuesta.

  `%%` se puede utilizar con `batch` y `load`, manteniendo en ambos casos el mismo significado que en el modo interactivo.

  Véase también `%`

  Ejemplos:

  Los siguientes dos ejemplos devuelven el mismo resultado.

      (%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
                                     21
      (%o1)                          --
                                     2
      (%i2) block ([prev], prev: integrate (x^5, x),
                     ev (prev, x=2) - ev (prev, x=1));
                                     21
      (%o2)                          --
                                     2

  Una sentencia compuesta puede contener otras sentencias compuestas. Independientemente de que una sentencia sea simple o compuesta, `%%` es el valor de la sentencia previa.

      (%i3) block (block (a^n, %%*42), %%/6);
                                       n
      (%o3)                         7 a

  Dentro de una sentencia compuesta, el valor de `%%` puede inspeccionarse en un punto de interrupción que se abra ejecutando la función `break`. Por ejemplo, escribiendo `%%;` en el siguiente ejemplo se obtiene `42`.

      (%i4) block (a: 42, break ())$

      Entering a Maxima break point. Type 'exit;' to resume.
      _%%;
      42
      _

Función: %th (i)

  Es el valor de la expresión de la i-ésima salida anterior. Esto es, si la siguiente expresión a calcular es la salida n-ésima, `%th (m)` es la salida (n - m)-ésima.

  `%th` es reconocido por `batch` y `load`, interpretándose de la misma manera que se acaba de indicar. Cuando un fichero es procesado por `load`, `%th` se refiere a los cálculos más recientes; `%th` no hace referencia a las expresiones de salida incluidas en el propio fichero que se está procesando.

  Véanse también `%` y `%%`

  Ejemplo:

  `%th` es útil en ficheros `batch` para hacer referencia a grupos de resultados recién obtenidos. En este ejemplo se asigna a `s` la suma de los cinco resultados.

      (%i1) 1;2;3;4;5;
      (%o1)                           1
      (%o2)                           2
      (%o3)                           3
      (%o4)                           4
      (%o5)                           5
      (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
      (%o6)                          15

Símbolo especial: ?

  Como prefijo de una función o nombre de variable, `?` significa que el nombre es de Lisp, no de Maxima. Por ejemplo, `?round` representa la función de Lisp `ROUND`. Véase `Lisp y Maxima` para más información.

  La notación `? word` (un símbolo de interrogación seguido de una palabra y separados por un espacio) equivale a `describe ("word")`. El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

Símbolo especial: ??

  La notación `?? palabra` (`??` seguido de un espacio y una palabra) equivale a `describe("palabra", inexact)`. El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

Variable opcional: inchar

  Valor por defecto: `%i`

  La variable `inchar` es el prefijo de las etiquetas de las expresiones introducidas por el usuario. Maxima crea automáticamente una etiqueta para cada expresión de entrada concatenando `inchar` y `linenum`.

  A `inchar` se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos `inchar`, `outchar` y `linechar` deben comenzar con caracteres diferentes; en caso contrario, sentencias como `kill(inlables)` pueden dar resultados inesperados.

  Véase también `labels`.

  Ejemplo:

      (%i1) inchar: "input";
      (%o1)                         input
      (input2) expand((a+b)^3);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (input3)

Variable del sistema: infolists

  Valor por defecto: `[]`

  La variable `infolists` es una lista con los nombres de todas las listas que guardan información sobre Maxima. Estas son:

  `labels`

    Todas las etiquetas `%i`, `%o` y `%t` con valores asignados.

  `values`

    Todos los átomos que son variables de usuario, no opciones de Maxima creadas con `:` o `::`.

  `functions`

    Todas las funciones de usuario creadas con `:=` o `define`.

  `arrays`

    Arreglos declarados y no declarados, creados por `:`, `::` o `:=`.

  `macros`

    Cualquier macro definida por el usuario.

  `myoptions`

    Todas las opciones inicializadas por el usuario, independientemente de que posteriormente hayan sido devueltas a sus valores por defecto.

  `rules`

    Reglas de patrones y simplificación definidas por el usuario, creadas con `tellsimp`, `tellsimpafter`, `defmatch` o `defrule`.

  `aliases`

    Átomos que tienen un "alias" definido por el usuario, creado por las funciones `alias`, `ordergreat` o `orderless` o por haber declarado el átomo como `noun` (nombre) con `declare`.

  `dependencies`

    Átomos que tienen dependencias funcionales, creados por las funciones `depends` o `gradef`.

  `gradefs`

    Funciones que tienen derivadas definidas por el usuario, creadas por la función `gradef`.

  `props`

    Todos los átomos que tengan cualquier propiedad que no sea de las mencionadas hasta ahora, como las establecidas por `atvalue`, `matchdeclare`, etc., así como propiedadas especificadas en la función `declare`.

  `let_rule_packages`

    Todos los paquetes de reglas `let` definidos por el usuario, junto con el paquete especial `default_let_rule_package`; `default_let_rule_package` es el nombre del paquete de reglas utilizado cuando no se use ningún otro especificado por el usuario.

Función: kill (a_1, ..., a_n)
Función: kill (labels)
Función: kill (inlabels, outlabels, linelabels)
Función: kill (n)
Función: kill ([m, n])
Función: kill (values, functions, arrays, ...)
Función: kill (all)
Función: kill (allbut (a_1, ..., a_n))

  Elimina todas las asignaciones (valor, función, arreglo o regla) hechas a los argumentos a_1, ..., a_n. Un argumento a_k puede ser un símbolo o el elemento de un array. Si a_k es elemento de un array, `kill` elimina la asignación hecha a este elemento sin afectar al resto del array.

  Se reconocen varios argumentos especiales. Se pueden combinar diferentes clases de argumentos, como por ejemplo, `kill (inlabels, functions, allbut (foo, bar))`.

  La instrucción `kill (labels)` borra todas las asignaciones asociadas a las etiquetas de entrada, de salida e intermedias creadas hasta el momento. La instrucción `kill (inlabels)` elimina únicamente las asignaciones de las etiquetas de entrada que comienzan con el valor actual de `inchar`. Del mismo modo, `kill (outlabels)` elimina únicamente las asignaciones de las etiquetas de salida que comienzan con el valor actual de `outchar`. Finalmente, `kill (linelabels)` elimina únicamente las asignaciones de las etiquetas de las expresiones intermedias que comienzan con el valor actual de `linechar`.

  La instrucción `kill (n)`, siendo n un entero, elimina las asignaciones de las últimas n etiquetas, tanto de entrada como de salida.

  La instrucción `kill ([m, n])` elimina las asignaciones hechas a las etiquetas de entrada y salida desde la m hasta lan.

  La instrucción `kill (infolist)`, siendo infolist cualquier elemento de `infolists` (como `values`, `functions` o `arrays`), elimina todas las asignaciones hechas a los elementos de infolist. Véase también `infolists`.

  La instrucción `kill (all)` elimina todas las asignaciones de todas las variables, pero no reinicia las variables globales a sus valores por defecto. Véase también `reset`.

  La instrucción `kill (allbut (a_1, ..., a_n))` elimina las asignaciones hechas a todas las variables, excepto a a_1, ..., a_n; la instrucción `kill (allbut (infolist))` elimina todas las asignaciones, excepto las de los elementos de infolist, pudiendo ser infolist igual a `values`, `functions`, `arrays`, etc.

  La memoria reservada para una asignación no se libera hasta que no se vacíen todos los símbolos asociados con esta asignación; por ejemplo, para liberar la memoria del valor de un símbolo es necesario eliminar tanto la asignación de la etiqueta de salida que muestra el resultado, como la del propio símbolo.

  La función `kill` no evalua sus argumentos. El operador comilla-comilla, `''`, obliga a que se realice la evaluación.

  La llamada `kill (symbol)` elimina todas las propiedades de symbol. Por el contrario, `remvalue`, `remfunction`, `remarray` y `remrule` eliminan propiedades específicas.

  `kill` siempre devuelve `done`, incluso cuando alguno de sus argumentos carecía de asignación previa.

Función: labels (symbol)
Variable del sistema: labels

  Retorna la lista de etiquetas de entrada, salida o de expresiones intermedias las cuales empiezan con symbol. Típicamente symbol es el valor de las variables `inchar`, `outchar` o `linechar`. El caractér de etiqueta puede ser pasado con o sin signo de porcentaje, así, por ejemplo, `i` y `%i` producen el mismo resultado.

  Si ninguna etiqueta empieza con symbol, `labels` retorna a una lista vacía.

  La función `labels` no evalua su argumento. El operador comilla-comilla, `''`, obliga a que se realice la evaluación. Por ejemplo, `labels (''inchar)` devuelve las etiquetas de entrada que empiezan con el caractér de etiqueta de entrada actual.

  La variable `labels` es una lista de las etiquetas de entrada, salida y expresiones intermedias, incluyendo todas las etiquetas anteriores en el caso de que `inchar`, `outchar` o `linechar` hayan sido redefinidas.

  Por defecto, Maxima muestra el resultado de cada expresión introducida por el usuario, asignando al resultado una etiqueta de salida. La salida (es decir el resultado) puede ser suprimida terminando la expresión de entrada con un `$` (signo de dólar) en vez de un `;` (punto y coma). En este caso, se crea la etiqueta de salida y se le asigna el resultado, aunque éste no se muestre; aún así, la etiqueta puede ser referenciada de la misma forma que se hace con aquéllas cuyos resultados sí son mostrados.

  Véanse también: `%`, `%%` y `%th`.

  Las etiquetas de expresiones intermedias pueden ser generadas por algunas funciones. El interruptor `programmode` controla si `solve` y algunas otras funciones generan etiquetas de expresiones intermedias en vez de retornar una lista de expresiones. Algunas otras funciones, tales como `ldisplay`, siempre generan etiquetas de expresiones intermedias.

  Véase también: `inchar`, `outchar`, `linechar` y `infolists`.

Variable opcional: linechar

  Valor por defecto: `%t`

  La variable `linechar` es el prefijo de las etiquetas que genera Maxima para expresiones intermedias. Cuando sea necesario, Maxima creará una etiqueta para cada expresión intermedia concatenando `linechar` y `linenum`.

  A `linechar` se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos `inchar`, `outchar` y `linechar` deben comenzar con caracteres diferentes; en caso contrario, sentencias como `kill(inlables)` pueden dar resultados inesperados.

  Las expresiones intermedias pueden ser mostradas o no. Véanse también `programmode` y `labels`.

Variable del sistema: linenum

  El número de la línea del par de expresiones de entrada y salida actuales.

Variable del sistema: myoptions

  Valor por defecto: `[]`

  `myoptions` es la lista de todas las opciones que nunca fueron reconfiguradas por el usuario, aunque éstas hayan sido reconfiguradas a su valor por defecto.

Variable opcional: nolabels

  Valor por defecto: `false`

  Cuando `nolabels` vale `true`, las etiquetas de entrada y salida (`%i` y `%o`, respectivamente) son mostradas, pero a éstas no se les asignan los resultados; además, las etiquetas no se incorporan a la lista `labels`. Puesto que a las etiquetas no se les asignan resultados, el colector de basura puede recuperar la memoria ocupada por éstos.

  En el caso contrario, a las etiquetas de entrada y salida se les asignan los resultados correspondientes y son añadidas a la lista `labels`.

  Las etiquetas de expresiones intermedias (`%t`) no se ven afectadas por la variable `nolabels`; independientemente de que `nolabels` valga `true` o `false`, a las etiquetas de expresiones intermedias se les asignan siempre valores, además de ser añadidas a la lista `labels`.

  Véanse también `batch`, `batchload` y `labels`.

Variable opcional: optionset

  Valor por defecto: `false`

  Cuando `optionset` tiene como valor `true`, Maxima imprime un mensaje cada vez que una opción de Maxima es reconfigurada. Esto es muy útil si el usuario duda con frecuencia de la correctitud de alguna opción y quiere estar seguro de la variable a la que él asignó un valor fue verdaramente una variable opción (o interruptor).

  Ejemplo:

      (%i1) optionset:true;
      assignment: assigning to option optionset
      (%o1)                         true
      (%i2) gamma_expand:true;
      assignment: assigning to option gamma_expand
      (%o2)                         true

Variable opcional: outchar

  Valor por defecto: `%o`

  La variable `outchar` es el prefijo de las etiquetas de las expresiones calculadas por Maxima. Maxima crea automáticamente una etiqueta para cada expresión calculada concatenando `outchar` y `linenum`.

  A `outchar` se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos `inchar`, `outchar` y `linechar` deben comenzar con caracteres diferentes; en caso contrario, sentencias como `kill(inlables)` pueden dar resultados inesperados.

  Véase también `labels`.

  Ejemplo:

      (%i1) outchar: "output";
      (output1)                    output
      (%i2) expand((a+b)^3);
                           3        2      2      3
      (output2)           b  + 3 a b  + 3 a  b + a
      (%i3)

Función: playback ()
Función: playback (n)
Función: playback ([m, n])
Función: playback ([m])
Función: playback (input)
Función: playback (slow)
Función: playback (time)
Función: playback (grind)

  Muestra las entradas, salidas y expresiones intermedias sin recalcularlas. `playback` sólo muestra las expresiones asociadas con etiquetas; cualquier otra salida (tal como texto impreso por `print` o `describe`, o mensajes de error) no es mostrada. Véase también: `labels`.

  `playback` no evalua sus argumentos. El operador comilla-comilla, `''`, obliga a que se realice la evaluación. `playback` siempre devuelve `done`.

  `playback ()` (sin argumentos) muestra todas las entradas, salidas y expresiones intermedias generadas hasta el momento. Una expresión de salida es mostrada incluso si ésta fue suprimida por el caracter de terminación `$`, cuando fue originalmente calculada.

  `playback (n)` muestra las n expresiones más recientes. Cada entrada, salida y expresión intermedia cuenta como una.

  `playback ([m, n])` muestra entradas, salidas y expresiones intermedias con los números desde m hasta n, ambos inclusive.

  `playback ([m])` es equivalente a `playback ([m, m])`; esto usualmente imprime un par de expresiones de entrada y salida.

  `playback (input)` muestra todas las expresiones de entrada generadas hasta el momento.

  `playback (slow)` hace pausas entre expresiones y espera a que el usuario pulse la tecla `enter` para continuar. Esto es un comportamiento similar a `demo`.

  `playback (slow)` es muy útil en conjunción con `save` o `stringout` cuando se crea un archivo secundario de almacenamiento con el objetivo de elegir cuidadosamente las expresiones realmente útiles.

  `playback (time)` muestra el tiempo de computo por cada expresión.

  `playback (grind)` muestra las expresiones de entrada en el mismo formato como la función `grind`. Las expresiones de salida no se ven afectadas por la opción `grind`. Vea `grind`. Los argumentos pueden ser combinados, por ejemplo, `playback ([5, 10], grind, time, slow)`.

Variable opcional: prompt

  Valor por defecto: `_`

  `prompt` es el símbolo del prompt de la función `demo`, del modo `playback (slow)` y del bucle de interrupción de Maxima (el que se invoca con `break`).

Función: quit ()

  Termina una sesión de Maxima. Nótese que la función debe ser invocada como `quit();` o `quit()$`, no como `quit`.

  Para parar un cálculo muy demorado pulse `Control-C`. La acción por defecto es retornar a prompt de Maxima. Si `*debugger-hook*` tiene como valor `nil`, pulsar `Control-C` abrirá el depurador de Lisp. Vea también: `debugging`.

Función: read (expr_1, ..., expr_n)

  Imprime expr_1, ..., expr_n y a continuación lee una expresión desde la consola y devuelve la expresión evaluada. La expresión termina con un punto y coma `;` o con el símbolo de dólar `$`.

  Véase también `readonly`.

      (%i1) foo: 42$
      (%i2) foo: read ("foo vale", foo, " -- nuevo valor.")$
      foo vale 42  -- nuevo valor.
      (a+b)^3;
      (%i3) foo;
                                           3
      (%o3)                         (b + a)

Función: readonly (expr_1, ..., expr_n)

  Imprime expr_1, ..., expr_n y a continuación lee una expresión desde la consola y devuelve la expresión sin evaluar. La expresión termina con un punto y coma `;` o con el símbolo de dólar `$`.

      (%i1) aa: 7$
      (%i2) foo: readonly ("Introducir expresion:");
      Introducir expresion:
      2^aa;
                                        aa
      (%o2)                            2
      (%i3) foo: read ("Introducir expresion:");
      Introducir expresion:
      2^aa;
      (%o3)                            128

  Véase también `read`.

Función: reset ()

  Reconfigura muchas variables y opciones globales y algunas otras variables a sus valores por defecto.

  `reset` procesa las variables que se encuentran en la lista Lisp `*variable-initial-values*`. La macro Lisp `defmvar` pone las variables en ésta lista (entre otras acciones). Muchas, pero no todas, las variables y opciones globales son definidas por `defmvar`, y algunas variables definidas por `defmvar` no son ni variables ni opciones globales.

Variable opcional: showtime

  Valor por defecto: `false`

  Cuando `showtime` tiene como valor `true`, el tiempo de cálculo y el tiempo de retardo se imprimen junto con la salida de cada expresión.

  El tiempo de cálculo se almacena siempre, de manera que `time` y `playback` puedan mostrar el tiempo de cálculo incluso cuando `showtime` vale `false`.

  Véase también `timer`.

Function: to_lisp ()

  Entra en el intérprete Lisp bajo Maxima. `(to-maxima)` retorna de nuevo a Maxima.

  Ejemplo:

  Define una función y entra en el nivel Lisp. La definición se consulta en la lista de propiedades, luego se extrae la definición de la función, se factoriza y almacena el resultado en la variable `$result`. Esta variable se puede utilizar luego una vez se haya vuelto al nivel de Maxima.

      (%i1) f(x):=x^2+x;
                                               2
      (%o1)                           f(x) := x  + x
      (%i2) to_lisp();
      Type (to-maxima) to restart, ($quit) to quit Maxima.

      MAXIMA> (symbol-plist '$f)
      (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X) ((MPLUS) ((MEXPT) $X 2) $X))))
      MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
      ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
      MAXIMA> (to-maxima)
      Returning to Maxima
      (%o2)                                true
      (%i3) result;
      (%o3)                              x (x + 1)

Variable del sistema: values

  Valor inicial: `[]`

  `values` es una lista de todas las variables que el usuario ha creado (no incluye las opciones de Maxima ni los interruptores). La lista comprende los símbolos a los que se ha asignado un valor mediante `:` o `::`.

  Si el valor de una variable se borra con cualquiera de las instrucciones `kill`, `remove` o `remvalue`, dicha variable desaparece de la lista `values`.

  Véase `functions` para una lista de funciones definidas por el usuario.

  Ejemplos:

  Primero, `values` muestra los símbolos `a`, `b` y `c`, pero no `d`, pues no tiene valor asignado, ni la función de usuario `f`. Luego los valores de las variables se borran y `values` queda como una lista vacía.

      (%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
                                                        2
      (%o1)                     [99, 9, 90, d, f(x) := x ]
      (%i2) values;
      (%o2)                              [a, b, c]
      (%i3) [kill(a), remove(b,value), remvalue(c)];
      (%o3)                          [done, done, [c]]
      (%i4) values;
      (%o4)                                 []

Siguiente: Funciones y variables para la impresión, Anterior: Introducción a la línea de comandos, Subir: Línea de comandos [Índice general][Índice]