Funciones y variables para la impresión (Manual de Maxima 5.44.0)

Anterior: Funciones y variables para la línea de comandos, Subir: Línea de comandos [Índice general][Índice]

### 4.3 Funciones y variables para la impresión

Variable opcional: %edispflag

  Valor por defecto: `false`

  Si `%edispflag` vale `true`, Maxima muestra `%e` elevado a un exponente negativo como un cociente. Por ejemplo, `%e^-x` se muestra como `1/%e^x`. Véase también `exptdispflag`.

  Ejemplo:

      (%i1) %e^-10;
                                     - 10
      (%o1)                        %e
      (%i2) %edispflag:true$
      (%i3) %e^-10;
                                     1
      (%o3)                         ----
                                      10
                                    %e

Variable opcional: absboxchar

  Valor por defecto: `!`

  La variable `absboxchar` es el carácter utilizado para representar el valor absoluto de una expresión que ocupa más de una línea de altura.

  Ejemplo:

      (%i1) abs((x^3+1));
                                  ! 3    !
      (%o1)                       !x  + 1!

Función: disp (expr_1, expr_2, ...)

  Es como `display` pero sólo se muestran los valores de los argumentos, no las ecuaciones. Es útil para argumentos complicados que no tienen nombre o en situaciones en las que solamente es de interés el valor del argumento pero no su nombre.

  Véanse también `ldisp` y `print`.

  Ejemplos:

      (%i1) b[1,2]:x-x^2$
      (%i2) x:123$
      (%i3) disp(x, b[1,2], sin(1.0));
                                     123

                                        2
                                   x - x

                              .8414709848078965

      (%o3)                         done

Función: display (expr_1, expr_2, ...)

  Muestra las ecuaciones cuyos miembros izquierdos son expr_i sin evaluar y cuyos miembros derechos son los valores de las expresiones. Esta función es útil en los bloques y en las sentencias `for` para mostrar resultados intermedios. Los argumentos de `display` suelen ser átomos, variables subindicadas o llamadas a funciones.

  Véanse también `ldisplay`, `disp` y `ldisp`.

  Ejemplos:

      (%i1) b[1,2]:x-x^2$
      (%i2) x:123$
      (%i3) display(x, b[1,2], sin(1.0));
                                   x = 123

                                            2
                               b     = x - x
                                1, 2

                        sin(1.0) = .8414709848078965

      (%o3)                         done

Variable opcional: display2d

  Valor por defecto: `true`

  Si `display2d` vale `false`, la salida por consola es una cadena unidimensional, en lugar de una expresión bidimensional.

  Véase también `leftjust` para cambiar la justificación a la izquierda o el centrado de la ecuación.

  Ejemplo:

      (%i1) x/(x^2+1);
                                     x
      (%o1)                        ------
                                    2
                                   x  + 1
      (%i2) display2d:false$
      (%i3) x/(x^2+1);
      (%o3) x/(x^2+1)

Variable opcional: display_format_internal

  Valor por defecto: `false`

  Si `display_format_internal` vale `true`, las expresiones se muestran sin ser transformadas de manera que oculten su representación matemática interna. Se representa lo que la función `inpart` devolvería, en oposición a `part`.

  Ejemplos:

      User     part       inpart
      a-b;      a - b     a + (- 1) b

                 a            - 1
      a/b;       -         a b
                 b
                             1/2
      sqrt(x);   sqrt(x)    x

                4 X        4
      X*4/3;    ---        - X
                 3         3

Función: dispterms (expr)

  Muestra expr en partes, una debajo de la otra. Esto es, primero se muestra el operador de expr, luego cada término si se trata de una suma, o cada factor si es un producto, o si no se muestra separadamente la parte de una expresión más general. Es útil si expr es demasiado grande para representarla de otra forma. Por ejemplo, si `P1`, `P2`, ... son expresiones muy grandes, entonces el programa de representación puede superar el espacio de almacenamiento tratando de mostrar `P1 + P2 + ...` todo junto. Sin embargo, `dispterms (P1 + P2 + ...)` muestra `P1`, debajo `P2`, etc. Cuando una expresión exponencial es demasiado ancha para ser representada como `A^B`, si no se utiliza `dispterms`, entonces aparecerá como `expt (A, B)` (o como `ncexpt (A, B)`, en lugar de `A^^B`).

  Ejemplo:

      (%i1) dispterms(2*a*sin(x)+%e^x);

      +

      2 a sin(x)

        x
      %e

      (%o1)                         done

