Paquetes LaTeX externos | Aspose.TeX para .NET

Paquetes externos de LaTeX

La biblioteca Aspose.TeX incluye varios paquetes comunes de LaTeX. Por lo tanto, no tiene que preocuparse por cómo proporcionar estos paquetes al motor TeX de la biblioteca. Pero a veces (o con bastante frecuencia) su archivo LaTeX puede requerir un paquete más allá del “paquete” de paquetes admitido “de forma nativa”. Si este es el caso, puede intentar proporcionar la entrada requerida, es decir, los archivos fuente del paquete requerido, a través de la opción RequiredInputDirectory de la instancia de clase TeXOptions. Veremos cómo funciona esto con dos ejemplos.

Entrada requerida desempaquetada (paquete fancybox)

Digamos que tenemos el siguiente archivo LaTeX simple, que es required-input-fs.tex de nuestra solución de ejemplo:

\documentclass{article}
\usepackage[a6paper,landscape]{geometry}
\usepackage{fancybox}
\begin{document}
Test: \fbox{
  \begin{Bitemize}[b]
  \item First item
  \item A second one\\ on two lines
  \item(2pt) A third with extra space
  \end{Bitemize}
}
\par\bigskip
Test: \fbox{
  \begin{Beqnarray}[t]
  y & = & x^2 \\
  a^2 + 2ab + b^2 & = & (a + b)^2 \\
  \int_0^\infty e^{-ax} dx & = & \frac{1}{a}
  \end{Beqnarray}
}
\end{document}

En la tercera línea, podemos ver que el archivo requiere el paquete fancybox, que no es compatible “de forma nativa”. Supongamos también que tenemos el archivo fuente del paquete fancybox. Es un paquete simple, por lo que realmente consta de un único archivo. Podemos colocar este archivo en cualquier lugar de nuestro sistema de archivos y especificar la ruta del directorio de la manera más simple que se muestra a continuación:

options.RequiredInputDirectory = new InputFileSystemDirectory("path-to-directory-where-fancybox.sty-located");

Después de ejecutar un trabajo TeX con esta opción (no olvide ajustar las otras opciones según sea necesario), obtenemos el documento de salida (es decir, una imagen PNG).

Aquí está el código fuente completo del ejemplo:

// External LaTeX packages from file system

// Create conversion options for Object LaTeX format upon Object TeX engine extension.
TeXOptions options = TeXOptions.ConsoleAppOptions(TeXConfig.ObjectLaTeX);
// Specify a file system working directory for the output.
options.OutputWorkingDirectory = new OutputFileSystemDirectory(OutputDir);
// Specify a file system working directory for the required input.
// The directory containing packages may be located anywhere.
options.RequiredInputDirectory = new InputFileSystemDirectory(Path.Combine(DataDir, "packages"));
// Initialize the options for saving in PNG format.
options.SaveOptions = new PngSaveOptions();
// Run LaTeX to PNG conversion.
new TeXJob(Path.Combine(DataDir, "required-input-fs.tex"), new ImageDevice(), options).Run();

Entrada requerida archivada (paquete pgfplots)

Digamos ahora que tenemos el siguiente archivo LaTeX también bastante simple, que es required-input-zip.tex de nuestra solución de ejemplo:

\documentclass{article}
\usepackage[margin=0.25in]{geometry}
\usepackage{pgfplots}
\pgfplotsset{width=10cm,compat=1.18}
\begin{document}

First example is 2D and 3D math expressions plotted side-by-side.

%Here begins the 2D plot
\begin{tikzpicture}
\begin{axis}
\addplot[color=red]{exp(x)};
\end{axis}
\end{tikzpicture}
%Here ends the 2D plot
\hskip 5pt
%Here begins the 3D plot
\begin{tikzpicture}
\begin{axis}
\addplot3[
    surf,
]
{exp(-x^2-y^2)*x};
\end{axis}
\end{tikzpicture}
%Here ends the 3D plot

\end{document}

