convertir un grand nombre en hexadécimal

Question

Je veux transformer un grand nombre, en l'occurrence le temps présent en secondes compté à partir du temps d'unix, en une chaîne hexadécimale.

J'ai piraté un code il y a longtemps, qui (je pense) a fonctionné sur une version antérieure d'emacs, mais ça ne marche plus sur emacs 23 que j'utilise maintenant (il est possible que je foirais le code). La difficulté au moment où je l'ai écrit était que le nombre était grand pour être traité comme un argument pour certaines fonctions, donc je devais le diviser, faire quelque chose, et les mettre ensemble. Par exemple, si vous donnez un grand nombre à string-to-number, il renvoie un flottant même si je veux un entier.

Quelqu'un peut-il suggérer une réécriture?

Voici le code cassé que j'ai écrit. Cela ne fonctionne pas, mais peut vous donner une idée de ce que j'essaie de faire. Tout d'abord, ce sont tous les sous-programmes qui sont utilisés ci-dessous:

(defun seconds-since-origin() 
    (string-to-number (concat 
     (number-to-string (- (string-to-number 
      (substring (format-time-string "%s") 0 5) 
     ) 10000)) 
    (substring (format-time-string "%s") 5) 
))) 

(defun hexatridecimal (decimal) 
(concat 
    (let ((quotient (/ decimal 36))) (if (> quotient 35) 
     (hexatridecimal quotient) 
     (hexatridecimal-digit quotient) 
    )) 
    (hexatridecimal-digit (% decimal 36)) 
)) 

(defun hexatridecimal-digit (number) 
    (nth number (list 
"0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" 
    "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z")) 
) 

Ce qui suit sera la principale fonction qui sera appelée:

(hexatridecimal (seconds-since-origin)) 

Answer 1

L'utilisation d'un Emacs (dont 64 bits peut gérer des entiers comme vous « re à l'aide), effectuez les modifications suivantes:

(defun seconds-since-origin() 
    (string-to-number (format-time-string "%s"))) 

(defun hexatridecimal (decimal) 
    (let ((quotient (/ decimal 36)) 
     (remainder (% decimal 36))) 
    (concat 
    (if (> quotient 0) 
     (hexatridecimal quotient) 
     "") 
    (hexatridecimal-digit remainder)))) 

note: cela ne suppose un Emacs 64 bits qui a plus de bits pour large integers que le construit 32 bits. Si vous voulez travailler sur un Emacs 32 bits, vous pouvez utiliser la capacité big-int de calc pour faire les calculs à votre place et ajuster le code de manière appropriée.

Edité pour ajouter: Voici la version en utilisant les capacités de BigNum de calc:

(require 'calc) 
(require 'calc-ext) 
(defun seconds-since-origin() 
    (math-read-number-simple (format-time-string "%s"))) 
(defun hexatridecimal (decimal-bignum) 
    (let* ((q-r (math-idivmod decimal-bignum 36)) 
    (quotient (car q-r)) 
    (remainder (cdr q-r))) 
(concat 
(if (math-lessp 0 quotient) 
    (hexatridecimal quotient) 
    "") 
(hexatridecimal-digit remainder))))