Símbolo especial: expt (a, b)
Símbolo especial: ncexpt (a, b)

  Si una expresión exponencial es demasiado ancha para ser mostrada como `a^b` aparecerá como `expt (a, b)` (o como `ncexpt (a, b)` en lugar de `a^^b`).

  Las funciones `expt` y `ncexpt` no se reconocen en una entrada.

Variable opcional: exptdispflag

  Valor por defecto: `true`

  Si `exptdispflag` vale `true`, Maxima muestra las expresiones con exponentes negativos como cocientes. Véase también `%edispflag`.

  Ejemplo:

      (%i1) exptdispflag:true;
      (%o1)                         true
      (%i2) 10^-x;
                                      1
      (%o2)                          ---
                                       x
                                     10
      (%i3) exptdispflag:false;
      (%o3)                         false
      (%i4) 10^-x;
                                      - x
      (%o4)                         10

Función: grind (expr)
Variable opcional: grind

  La función `grind` imprime expr en la consola en un formato admisible como entrada para Maxima. La función `grind` devuelve siempre `done`.

  Cuando expr es el nombre de una función o macro, `grind` muestra la definición de la función o de la macro en lugar de sólo su nombre.

  Véase también `string`, que devuelve una cadena en lugar de imprimir la salida. La función `grind` intenta imprimir la expresión de forma que sea lago más sencilla de leer que la salida de `string`.

  Cuando la variable `grind` vale `true`, la salida de `string` y `stringout` tienen el mismo formato que la de `grind`; en caso contrario no se formatea la salida de esas funciones. El valor por defecto de la variable `grind` es `false`.

  La variable `grind` también se puede utilizar como argumento en `playback`. Si `grind` está presente, `playback` imprime las expresiones de entrada en el mismo formato que lo hace la función `grind`; en caso contrario no se formatean la expresiones de entrada.

  La función `grind` evalúa sus argumentos.

  Ejemplos:

      (%i1) aa + 1729;
      (%o1)                       aa + 1729
      (%i2) grind (%);
      aa+1729$
      (%o2)                         done
      (%i3) [aa, 1729, aa + 1729];
      (%o3)                 [aa, 1729, aa + 1729]
      (%i4) grind (%);
      [aa,1729,aa+1729]$
      (%o4)                         done
      (%i5) matrix ([aa, 17], [29, bb]);
                                 [ aa  17 ]
      (%o5)                      [        ]
                                 [ 29  bb ]
      (%i6) grind (%);
      matrix([aa,17],[29,bb])$
      (%o6)                         done
      (%i7) set (aa, 17, 29, bb);
      (%o7)                   {17, 29, aa, bb}
      (%i8) grind (%);
      {17,29,aa,bb}$
      (%o8)                         done
      (%i9) exp (aa / (bb + 17)^29);
                                      aa
                                  -----------
                                           29
                                  (bb + 17)
      (%o9)                     %e
      (%i10) grind (%);
      %e^(aa/(bb+17)^29)$
      (%o10)                        done
      (%i11) expr: expand ((aa + bb)^10);
               10           9        2   8         3   7         4   6
      (%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
               5   5         6   4         7   3        8   2
       + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
              9        10
       + 10 aa  bb + aa
      (%i12) grind (expr);
      bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
           +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
           +10*aa^9*bb+aa^10$
      (%o12)                        done
      (%i13) string (expr);
      (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
      +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
      bb+aa^10
      (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
        p : makelist (0, i, 1, length (A))], for i thru n do
        for j : i thru n do
        (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
        if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
        for i thru n do L[i, i] : 1 / p[i],
        for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
      (%i15) grind (cholesky);
      cholesky(A):=block(
               [n:length(A),L:copymatrix(A),
                p:makelist(0,i,1,length(A))],
               for i thru n do
                   (for j from i thru n do
                        (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                         if i = j then p[i]:1/sqrt(x)
                             else L[j,i]:x*p[i])),
               for i thru n do L[i,i]:1/p[i],
               for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
      (%o15)                        done
      (%i16) string (fundef (cholesky));
      (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
      t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
      [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
      ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
      n do (for j from i+1 thru n do L[i,j]:0),L)

Variable opcional: ibase

  Valor por defecto: `10`

  `ibase` es la base en la que Maxima lee valores enteros.

  A `ibase` se le puede asignar cualquier entero entre 2 y 36 (base decimal), ambos inclusive. Si `ibase` es mayor que 10, las cifras a utilizar serán los dígitos de 0 a 9, junto con las letras del alfabeto A, B, C, ..., tantas como sean necesarias para completar la base `ibase`. Las letras se interpretarán como cifras sólo cuando el primer dígito sea un valor entre 9. Es indiferente hacer uso de letras mayúsculas o minúsculas. Las cifras para la base 36, la mayor posible, son los dígitos numéricos de 0 a 9 y las letras desde la A hasta la Z.

  Cualquiera que sea el valor de `ibase`, si un entero termina con un punto decimal, se interpretará en base 10.

  Véase también `obase`.

  Ejemplos:

  `ibase` menor que 10.

      (%i1) ibase : 2 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1111111111111111;
      (%o3)                         65535

  `ibase` mayor que 10. Las letras se interpretan como dígitos sólo si el primer dígito es una cifra entre 0 y 9.

      (%i1) ibase : 16 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1000;
      (%o3)                         4096
      (%i4) abcd;
      (%o4)                         abcd
      (%i5) symbolp (abcd);
      (%o5)                         true
      (%i6) 0abcd;
      (%o6)                         43981
      (%i7) symbolp (0abcd);
      (%o7)                         false

  Independientemente del valor de `ibase`, si el entero termina con un punto decimal, se interpretará en base diez.

      (%i1) ibase : 36 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1234;
      (%o3)                         49360
      (%i4) 1234.;
      (%o4)                         1234

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

  Muestra las expresiones expr_1, ..., expr_n en la consola con el formato de salida; `ldisp` asigna una etiqueta a cada argumento y devuelve la lista de etiquetas.

  Véanse también `disp`, `display` y `ldisplay`.

      (%i1) e: (a+b)^3;
                                         3
      (%o1)                       (b + a)
      (%i2) f: expand (e);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (%i3) ldisp (e, f);
                                         3
      (%t3)                       (b + a)

                           3        2      2      3
      (%t4)               b  + 3 a b  + 3 a  b + a

      (%o4)                      [%t3, %t4]
      (%i4) %t3;
                                         3
      (%o4)                       (b + a)
      (%i5) %t4;
                           3        2      2      3
      (%o5)               b  + 3 a b  + 3 a  b + a

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

  Muestra las expresiones expr_1, ..., expr_n en la consola con el formato de salida. Cad expresión se muestra como una ecuación de la forma `lhs = rhs` en la que `lhs` es uno de los argumentos de `ldisplay` y `rhs` su valor. Normalmente, cada argumento será el nombre de una variable. La función `ldisp` asigna una etiqueta a cada ecuación y devuelve la lista de etiquetas.

  Véanse también `disp`, `display` y `ldisp`.

      (%i1) e: (a+b)^3;
                                         3
      (%o1)                       (b + a)
      (%i2) f: expand (e);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (%i3) ldisplay (e, f);
                                           3
      (%t3)                     e = (b + a)

                             3        2      2      3
      (%t4)             f = b  + 3 a b  + 3 a  b + a

      (%o4)                      [%t3, %t4]
      (%i4) %t3;
                                           3
      (%o4)                     e = (b + a)
      (%i5) %t4;
                             3        2      2      3
      (%o5)             f = b  + 3 a b  + 3 a  b + a

Variable opcional: linel

  Valor por defecto: `79`

  La variable `linel` es la anchura (medida en número de caracteres) de la consola que se le da a Maxima para que muestre las expresiones. A `linel` se le puede asignar cualquier valor, pero si éste es muy pequeño o grande resultará de poca utilidad. El texto que impriman las funciones internas de Maxima, como los mensajes de error y las salidas de la función `describe`, no se ve afectado por el valor de `linel`.

Variable opcional: lispdisp

  Valor por defecto: `false`

  Si `lispdisp` vale `true`, los símbolos de Lisp se muestran precedidos del carácter de interrogación `?`. En caso contrario, los símbolos de Lisp se muestran sin esta marca.

  Ejemplos:

      (%i1) lispdisp: false$
      (%i2) ?foo + ?bar;
      (%o2)                       foo + bar
      (%i3) lispdisp: true$
      (%i4) ?foo + ?bar;
      (%o4)                      ?foo + ?bar

Variable opcional: negsumdispflag

  Valor por defecto: `true`

  Si `negsumdispflag` vale `true`, `x - y` se muestra como `x - y` en lugar de `- y + x`. Dándole el valor `false` se realiza un análisis adicional para que no se representen de forma muy diferente dos expresiones similares. Una aplicación puede ser para que `a + %i*b` y `a - %i*b` se representen ambas de la misma manera.

Variable opcional: obase

  Valor por defecto: `10`

  `obase` es la base en la que Maxima imprime los números enteros.

  A `obase` se le puede asignar cualquier entero entre 2 y 36 (base decimal), ambos inclusive. Si `obase` es mayor que 10, las cifras a utilizar serán los dígitos de 0 a 9, junto con las letras del alfabeto A, B, C, ..., tantas como sean necesarias para completar la base `obase`. Si el primer dígito resulta ser una letra, se le añadirá el cero como prefijo. Las cifras para la base 36, la mayor posible, son los dígitos numéricos de 0 a 9 y las letras desde la A hasta la Z.

  Véase también `ibase`.

  Ejemplos:

      (%i1) obase : 2;
      (%o1)                          10
      (%i2) 2^8 - 1;
      (%o10)                      11111111
      (%i3) obase : 8;
      (%o3)                          10
      (%i4) 8^8 - 1;
      (%o4)                       77777777
      (%i5) obase : 16;
      (%o5)                          10
      (%i6) 16^8 - 1;
      (%o6)                       0FFFFFFFF
      (%i7) obase : 36;
      (%o7)                          10
      (%i8) 36^8 - 1;
      (%o8)                       0ZZZZZZZZ

Variable opcional: pfeformat

  Valor por defecto: `false`

  Si `pfeformat` vale `true`, una fracción de enteros será mostrada con el carácter de barra inclinada `/` entre ellos.

      (%i1) pfeformat: false$
      (%i2) 2^16/7^3;
                                    65536
      (%o2)                         -----
                                     343
      (%i3) (a+b)/8;
                                    b + a
      (%o3)                         -----
                                      8
      (%i4) pfeformat: true$
      (%i5) 2^16/7^3;
      (%o5)                       65536/343
      (%i6) (a+b)/8;
      (%o6)                      1/8 (b + a)

Variable opcional: powerdisp

  Valor por defecto: `false`

  Si `powerdisp` vale `true`, se muestran las sumas con sus términos ordenados de menor a mayor potencia. Así, un polinomio se presenta como una serie de potencias truncada con el término constante al principio y el de mayor potencia al final.

  Por defecto, los términos de una suma se muestran en el orden de las potencias decrecientes.

  Ejemplo:

      (%i1) powerdisp:true;
      (%o1)                         true
      (%i2) x^2+x^3+x^4;
                                 2    3    4
      (%o2)                     x  + x  + x
      (%i3) powerdisp:false;
      (%o3)                         false
      (%i4) x^2+x^3+x^4;
                                 4    3    2
      (%o4)                     x  + x  + x

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

  Evalúa y muestra las expresiones expr_1, ..., expr_n secuencialmente de izquierda a derecha, comenzando la impresión por el borde izquierdo de la consola.

  El valor devuelto por `print` es el valor de su último argumento. La función `print` no genera etiquetas para las expresiones intermedias.

  Véanse también `display`, `disp`, `ldisplay` y `ldisp`, que muestran una expresión por línea, mientras que `print` trata de mostrar dos o más expresiones por línea.

  Para mostrar el contenido de un archivo véase `printfile`.

      (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
            radcan (log (a^10/b)))$
                  3        2      2      3
      (a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is

                                                    10 log(a) - log(b)
      (%i2) r;
      (%o2)                  10 log(a) - log(b)
      (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
            radcan (log (a^10/b)))$
                                 (a+b)^3 is

                           3        2      2      3
                          b  + 3 a b  + 3 a  b + a

                               log (a^10/b) is

                             10 log(a) - log(b)

Variable opcional: sqrtdispflag

  Valor por defecto: `true`

  Si `sqrtdispflag` vale `false`, hará que `sqrt` se muestre con el exponente 1/2.

Variable opcional: stardisp

  Valor por defecto: `false`

  Si `stardisp` vale `true`, la multiplicación se muestra con un asterisco `*` entre los operandos.

Variable opcional: ttyoff

  Valor por defecto: `false`

  Si `ttyoff` vale `true`, no se muestran las expresiones resultantes, pero éstas se calculan de todos modos y se les asignan etiquetas. Véase `labels`.

  El texto que escriban las funciones internas de Maxima, tales como los mensajes de error y las salidas de `describe`, no se ven afectadas por `ttyoff`.

Anterior: Funciones y variables para la línea de comandos, Subir: Línea de comandos [Índice general][Índice]