J'essaie de trouver un moyen d'exporter un document Org avec beaucoup de formules en texte brut, mais les résultats ne sont pas excellents jusqu'à présent.

Ce que j'ai essayé:

1. pandoc - maintient fondamentalement toutes les mathématiques dans LaTeX inchangées, ne dépouille même pas les créateurs d'environnement.
2. detex - ne remplace pas les symboles grecs (les supprime simplement), il y a des artefacts dans les formules produites (sa esperluette laissée par l'alignement, etc.)
3. tex2mail - semble drôle et très difficile à lire, laisse des artefacts, des marqueurs d'environnement, etc.
4. catdvi - est le meilleur jusqu'à présent, cependant, je n'en ai besoin que pour fonctionner sur les fragments LaTeX du fichier Org, le reste du fichier semble très mauvais (indentation, titres, etc.).
5. hevea- ce programme est utilisé par texi2dvipour générer une sortie texte. Cela ne fonctionne pas vraiment, la sortie semble très étrange / certaines lettres grecques sont traduites en Unicode, d'autres non, l'alignement est tout faux ...

Je pourrais probablement écrire un backend spécial pour exporter d'abord tous les fragments LaTeX vers DVI puis pour les exécuter catdvi, mais avant d'y arriver, peut-être y a-t-il un moyen plus simple de le faire?

Donc, voici quelque chose que j'ai trouvé, mais ce n'est toujours pas parfait. Il y a deux problèmes principaux:

1. catdvine peut pas être fait pour utiliser les indices et les exposants Unicode, au lieu de cela, il place des caractères de taille normale sur la ligne ci-dessous et au-dessus, ce qui fait que les bits LaTeX en ligne semblent mauvais. Il y a aussi des problèmes connexes tels que le rendu de \frac{}{}, \binom{}{}et en ligne similaires, où ils apparaissent sur la même ligne et complètement se désintégrer en texte qui l' entoure.

2. Le code multiligne LaTeX est nettement meilleur, mais catdviajoute parfois des lignes vierges supplémentaires (il est difficile de savoir s'il faut les supprimer, mais je pourrais post-traiter la sortie pour supprimer les lignes vides).

Voici le code que j'ai utilisé et quelques exemples générés:

(defmacro by-backend (&rest body)
  `(cl-case (when (boundp 'backend)
              (org-export-backend-name backend))
     ,@body))

(defun my/org-latex-headers ()
  (mapcar
   (lambda (record) (plist-get (cl-second record) :value))
   (cl-remove-if-not
    (lambda (record)
      (let* ((data (cl-second record))
             (key (plist-get data :key)))
        (or (string-equal key "LATEX_HEADER")
            (string-equal key "LATEX_HEADER_EXTRA"))))
    (org-element-map (org-element-parse-buffer) 'keyword 'identity))))

(defun my/org-latex-template-with-header (body)
  (org-latex-template
   body
   `(:title ""
            :exported-data ,(make-hash-table)
            :language "latex"
            :latex-classes ,org-latex-classes
            :latex-class "article"
            :latex-header ,(mapconcat 'identity (my/org-latex-headers) "\n"))))

(defun my/latex-to-ascii (latex &optional multiline)
  (let* ((catdvi-buf (get-buffer-create "*catdvi-buf*"))
         (tmpname (make-temp-file "catdvi" nil ".tex"))
         (dviname (format "%s.dvi" (file-name-sans-extension tmpname)))
         (template (my/org-latex-template-with-header latex)))
    (with-current-buffer catdvi-buf (erase-buffer))
    (with-temp-file tmpname
      (insert template)
      tmpname)
    (call-process (executable-find "texi2dvi")
                  nil (get-buffer-create "*texi2dvi-buf*") nil
                  "-o" dviname tmpname)
    (if multiline
        (progn
          (call-process (executable-find "catdvi") nil (list catdvi-buf nil) nil
                        "-e" "0" dviname)
          (replace-regexp-in-string
            ;; removes page numbering and page break
            "[\f\v\t\n ]*1[\f\n\t \\.]*\\'" ""
            (with-current-buffer catdvi-buf (buffer-string))))
      (progn
        (call-process (executable-find "catdvi") nil (list catdvi-buf nil) nil
                      "-s" "-e" "0" dviname)
        (org-trim
         (replace-regexp-in-string
          ;; removes page numbering and page break
          "1[\f\n\t \\.]*\\'" ""
          (with-current-buffer catdvi-buf (buffer-string))))))))

(defun my/org-ascii-latex-fragment (orig latex-fragment contents info)
  (when (plist-get info :with-latex)
    (my/latex-to-ascii
     (org-element-property :value latex-fragment))))

(defun my/org-ascii-latex-environment (orig latex-environment contents info)
  (message "my/org-ascii-latex-environment")
  (when (plist-get info :with-latex)
    (org-ascii--justify-element
     (my/latex-to-ascii
      (org-remove-indentation (org-element-property :value latex-environment)) t)
     latex-environment info)))

(advice-add 'org-ascii-latex-fragment :around 'my/org-ascii-latex-fragment)
(advice-add 'org-ascii-latex-environment :around 'my/org-ascii-latex-environment)

Notez que vous devrez également compiler à catdvipartir des sources. Il y a aussi un problème mineur à le compiler: certains fichiers C utilisent une variable définie dans un fichier d'en-tête dépendant (généralement installé séparément) sans a const, tandis que l'en-tête en a besoin d'être const(facilement corrigé en ajoutant simplement le bit de déclaration nécessaire). texi2dvidevrait être disponible pour l'installation à partir du gestionnaire de packages.

Alternatives pour LaTeX en ligne:

Je pensais utiliser TeXune méthode d'entrée, qui peut utiliser des caractères Unicode en indice et en exposant, cependant, cela nécessiterait l'analyse et le prétraitement du code LaTeX afin de l'alimenter en TeXméthode d'entrée.

Une autre alternative est d'essayer d'utiliser l'analyse syntaxique AUCTeX pour comprendre les indices et les exposants, mais ces deux nécessitent trop d'efforts ... Il est plus facile pour le moment d'utiliser catdviles formules en ligne, puis de corriger manuellement les indices / indices.

(defun my/prepare-tex-ime (input)
  (cl-loop for paren in '("[]{}") do
           (setq input (replace-regexp-in-string
                        (format "\\\\%s" paren) paren input)))
  input)

(defun my/tex-ime-translate (input)
  (with-temp-buffer
    (set-input-method 'TeX)
    (setq quail-current-key "")
    (cl-loop for c across input do
             (setq last-command-event c)
             (call-interactively 'quail-self-insert-command))
    (buffer-string)))

Exemples:

** Problem 1
   Prove that
   #+HEADER: :exports results
   #+HEADER: :results (by-backend (pdf "latex") (t "raw"))
   #+BEGIN_SRC latex
     \begin{align*}
       L = \{w \in \{a, b, c, d\}^* \;|\; w=dv, v \in \{a, b, c\}^*,
       \#_a(w) \cdot \#_c(w) < \#_b(w) \}
     \end{align*}
   #+END_SRC
   is not regular.

Se traduit en

1.1 Problem 1
─────────────

  Prove that
                    ∗                    ∗
  L = {w ∈ {a,b,c,d} | w = dv,v ∈ {a,b,c} ,# (w)·# (w) < # (w)}
                                            a     c       b

  is not regular.