Funciones y variables para salida TeX (Manual de Maxima 5.44.0)

Siguiente: Funciones y variables para salida Fortran, Anterior: Funciones y variables para lectura y escritura, Subir: Lectura y escritura [Índice general][Índice]

### 13.4 Funciones y variables para salida TeX

Función: tex (expr)
Función: tex (expr, destination)
Función: tex (expr, false)
Función: tex (label)
Función: tex (label, destination)
Función: tex (label, false)

  Devuelve la expresión en un formato apropiado para para ser incorporado a un documento basado en TeX. El resultado que se obtiene es un fragmento de código que puede incluirse en un documento mayor, pero que no puede ser procesado aisladamente.

  La instrucción `tex (expr)` imprime en la consola la representación en TeX de expr.

  La instrucción `tex (label)` imprime en la consola la representación en TeX de la expresión a la que hace referencia la etiqueta label, asignándole a su vez una etiqueta de ecuación que será mostrada al lado izquierdo de la misma. La etiqueta de la expresión en TeX es la misma que la de Maxima.

  destination puede ser tanto un flujo de salida como el nombre de un fichero.

  Si destination es el nombre de un fichero, `tex` añade la salida al fichero. Las funciones `openw` y `opena` crean flujos de salida.

  Las instrucciones `tex (expr, false)` y `tex (label, false)` devuelven el código TeX en formato de cadena.

  La función `tex` evalúa su primer argumento tras comprobar si se trata de una etiqueta. La doble comilla simple `''` fuerza la evaluación del argumento, anulando la comprobación sobre la etiqueta.

  Véase también `texput`.

  Ejemplos:

      (%i1) integrate (1/(1+x^3), x);
                                          2 x - 1
                        2            atan(-------)
                   log(x  - x + 1)        sqrt(3)    log(x + 1)
      (%o1)      - --------------- + ------------- + ----------
                          6             sqrt(3)          3
      (%i2) tex (%o1);
      $$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
       }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
       }\over{3}}\leqno{\tt (\%o1)}$$
      (%o2)                          (\%o1)
      (%i3) tex (integrate (sin(x), x));
      $$-\cos x$$
      (%o3)                           false
      (%i4) tex (%o1, "foo.tex");
      (%o4)                          (\%o1)

  `tex (expr, false)` devuelve el código TeX en formato de cadena.

      (%i1) S : tex (x * y * z, false);
      (%o1) $$x\,y\,z$$
      (%i2) S;
      (%o2) $$x\,y\,z$$

Función: tex1 (e)

  Devuelve una cadena con el código TeX de la expresión e. El código TeX no se encierra entre delimitadores para una ecuación ni cualesquiera otros entornos.

  Ejemplo:

      (%i1) tex1 (sin(x) + cos(x));
      (%o1)                     \sin x+\cos x

