google-translate--gen-tk-test1.el

(require 'cl-lib)

(defvar google-translate--bit-v-len 32)

(defun google-translate--bit-v-2comp (v)
  "Return the two's complement of V."
  (let* ((vc (vconcat v))
         (len (length vc)))
    ;; Complement of v
    (cl-loop for i from 0 below len do
             (aset vc i (logxor (aref vc i) 1)))
    ;; vc = complement of v + 1
    (cl-loop for i downfrom (1- len) to 0
             do (aset vc i (logxor (aref vc i) 1))
             when (> (aref vc i) 0) return nil)
    vc))

(defun google-translate--number-to-bit-v (n)
  "Return a bit vector from N."
  (if (< n 0) (google-translate--bit-v-2comp
               (google-translate--number-to-bit-v (abs n)))
    (let ((v (make-vector google-translate--bit-v-len 0)))
      (cl-loop for i downfrom (1- google-translate--bit-v-len) to 0
               with q
               when (< n 1) return nil do               
               (setq q (ffloor (* n 0.5)))
               (aset v i (floor (- n (* 2.0 q))))
               (setq n q))
      v)))

(defun google-translate--bit-v-to-number (v)
  "Return a floating-point number from V."
  (if (and (> (aref v 0) 0)
           ;; Exclude [1 0 ... 0]
           (cl-loop for i from 1 below google-translate--bit-v-len
                    thereis (> (aref v i) 0)))
      (- (google-translate--bit-v-to-number (google-translate--bit-v-2comp v)))
    (funcall (if (> (aref v 0) 0)  #'- #'+)
             (cl-reduce (lambda (acc e) (+ (* acc 2.0) e))
                        v :initial-value 0.0))))

(defun google-translate--logfn (fn n1 n2)
  "Helper function for logical FN."
  (let ((v1 (google-translate--number-to-bit-v n1))
        (v2 (google-translate--number-to-bit-v n2))
        (v (make-vector google-translate--bit-v-len 0)))
    (cl-loop for i from 0 below google-translate--bit-v-len do
             (aset v i (funcall fn (aref v1 i) (aref v2 i))))
    (google-translate--bit-v-to-number v)))

(defun google-translate--logand (n1 n2)
  "Return a floating-point number from N1 and N2."
  (google-translate--logfn #'logand n1 n2))

(defun google-translate--logxor (n1 n2)
  "Return a floating-point number from N1 and N2."
  (google-translate--logfn #'logxor n1 n2))

(defun google-translate--lsh (n d)
  "Return a floating-point number.
Shift the bits in N to the left or rihgt D places.
D is an integer."
  (let ((v (google-translate--number-to-bit-v n))
        (v-result (make-vector google-translate--bit-v-len 0)))
    (cond
     ((zerop d) n)
     ((< d 0) ;; Shift Right Logical
      ;; [x0 x1 ... xn-d ... xn] => [0 ... 0 x0 x1 ... xn-d]
      (cl-loop for i from (abs d) below google-translate--bit-v-len
               for j from 0 do
               (aset v-result i (aref v j))))
     (t ;; Shift Left Logical
      ;; [x0 x1 ... xd ... xn] => [xd ... xn 0 ... 0]
      (cl-loop for i from d below google-translate--bit-v-len
               for j from 0 do
               (aset v-result j (aref v i)))))
    (google-translate--bit-v-to-number v-result)))

(defun my-google-translate--gen-rl (a b)
  (cl-loop for c from 0 below (- (length b) 2) by 3
           for d = (aref b (+ c 2)) do
           (setq d (if (>= d ?a) (- d 87) (- d ?0)))
           (setq d (if (= (aref b (1+ c)) ?+)
                       (google-translate--lsh a (- d))
                     (google-translate--lsh a d)))
           (setq a (if (= (aref b c) ?+)
                       (google-translate--logand (+ a d) 4294967295.0)
                     (google-translate--logxor a d))))
  a)

(defun my-google-translate--gen-tk (text &optional float-time)
  (let* ((b (ffloor (/ (or float-time (time-to-seconds)) 3600.0)))
         (ub "+-3^+b+-f")
         (vb "+-a^+6")
         (a (cl-reduce (lambda (a e) (my-google-translate--gen-rl (+ a e) vb))
                       (encode-coding-string text 'utf-8) :initial-value b)))
    (setq a (my-google-translate--gen-rl a ub))
    (when (< a 0) ;; (abs a) + 2^31
      (setq a (+ (google-translate--logand a 2147483647.0) 2147483648.0)))
    (setq a (ffloor (mod a 1e6)))
    (format "%s.%s"
            (car (split-string (number-to-string a) "\\."))
            (car (split-string (number-to-string (google-translate--logxor a b)) "\\.")))))

(cl-assert (equal (my-google-translate--gen-rl 403419 "+-a^+6")
                  415696276.0))

(let ((text "This buffer is for notes you don't want to save, and for Lisp evaluation."))
  (cl-assert (equal (my-google-translate--gen-tk text 1627424318) "759658.881332"))
  (cl-assert (equal (my-google-translate--gen-tk text 1907276848) "106131.625428"))
  (cl-assert (equal (my-google-translate--gen-tk text 1900349679) "536698.15992"))
  (cl-assert (equal (my-google-translate--gen-tk text 1691683705) "889864.704400"))
  (cl-assert (equal (my-google-translate--gen-tk text 1671310694) "684671.878339"))
  (cl-assert (equal (my-google-translate--gen-tk text 1461784924) "448784.60211"))
  (cl-assert (equal (my-google-translate--gen-tk text 1974249291) "360864.909202"))
  (cl-assert (equal (my-google-translate--gen-tk text 1939139469) "143145.661296"))
  (cl-assert (equal (my-google-translate--gen-tk text 1679558583) "253172.311940"))
  (cl-assert (equal (my-google-translate--gen-tk text 1912948790) "184141.709859")))


(advice-add 'google-translate--gen-rl :override #'my-google-translate--gen-rl)
(advice-add 'google-translate--gen-tk :override #'my-google-translate--gen-tk)

;; (advice-remove 'google-translate--gen-rl #'my-google-translate--gen-rl)
;; (advice-remove 'google-translate--gen-tk #'my-google-translate--gen-tk)