Hola a todos:

Por si le resultase de utilidad a alguien (que use Emacs), he escrito
para mi uso esta funcioncilla en Elisp para convertir entre unidades de
las que maneja TeX (pt, dd, bp, cm, in y todo eso). Hace falta requerir
el paquete calc-units, que es el que hace el trabajo:

  (require 'calc-units)

Y aquí va mi función. Se puede usar interactivamente, en cuyo caso
pregunta por la cantidad a convertir (p.ej. "18in") y la unidad a
convertir (p.ej. "bp"), y el resultado lo devuelve con un mensaje en la
"echo area" y lo copia al portapapeles. Pero también se puede usar como
código, de forma que admite un argumento que debe ser una lista de dos
elementos, el primero la cantidad a convertir y el segundo la unidad a
convertir. Es decir, podemos poner como código:

   (mi-convierte-unidades-tex '("18in" "bp"))

La función (es más simple de lo que parece, ya que tuve que limpiar algo
los resultados, pues calc-units usa cosas como "texbp", "texpt", etc.):

(defun mi-convierte-unidades-tex (&optional cons-cell-de-a)
     (interactive)
     (let* ((unidades-tex (regexp-opt
			   '("pt" "pc" "bp" "dd" "cc" "sp")))
	    (cantidad-de (if cons-cell-de-a
			     (car cons-cell-de-a)
			   (read-from-minibuffer "Convertir: ")))
	    (cantidad-de-corr (if (string-match (concat "\\([[:digit:]]+\\)"
							"\\("
							unidades-tex
							"\\)")
						cantidad-de)
				  (concat
				   (match-string 1 cantidad-de)
				   "tex"
				   (match-string 2 cantidad-de))
				cantidad-de))
	    (cantidad-a (if cons-cell-de-a
			    (car (cdr cons-cell-de-a))
			  (read-from-minibuffer "Convertir a: ")))
	    (cantidad-a-corr (if (string-match (concat "\\(" unidades-tex "\\)")
					       cantidad-a)
				 (concat "tex"
					 (match-string 1 cantidad-a))
			       cantidad-a))
	    (resultado  (calc-eval (math-convert-units (calc-eval cantidad-de-corr 'raw)
						       (calc-eval cantidad-a-corr 'raw))))
	    (resultado-corr (replace-regexp-in-string "tex\\|\s" "" resultado)))
       (if cons-cell-de-a
	   resultado-corr
	 (message resultado-corr)
	 (kill-new resultado-corr))))

Y aprovechando que se puede usar como código, escribí esta otra, que
partiendo de una cantidad devuelve una lista de equivalencias en
diversas unidades (ampliable, en la variable 'unidades'):

(defun cuanto-es-en-tex ()
   (interactive)
   (let* ((unidades
	   (list "pt" "pc" "bp" "dd" "cc" "sp" "cm" "mm" "in"))
	  (desde (read-from-minibuffer "Cuánto es en TeX: "))
	  (resultado-bruto
	   (mapcar (lambda (x)
		     (mi-convierte-unidades-tex
		      (list desde x)))
		   unidades))
     (resultado (mapconcat 'identity resultado-bruto "\n")))
   (message (format "%s equivalen a:\n\n%s"  desde resultado))
   (kill-new (format "%s equivalen a:\n\n%s"  desde resultado))))

Y la lista la copia también en el portapapeles además de entregarla como
mensaje. Es decir, que si hacemos M-x cuanto-es-en-tex RET "24cm" RET,
obtenemos la cadena:

"24cm equivalen a:

682.866141732pt
56.905511811pc
680.31496063bp
638.187500795dd
53.1822917329cc
44752315.4646sp
24cm
240.mm
9.44881889764in"

Saludos,

Juan Manuel 

----------------------------------------------------
Normas para el correcto uso del correo electrónico:
		http://www.rediris.es/mail/estilo.html
----------------------------------------------------