Anonymous user
Knuth's power tree: Difference between revisions
Added EchoLisp
(→{{header|REXX}}: Added zkl) |
(Added EchoLisp) |
||
Line 73:
See: link to Rosetta Code [http://rosettacode.org/wiki/Addition-chain_exponentiation addition-chain exponentiation].
<br>
=={{header|EchoLisp}}==
===Power tree===
We build the tree using '''tree.lib''', adding leaves until the target n is found.
<lang scheme>
(lib 'tree)
;; displays a chain hit
(define (power-hit target chain)
(vector-push chain target)
(printf "L(%d) = %d - chain:%a "
target (1- (vector-length chain)) chain)
(vector-pop chain))
;; build the power-tree : add 1 level of leaf nodes
;; display all chains which lead to target
(define (add-level node chain target nums (new))
(vector-push chain (node-datum node))
(cond
[(node-leaf? node)
;; add leaves by summing this node to all nodes in chain
;; do not add leaf if number already known
(for [(prev chain)]
(set! new (+ prev (node-datum node)))
(when (= new target) (power-hit target chain ))
#:continue (vector-search* new nums)
(node-add-leaf node new)
(vector-insert* nums new)
)]
[else ;; not leaf node -> recurse
(for [(son (node-sons node))]
(add-level son chain target nums )) ])
(vector-pop chain))
;; add levels in tree until target found
;; return (number of nodes . upper-bound for L(target))
(define (power-tree target)
(define nums (make-vector 1 1)) ;; known nums = 1
(define T (make-tree 1)) ;; root node has value 1
(printf "Looking for %d in %a." target T)
(while #t
#:break (vector-search* target nums) => (tree-count T)
(add-level T init-chain: (make-vector 0) target nums)
))
</lang>
{{out}}
<pre>
(for ((n (in-range 2 18))) (power-tree n))
L(2) = 1 - chain:#( 1 2)
L(3) = 2 - chain:#( 1 2 3)
[ ... ]
(power-tree 17)
Looking for 17 in (🌴 1).
L(17) = 5 - chain:#( 1 2 4 8 16 17)
(power-tree 81)
Looking for 81 in (🌴 1).
L(81) = 8 - chain:#( 1 2 3 5 10 20 40 41 81)
L(81) = 8 - chain:#( 1 2 3 5 10 20 40 80 81)
L(81) = 8 - chain:#( 1 2 3 6 9 18 27 54 81)
L(81) = 8 - chain:#( 1 2 3 6 9 18 36 72 81)
L(81) = 8 - chain:#( 1 2 4 8 16 32 64 65 81)
(power-tree 191)
Looking for 191 in (🌴 1).
L(191) = 11 - chain:#( 1 2 3 5 7 14 19 38 57 95 190 191)
L(191) = 11 - chain:#( 1 2 3 5 7 14 21 42 47 94 188 191)
L(191) = 11 - chain:#( 1 2 3 5 7 14 21 42 63 126 189 191)
L(191) = 11 - chain:#( 1 2 3 5 7 14 28 31 59 118 177 191)
L(191) = 11 - chain:#( 1 2 3 5 7 14 28 31 62 93 186 191)
L(191) = 11 - chain:#( 1 2 3 5 10 11 22 44 88 176 181 191)
(power-tree 12509) ;; not optimal
Looking for 12509 in (🌴 1).
L(12509) = 18 - chain:#( 1 2 3 5 10 13 26 39 78 156 312 624 1248 2496 2509 3757 6253 12506 12509)
L(12509) = 18 - chain:#( 1 2 3 5 10 15 25 50 75 125 250 500 1000 2000 2003 4003 8006 12009 12509)
</pre>
===Exponentiation===
<lang scheme>
;; j such as chain[i] = chain[i-1] + chain[j]
(define (adder chain i)
(for ((j i)) #:break (= [chain i] (+ [chain(1- i)] [chain j])) => j ))
(define (power-exp x chain)
(define lg (vector-length chain))
(define pow (make-vector lg x))
(for ((i (in-range 1 lg)))
(vector-set! pow i ( * [pow [1- i]] [pow (adder chain i)])))
[pow (1- lg)])
</lang>
{{out}}
<pre>
(power-exp 2 #( 1 2 4 8 16 17) )
→ 131072
(power-exp 1.1 #( 1 2 3 5 10 20 40 41 81) )
→ 2253.2402360440283
(lib 'bigint)
bigint.lib v1.4 ® EchoLisp
Lib: bigint.lib loaded.
(power-exp 3 #( 1 2 3 5 7 14 19 38 57 95 190 191) )
→ 13494588674281093803728157396523884917402502294030101914066705367021922008906273586058258347
</pre>
=={{header|J}}==
| |||