En la tercera línea, podemos ver que el archivo requiere el paquete pgfplots, que tampoco es compatible de forma “nativa”. Nuevamente, asumimos que tenemos los archivos fuente del paquete pgfplots. Es una cantidad bastante grande de archivos que se dividen en dos ubicaciones si los encuentra en el directorio de instalación de cualquier aplicación de composición tipográfica LaTeX. Puede encontrar la carpeta pgfplots en las carpetas \tex\generic y \tex\latex. Y el contenido de ambas carpetas debe proporcionarse como entrada requerida para la biblioteca Aspose.TeX. Queremos que estos archivos fuente estén empaquetados en un archivo ZIP, así que aquí está el diseño del archivo:

Y así es como especificamos el acceso a estos archivos fuente:

using (Stream zipStream = File.Open("path-to-zip-with-pgfplots-sources"), FileMode.Open))
{
    ...
    options.RequiredInputDirectory = new InputZipDirectory(zipStream);
    ...
}

Después de ejecutar un trabajo TeX con esta opción, obtenemos el documento de salida:

Aquí está el código fuente completo del ejemplo:

// External LaTeX packages from ZIP archive

// Create conversion options for Object LaTeX format upon Object TeX engine extension.
TeXOptions options = TeXOptions.ConsoleAppOptions(TeXConfig.ObjectLaTeX);
// Specify a file system working directory for the output.
options.OutputWorkingDirectory = new OutputFileSystemDirectory(OutputDir);
// Initialize the options for saving in PNG format.
options.SaveOptions = new PngSaveOptions();
// Create a file stream for the ZIP archive containing the required package.
// The ZIP archive may be located anywhere.
using (Stream zipStream = File.Open(Path.Combine(DataDir, "packages\\pgfplots.zip"), FileMode.Open))
{
    // Specify a ZIP working directory for the required input.
    options.RequiredInputDirectory = new InputZipDirectory(zipStream, "");
    
    // Run LaTeX to PNG conversion.
    new TeXJob(Path.Combine(DataDir, "required-input-zip.tex"), new ImageDevice(), options).Run();
}

NOTA: El resultado se verificó utilizando la versión 1.18.1 del paquete pgfplots. Mientras que la versión del paquete pfg incluida en la biblioteca Aspose.TeX es la 3.1.9a.

Emplear paquetes de fuentes externos

Como regla general, las distribuciones de LaTeX proporcionan un conjunto de fuentes predeterminadas disponibles para la composición tipográfica. Excepto estas fuentes, Aspose.TeX incluye varios paquetes de fuentes no estándar. Por ejemplo, “amsfonts”, “eurosym” y “wasysym”. Como vimos anteriormente, Aspose.TeX también permite emplear paquetes externos. Pero sobre todo estábamos hablando de paquetes que no contienen fuentes. La extensión del motor Object TeX de Aspose.TeX necesita mapas de fuentes (que son archivos de texto en un formato determinado con la extensión .map por convención) para determinar qué fuentes físicas corresponden al nombre de fuente interno de cada TeX. . Estos mapas de fuentes deben cargarse en la memoria de TeX durante la fase de inicialización. Y, por supuesto, deben estar presentes entre los archivos del paquete que está conectando. Como el motor no conoce los nombres de todos los mapas de fuentes, busca todos los archivos con la extensión .map. Por lo tanto, una implementación de la interfaz IInputWorkingDirectory que se utiliza como valor de la opción RequiredInputDirectory debe proporcionar una forma de acceder a colecciones de nombres de archivos por extensión. Más específicamente, esta implementación también debe implementar la interfaz IFileCollector. Las implementaciones estándar, InputFileSystemDirectory y InputZipDirectory, ya lo hacen.

A continuación, proporcionamos un ejemplo ilustrativo de un directorio de entrada personalizado requerido que también implementa la interfaz IFileCollector. Si bien nos centramos en recopilar nombres de archivos por extensión, omitimos intencionalmente los detalles del almacenamiento y recuperación de archivos.

// Custom implementation of IInputWorkingDirectory for external packages with fonts

// This is an implementation of IInputWorkingDirectory that is suitable for the TeX job's RequiredInputDirectory option
// in case required input contains fonts provided by external packages.
// The class additionally implements IFileCollector, which provides access to file collections by extension.
// This is necessary to load external font maps, which are files (outside TeX syntax) that map TeX's
// internal font names to file names of physical fonts.
public class RequiredInputDirectory : IInputWorkingDirectory, IFileCollector
{
    private Dictionary<string, Dictionary<string, string>> _fileNames =
        new Dictionary<string, Dictionary<string, string>>();

