Takeuchi Number in Clojure (Productivity)

Question

When calculating Takeuchi numbers, we need to find out how many times the function calls itself. I quickly came up with:

(def number (atom 0))

(defn tak [x y z]
  (if (<= x y)
    y
    (do 
      (dosync (swap! number inc))
      (tak (tak (dec x) y z)
           (tak (dec y) z x)
           (tak (dec z) x y)))))

(defn takeuchi_number [n]
  (dosync (reset! number 0))
  (tak n 0 (inc n))
  @number)

(time (takeuchi_number 10))
; 1029803
; "Elapsed time: 11155.012266 msecs"

But the performance is very poor. How to do this incredibly fast in Clojure?

Answer 1

As someone says, removing dosync seems to improve the situation 10 times, but that’s not the whole story. Once the JVM has hotspotted your code, it gets another factor 10 faster. This is why you should use criteria or the like to test real speed ...

(def number (atom 0))

(defn tak [x y z]
  (if (<= x y)
    y
    (do 
      (swap! number inc)
      (tak (tak (dec x) y z)
           (tak (dec y) z x)
           (tak (dec z) x y)))))

(defn takeuchi_number [n]
  (reset! number 0)
  (tak n 0 (inc n))
  @number)

;=> (time (takeuchi_number 10))
; "Elapsed time: 450.028 msecs"
; 1029803
;=> (time (takeuchi_number 10))
; "Elapsed time: 42.008 msecs"
; 1029803

dosync 5 , 10! , ? .

(defn tak [c x y z]
  (if (<= x y)
    [c y]
    (let [[a- x-] (tak 0 (dec x) y z)
          [b- y-] (tak 0 (dec y) z x)
          [c- z-] (tak 0 (dec z) x y)]
      (recur (+' 1 a- b- c- c) x- y- z-))))

(defn takeuchi_number [n]
   (tak 0 n 0 (inc n)))

;=> (time (takeuchi_number 10))
; "Elapsed time: 330.741 msecs"
; [1029803 11]
;=> (time (takeuchi_number 10))
; "Elapsed time: 137.829 msecs"
; [1029803 11]
;=> (time (takeuchi_number 10))
; "Elapsed time: 136.866 msecs"
; [1029803 11]

. , , . , !

=> (def tak (memoize tak))
#'euler.tak/tak
=> (time (takeuchi_number 10))
"Elapsed time: 1.401 msecs"
[1029803 11]

3000 . .

Answer 2

tak [result count], result - tak, count - , . , .

atom , Clojure, ; . , , - , , . :

(defn tak [x y z ^longs counter]
  (if (<= x y)
    y
    (do 
      (aset counter 0 (inc (aget counter 0)))
      (tak (tak (dec x) y z counter)
           (tak (dec y) z x counter)
           (tak (dec z) x y counter)
           counter))))

(defn takeuchi_number [n]
  (let [counter (long-array [0])]
    (tak n 0 (inc n) counter)
    (aget counter 0)))

, , , .