6

I'm new to Clojure and I think my approach to writing code so far is not in line with the "Way of Clojure". At least, I keep writing functions that keep leading to StackOverflow errors with large values. I've learned about using recur which has been a good step forward. But, how to make functions like the one below work for values like 2500000?

(defn fib [i]
  (if (>= 2 i)
    1
    (+ (fib (dec i))
       (fib (- i 2)))))

The function is, to my eyes, the "plain" implementation of a Fibonacci generator. I've seen other implementations that are much more optimized, but less obvious in terms of what they do. I.e. when you read the function definition, you don't go "oh, fibonacci".

Any pointers would be greatly appreciated!

bitops
  • 4,022
  • 3
  • 26
  • 31

3 Answers3

6

You need to have a mental model of how your function works. Let's say that you execute your function yourself, using scraps of paper for each invocation. First scrap, you write (fib 250000), then you see "oh, I need to calculate (fib 249999) and (fib 249998) and finally add them", so you note that and start two new scraps. You can't throw away the first, because it still has things to do for you when you finish the other calculations. You can imagine that this calculation will need a lot of scraps.

Another way is not to start at the top, but at the bottom. How would you do this by hand? You would start with the first numbers, 1, 1, 2, 3, 5, 8 …, and then always add the last two, until you have done it i times. You can even throw away all numbers except the last two at each step, so you can re-use most scraps.

(defn fib [i]
  (loop [a 0
         b 1
         n 1]
    (if (>= n i)
        b
        (recur b
               (+ a b)
               (inc n)))))

This is also a fairly obvious implementation, but of the how to, not of the what. It always seems quite elegant when you can simply write down a definition and it gets automatically transformed into an efficient calculation, but programming is that transformation. If something gets transformed automatically, then this particular problem has already been solved (often in a more general way).

Thinking "how would I do this step by step on paper" often leads to a good implementaion.

Svante
  • 50,694
  • 11
  • 78
  • 122
  • Thank you! I'll ponder on this. : ) – bitops Dec 29 '11 at 18:37
  • Hey, just wanted to come back and ask for some help: if I pass values greater than 92 to your function, I get an error. ArithmeticException integer overflow clojure.lang.Numbers.throwIntOverflow (Numbers.java:1374) Am I missing something? – bitops Jan 02 '12 at 00:50
  • @bitops: You might notice that `(fib 92)` is a rather large number. In fact, it takes close to 64 bits. Clojure _should_ automatically switch to BigNums, so this might be either a bug or some speed optimization setting. – Svante Jan 02 '12 at 16:23
  • 1
    @bitops: I stumbled upon an [explanation](http://dev.clojure.org/display/doc/Documentation+for+1.3+Numerics). Clojure doesn't do automatic promotion by default anymore (as of version 1.3). You need to use apostrophed versions of arithmetic operators for that, `+'` in this case. – Svante Jan 07 '12 at 14:13
5

A Fibonacci generator implemented in a "plain" way, as in the definition of the sequence, will always blow your stack up. Neither of two recursive calls to fib are tail recursive, such definition cannot be optimised.

Unfortunately, if you'd like to write an efficient implementation working for big numbers you'll have to accept the fact that mathematical notation doesn't translate to code as cleanly as we'd like it to.

For instance, a non-recursive implementation can be found in clojure.contrib.lazy-seqs. A whole range of various approaches to this problem can be found on Haskell wiki. It shouldn't be difficult to understand with knowledge of basics of functional programming.

Jan
  • 11,636
  • 38
  • 47
-1
 ;;from "The Pragmatic Programmers Programming Clojure"
 (defn fib [] (map first (iterate (fn [[a b]][b (+ a b)])[0N 1N])))
 (nth (fib) 2500000)
BLUEPIXY
  • 39,699
  • 7
  • 33
  • 70