    public RequiredInputDirectory()
    {
    }

    // This method should preliminarily be called for each file entry that is supposed to be located inside
    // the required input directory. Inside is an example of how the dictionary of file names could be organized
    // for easy collection of file names by extension.
    // Here fileName is a full file name. This can be a file path on a file system, a URL, or whatever else (theoretically).
    public void StoreFileName(string fileName)
    {
        string extension = Path.GetExtension(fileName);
        string name = Path.GetFileNameWithoutExtension(fileName);
        
        Dictionary<string, string> files;
        if (!_fileNames.TryGetValue(extension, out files))
            _fileNames.Add(extension, files = new Dictionary<string, string>());

        files[name] = fileName;
    }

    // The IInputWorkingDirectory implementation.
    public NamedStream GetFile(string fileName, bool searchSubdirectories = false)
    {
        // Try to find the file in our stored files
        foreach (var extFiles in _fileNames.Values)
        {
            foreach (var file in extFiles.Values)
            {
                if (file.EndsWith(fileName) || Path.GetFileName(file) == fileName)
                {
                    return new NamedStream(File.OpenRead(file), fileName);
                }
            }
        }
        // If not found in stored files, return null (file not available)
        return new NamedStream(null, fileName);
    }

    // Here is how we gather file collections by extension.
    public string[] GetFileNamesByExtension(string extension, string path = null)
    {
        Dictionary<string, string> files;
        if (!_fileNames.TryGetValue(extension, out files))
            return new string[0];

        return new List<string>(files.Values).ToArray();
    }

    public void Dispose()
    {
        _fileNames.Clear();
    }
}

Restricciones

Puede suceder que un paquete requerido por su archivo LaTeX esté desarrollado bajo el kernel LaTeX3e. Lo más probable es que un paquete de este tipo no funcione con la biblioteca Aspose.TeX ya que esta última se basa en el kernel LaTeX2e.

También puede suceder que un paquete requerido por su archivo LaTeX llame directamente a comandos primitivos dependientes del dispositivo que no son compatibles con el motor Object TeX de la biblioteca Aspose.TeX. Desafortunadamente, un paquete así no funcionará con seguridad.

Creación de un agente de IA para la optimización de paquetes integrados en LaTeX

Si necesita crear un agente de IA que optimice el contenido para el inventario de paquetes integrado sin realizar lentas búsquedas dinámicas en la red ni en el sistema de archivos durante la generación, puede utilizar el flujo de trabajo que se describe a continuación.

En lugar de obligar a un LLM a adivinar qué paquetes son seguros o rápidos de usar, el agente se centra en este inventario de paquetes precompilado específico para garantizar una composición de documentos 100 % fiable.

1. Extracción de la intención de diseño (capa de análisis del LLM) El usuario proporciona datos multiformato no estructurados o directivas conversacionales. El LLM asigna las solicitudes directamente a la lista de paquetes integrados de Aspose (colortbl para sombreado de filas, geometry para márgenes, hyperref para seguimiento y tabularx para columnas de ancho variable).

2. Aislamiento del AST e inyección de preámbulo En lugar de escribir importaciones de paquetes voluminosas, el agente verifica los requisitos del código con su manifiesto de motores nativos prealmacenado.

Escribe las rutas de optimización estructural directamente en la cadena del preámbulo del código.

3. Aislamiento y ejecución de flujos (Nodo del motor Aspose.TeX) El flujo de tokens compilado, junto con sus entornos de macros, se distribuye a los nodos de trabajo aislados. El sistema configura un perfil de ejecución de aplicación TeXOptions estricto utilizando el perfil de ensamblaje optimizado (p. ej., TeXConfig.ObjectLaTeX). Ejecuta de forma segura una canalización de ejecución de TeXJob sin bloqueo, completamente dentro del búfer de flujo en memoria.

\usepackage[a4paper,margin=0.5in]{geometry}
\usepackage{amsmath,tabularx,colortbl,hyperref}

4. Serialización de recursos (Capa de renderizado de salida) El sistema asigna coordenadas de destino y procesa los límites de salida, utilizando matrices de ejecución vectorial (PdfDevice o SvgDevice) para devolver diseños de documentación nítidos instantáneamente a la interfaz del cliente.