nextTerm = firstTerm + secTerm;

System.out.println(counter+”. “+nextTerm);

fibonacci(secTerm, nextTerm);
}

Goes to 25th term, based on firstTerm = 0 and secTerm = 1.

Since the core of this problem was essentially finding a O(log(n)) algorithm for matrix multiplication, I also wrote a O(1) solution based upon diagonalization. Looks like it works, but for very large values, it may suffer from accuracy issues due to the use of inexact numbers.

(define (transpose A)
  (apply map list A))

;; crude matrix-mult for 2x2
(define (matrix-mult A B)
  (let ((trans-B (transpose B)))
   (cons 
    (list 
     (apply + (map * (car A) (car trans-B)))
     (apply + (map * (car A) (cadr trans-B))))
    (list
     (list 
     (apply + (map * (cadr A) (car trans-B)))
     (apply + (map * (cadr A) (cadr trans-B)))))
    )))

(define (log_fib n)
  (cond
    ((>= 1 n) '((1 1) (1 0)))
    ((even? n)
     (let ((fib-matrix (log_fib (/ n 2))))
       (matrix-mult fib-matrix fib-matrix)))
    (else
     (let ((fib-matrix (log_fib (quotient n 2))))
       (matrix-mult 
        (matrix-mult fib-matrix fib-matrix)
        '((1 1) (1 0)))))))

(define (PDP_fib n)
  (let* ((eig1 (* 1/2 (+ 1 (sqrt 5))))
         (eig2 (* 1/2 (- 1 (sqrt 5))))
         (P (list 
             (list eig1 eig2)
             (list 1 1)))
         (D (list
             (list (expt eig1 n) 0)
             (list 0 (expt eig2 n )))) 
         (P^-1 (let ((det (/ 1 (- eig1 eig2))))
                 (list (list det (* det eig2 -1)) 
                       (list (* det -1) (* det eig1))))))     
    (round (cadr (car (matrix-mult (matrix-mult P D) P^-1))))))

[ I fixed the formatting. In the future, look at the code formatting how-to for instructions. Thanks for your kind words, and for an interesting variation on the problem. -- PP ]

(define (fib n)
  (define (square x) (* x x))
  (cond ((zero? n) 0) ((or (= n 1) (= n 2)) 1)
        ((even? n) (let* ((n2 (quotient n 2)) (n2-1 (- n2 1)))
                     (* (fib n2) (+ (* 2 (fib n2-1)) (fib n2)))))
        (else (let* ((n2-1 (quotient n 2)) (n2 (+ n2-1 1)))
                (+ (square (fib n2-1)) (square (fib n2)))))))

(define (fast-fib n)
  (define (successor a b)
    (list (+ a b) a))

  (define (square a b) \
    (list (* a (+ a b b)) (+ (* a a) (* b b))))

  (define (matrix-fib n)
    (cond ((= n 0) '(1 0))
	  ((even? n) (apply successor (matrix-fib (- n 1))))
	  (else (apply square (matrix-fib (/ (- n 1) 2))))))

  (if (< n 1) 0 (car (matrix-fib (- n 1)))))

That will teach me to proofread.

;;; Computation of Fibonacci numbers with F(0) = 0 and F(1) = 1

(define (naive-fib n)
  (if (< n 2) n (+ (naive-fib (- n 1)) (naive-fib (- n 2)))))


(define (linear-fib n)
  (let loop ((a 0) (b 1) (n n))
    (if (< n 1) a (loop b (+ a b) (- n 1)))))


;; The following takes advantage of matrix symmetry and the constant
;; successor term to use cheaper steps for the square and multiply
;; operations.  Note that the matrix square takes Fib n to Fib 2n+1,
;; so the sense of even/odd in the power function is reversed from
;; the usual.
(define (fast-fib n)
  (define (successor a b c)
    (list (+ a b)
	  (+ b c)
	  b))

  (define (square a b c)
    (let ((b-squared (* b b)))
      (list (+ (* a a) b-squared)
	    (* b (+ a c))
	    (+ b-squared (* c c)))))

  (define (matrix-fib n)
    (cond ((= n 1) '(2 1 1))
	  ((even? n) (apply successor (matrix-fib (- n 1))))
	  (else (apply square (matrix-fib (/ (- n 1) 2))))))

  (if (< n 1) 0 (caddr (matrix-fib n))))

{-# LANGUAGE FlexibleInstances #-}

import Data.List

instance Num a => Num [[a]] where
  a * b = [map (sum . zipWith (*) r) $ transpose b | r <- a]

fiblog :: Int -> Integer
fiblog n = ([[1,1],[1,0]] ^ n) !! 1 !! 0