Función: texput (a, s)
Función: texput (a, f)
Función: texput (a, s, operator_type)
Función: texput (a, [s_1, s_2], matchfix)
Función: texput (a, [s_1, s_2, s_3], matchfix)

  Establece el formato en TeX del átomo a, el cual puede ser un símbolo o el nombre de un operador.

  La instrucción `texput (a, s)` hace que la función `tex` introduzca s en la salida TeX en el lugar de a.

  La instrucción `texput (a, f)` hace que `tex` llame a la función f para que genere código TeX. La función f debe aceptar un único argumento, el cual es una expresión que tenga como operador a y que devuelva una cadena con el código TeX. Esta función puede llamar a `tex1` para generar el código TeX para los argumentos de la expresión de entrada.

  La instrucción `texput (a, s, operator_type)`, en la que operator_type es `prefix`, `infix` o `postfix`, `nary` o `nofix`,hace que la función `tex` introduzca s en la salida TeX en el lugar de a, colocándolo en el lugar correcto.

  La instrucción `texput (a, [s_1, s_2], matchfix)` hace que la función `tex` introduzca s_1 y s_2 en la salida TeX a los lados de los argumentos de a. Si son más de uno, los argumentos se separan por comas.

  La instrucción `texput (a, [s_1, s_2, s_3], matchfix)` hace que la función `tex` introduzca s_1 y s_2 en la salida TeX a los lados de los argumentos de a, con s_3 separando los argumentos.

  Ejemplos:

  Asigna código TeX para una variable.

  Llama a una función que genera código TeX.

      (%i1) texfoo (e) := block ([a, b], [a, b] : args (e),
        concat ("\\left[\\stackrel{", tex1 (b),
                "}{", tex1 (a), "}\\right]"))$
      (%i2) texput (foo, texfoo);
      (%o2)                        texfoo
      (%i3) tex (foo (2^x, %pi));
      $$\left[\stackrel{\pi}{2^{x}}\right]$$
      (%o3)                         false

      (%i1) texput (me,"\\mu_e");
      (%o1)                         \mu_e
      (%i2) tex (me);
      $$\mu_e$$
      (%o2)                         false

  Asigna código TeX para una función ordinaria (no para un operador).

      (%i1) texput (lcm, "\\mathrm{lcm}");
      (%o1)                     \mathrm{lcm}
      (%i2) tex (lcm (a, b));
      $$\mathrm{lcm}\left(a , b\right)$$
      (%o2)                         false

  Asigna código TeX para un operador prefijo.

      (%i1) prefix ("grad");
      (%o1)                         grad
      (%i2) texput ("grad", " \\nabla ", prefix);
      (%o2)                        \nabla
      (%i3) tex (grad f);
      $$ \nabla f$$
      (%o3)                         false

  Asigna código TeX para un operador infijo.

      (%i1) infix ("~");
      (%o1)                           ~
      (%i2) texput ("~", " \\times ", infix);
      (%o2)                        \times
      (%i3) tex (a ~ b);
      $$a \times b$$
      (%o3)                         false

  Asigna código TeX para un operador postfijo..

      (%i1) postfix ("##");
      (%o1)                          ##
      (%i2) texput ("##", "!!", postfix);
      (%o2)                          !!
      (%i3) tex (x ##);
      $$x!!$$
      (%o3)                         false

  Asigna código TeX para un operador n-ario.

      (%i1) nary ("@@");
      (%o1)                          @@
      (%i2) texput ("@@", " \\circ ", nary);
      (%o2)                         \circ
      (%i3) tex (a @@ b @@ c @@ d);
      $$a \circ b \circ c \circ d$$
      (%o3)                         false

  Asigna código TeX para un operador "no-fijo".

      (%i1) nofix ("foo");
      (%o1)                          foo
      (%i2) texput ("foo", "\\mathsc{foo}", nofix);
      (%o2)                     \mathsc{foo}
      (%i3) tex (foo);
      $$\mathsc{foo}$$
      (%o3)                         false

  Asigna código TeX para un operador "bi-fijo" (matchfix).

      (%i1) matchfix ("<<", ">>");
      (%o1)                          <<
      (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
      (%o2)                [ \langle ,  \rangle ]
      (%i3) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o3)                         false
      (%i4) tex (<<a, b>>);
      $$ \langle a , b \rangle $$
      (%o4)                         false
      (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
            matchfix);
      (%o5)           [ \langle ,  \rangle ,  \, | \,]
      (%i6) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o6)                         false
      (%i7) tex (<<a, b>>);
      $$ \langle a \, | \,b \rangle $$
      (%o7)                         false

Función: get_tex_environment (op)
Función: set_tex_environment (op, before, after)

  Gestiona el entorno de las salidas TeX que se obtienen de la función `tex`. El entorno TeX está formado por dos cadenas: una que se escribe antes que cualquier salida en TeX, y otra que se escribe después.

  `get_tex_environment` devuelve el entorno TeX que se aplica al operador op. Si no se ha asignado ningún entorno, devolverá el que tenga por defecto.

  `set_tex_environment` asigna el entorno TeX al operador op.

  Ejemplos:

      (%i1) get_tex_environment (":=");
      (%o1) [
      \begin{verbatim}
      , ;
      \end{verbatim}
      ]
      (%i2) tex (f (x) := 1 - x);

      \begin{verbatim}
      f(x):=1-x;
      \end{verbatim}

      (%o2)                         false
      (%i3) set_tex_environment (":=", "$$", "$$");
      (%o3)                       [$$, $$]
      (%i4) tex (f (x) := 1 - x);
      $$f(x):=1-x$$
      (%o4)                         false

Función: get_tex_environment_default ()
Función: set_tex_environment_default (before, after)

  Gestiona el entorno de las salidas TeX que se obtienen de la función `tex`. El entorno TeX está formado por dos cadenas: una que se escribe antes que cualquier salida en TeX, y otra que se escribe después.

  `get_tex_environment_default` devuelve el entorno TeX que se aplica a expresiones para las cuales el operador de mayor rango no tiene entorno TeX asignado (mediante `set_tex_environment`).

  `set_tex_environment_default` asigna el entorno TeX por defecto.

  Ejemplos:

      (%i1) get_tex_environment_default ();
      (%o1)                       [$$, $$]
      (%i2) tex (f(x) + g(x));
      $$g\left(x\right)+f\left(x\right)$$
      (%o2)                         false
      (%i3) set_tex_environment_default ("\\begin{equation}
      ", "
      \\end{equation}");
      (%o3) [\begin{equation}
      ,
      \end{equation}]
      (%i4) tex (f(x) + g(x));
      \begin{equation}
      g\left(x\right)+f\left(x\right)
      \end{equation}
      (%o4)                         false

Siguiente: Funciones y variables para salida Fortran, Anterior: Funciones y variables para lectura y escritura, Subir: Lectura y escritura [Índice general][Índice]