Can you recommend me a good arbitrary precision math library (a
Common Lisp implementation or simply bindings for
clisp/gcl/cmulisp/other free cl impl) for Common Lisp?
  I´m currently using clisp in Linux.

If someone could take and publish benchmarks. The following list of
operations is a good benchmark for bignum operations. Please post the
MCL timings.

A. Elementary integer computations:
   The tests are run with N = 100, 1000, 10000, 100000 decimal digits.
   Precompute x1 = floor((sqrt(5)+1)/2 * 10^(2N))
              x2 = floor(sqrt(3) * 10^N)
              x3 = 10^N+1
   Then time the following operations:
   1. Multiplication x1*x2,
   2. Division (with remainder) x1 / x2,
   3. integer_sqrt(x3),
   4. gcd(x1,x2),
B. (from Pari)
      u=1;v=1;p=1;q=1;for(k=1..1000){w=u+v;u=v;v=w;p=p*w;q=lcm(q,w);}

========================= timebench2.lisp =========================
(defvar x1)
(defvar x2)
(defvar x3)
(defvar y)
(defvar z)

(defun elementary-benchmark (N repeat)
  (setq x1 (floor (+ (isqrt (* 5 (expt 10 (* 4 N)))) (expt 10 (* 2 N))) 2))
  (setq x2 (isqrt (* 3 (expt 10 (* 2 N)))))
  (setq x3 (+ (expt 10 N) 1))
  (format t "~&~%N = ~D, Multiplication x1*x2, divide times by ~D~%" N repeat)
  (dotimes (count 3)
    (time
      (dotimes (_ repeat)
        (setq y (* x1 x2)))))
  (format t "~&~%N = ~D, Division (with remainder) x1 / x2, divide times by ~D~%" N repeat)
  (dotimes (count 3)
    (time
      (dotimes (_ repeat)
        (multiple-value-setq (y z) (floor x1 x2)))))
  (format t "~&~%N = ~D, integer_sqrt(x3), divide times by ~D~%" N repeat)
  (dotimes (count 3)
    (time
      (dotimes (_ repeat)
        (setq y (isqrt x3)))))
  (format t "~&~%N = ~D, gcd(x1,x2), divide times by ~D~%" N repeat)
  (dotimes (count 3)
    (time
      (dotimes (_ repeat)
        (setq y (gcd x1 x2)))))
)

(defun pari-benchmark (N repeat)
  (format t "~&~%N = ~D, pari-benchmark, divide times by ~D~%" N repeat)
  (dotimes (count 3)
    (time
      (dotimes (_ repeat)
        (let ((u 1) (v 1) (p 1) (q 1))
          (do ((k 1 (1+ k)))
              ((> k N) (setq y p z q))
            (let ((w (+ u v)))
              (shiftf u v w)
              (setq p (* p w))
              (setq q (lcm q w)))))))))

This is for MCL 4.3.1 running on a 300 MHz PowerPC G3 (beige).
Compiler options set via
   (declaim (optimize (speed 3) (safety 0) (space 0) (debug 0)))

        100     1000    10000   100000

A.1     0.021   1.6     153     16900   ms
        0.13    1.3      12.4     125   x 10^3 bytes allocated

A.2     0.042   1.2      99     10450   ms
        0.10    0.9      20.8     208   x 10^3 bytes allocated

A.3     0.18    1.37     65      6280   ms
        0.68    4.9      52.4     757   x 10^3 bytes allocated

A.4     1.7    42.5    3257    443000   ms
        5.8   414.5   43512  11991249   x 10^3 bytes allocated

       100    200      1000

B.     14.5   118      2150      ms
     4592    3280     51996      x 10^3 bytes allocated

================================================================

Long form:

 (integer-benchmark)

N = 100, Multiplication x1*x2, divide times by 10000
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 207 milliseconds (0.207 seconds) to run.
Of that, 1 milliseconds (0.001 seconds) were spent in The Cooperative Multitasking Experience.
 1,360,000 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 219 milliseconds (0.219 seconds) to run.
Of that, 6 milliseconds (0.006 seconds) were spent in The Cooperative Multitasking Experience.
 1,360,016 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 216 milliseconds (0.216 seconds) to run.
Of that, 3 milliseconds (0.003 seconds) were spent in The Cooperative Multitasking Experience.
 1,360,024 bytes of memory allocated.

N = 100, Division (with remainder) x1 / x2, divide times by 10000
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 427 milliseconds (0.427 seconds) to run.
Of that, 9 milliseconds (0.009 seconds) were spent in The Cooperative Multitasking Experience.
 1,040,016 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 505 milliseconds (0.505 seconds) to run.
Of that, 83 milliseconds (0.083 seconds) were spent in The Cooperative Multitasking Experience.
 1,040,024 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 467 milliseconds (0.467 seconds) to run.
Of that, 44 milliseconds (0.044 seconds) were spent in The Cooperative Multitasking Experience.
 1,040,040 bytes of memory allocated.

N = 100, integer_sqrt(x3), divide times by 10000
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 2,179 milliseconds (2.179 seconds) to run.
Of that, 94 milliseconds (0.094 seconds) were spent in The Cooperative Multitasking Experience.
201 milliseconds (0.201 seconds) was spent in GC.
 6,880,224 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 1,956 milliseconds (1.956 seconds) to run.
Of that, 103 milliseconds (0.103 seconds) were spent in The Cooperative Multitasking Experience.
 6,880,120 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 1,990 milliseconds (1.990 seconds) to run.
Of that, 137 milliseconds (0.137 seconds) were spent in The Cooperative Multitasking Experience.
 6,880,120 bytes of memory allocated.

N = 100, gcd(x1,x2), divide times by 10000
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 17,982 milliseconds (17.982 seconds) to run.
Of that, 964 milliseconds (0.964 seconds) were spent in The Cooperative Multitasking Experience.
364 milliseconds (0.364 seconds) was spent in GC.
 57,681,848 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 17,818 milliseconds (17.818 seconds) to run.
Of that, 1,008 milliseconds (1.008 seconds) were spent in The Cooperative Multitasking Experience.
183 milliseconds (0.183 seconds) was spent in GC.
 57,681,032 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 18,018 milliseconds (18.018 seconds) to run.
Of that, 1,020 milliseconds (1.020 seconds) were spent in The Cooperative Multitasking Experience.
364 milliseconds (0.364 seconds) was spent in GC.
 57,681,032 bytes of memory allocated.

N = 1000, Multiplication x1*x2, divide times by 1000
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,673 milliseconds (1.673 seconds) to run.
Of that, 78 milliseconds (0.078 seconds) were spent in The Cooperative Multitasking Experience.
 1,256,144 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,680 milliseconds (1.680 seconds) to run.
Of that, 97 milliseconds (0.097 seconds) were spent in The Cooperative Multitasking Experience.
 1,256,144 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,720 milliseconds (1.720 seconds) to run.
Of that, 134 milliseconds (0.134 seconds) were spent in The Cooperative Multitasking Experience.
 1,256,184 bytes of memory allocated.

N = 1000, Division (with remainder) x1 / x2, divide times by 1000
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 1,262 milliseconds (1.262 seconds) to run.
Of that, 39 milliseconds (0.039 seconds) were spent in The Cooperative Multitasking Experience.
 856,112 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 1,318 milliseconds (1.318 seconds) to run.
Of that, 97 milliseconds (0.097 seconds) were spent in The Cooperative Multitasking Experience.
 856,144 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 1,345 milliseconds (1.345 seconds) to run.
Of that, 125 milliseconds (0.125 seconds) were spent in The Cooperative Multitasking Experience.
 856,144 bytes of memory allocated.

N = 1000, integer_sqrt(x3), divide times by 1000
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 1,388 milliseconds (1.388 seconds) to run.
Of that, 14 milliseconds (0.014 seconds) were spent in The Cooperative Multitasking Experience.
 4,896,144 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 1,455 milliseconds (1.455 seconds) to run.
Of that, 80 milliseconds (0.080 seconds) were spent in The Cooperative Multitasking Experience.
 4,896,144 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (ISQRT X3))) took 1,467 milliseconds (1.467 seconds) to run.
Of that, 90 milliseconds (0.090 seconds) were spent in The Cooperative Multitasking Experience.
 4,896,176 bytes of memory allocated.

N = 1000, gcd(x1,x2), divide times by 1000
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 45,314 milliseconds (45.314 seconds) to run.
Of that, 2,742 milliseconds (2.742 seconds) were spent in The Cooperative Multitasking Experience.
2,187 milliseconds (2.187 seconds) was spent in GC.
 414,468,680 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 44,829 milliseconds (44.829 seconds) to run.
Of that, 2,441 milliseconds (2.441 seconds) were spent in The Cooperative Multitasking Experience.
1,999 milliseconds (1.999 seconds) was spent in GC.
 414,468,632 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (GCD X1 X2))) took 45,030 milliseconds (45.030 seconds) to run.
Of that, 2,469 milliseconds (2.469 seconds) were spent in The Cooperative Multitasking Experience.
2,190 milliseconds (2.190 seconds) was spent in GC.
 414,468,672 bytes of memory allocated.

N = 10000, Multiplication x1*x2, divide times by 10
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,579 milliseconds (1.579 seconds) to run.
Of that, 48 milliseconds (0.048 seconds) were spent in The Cooperative Multitasking Experience.
 124,808 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,599 milliseconds (1.599 seconds) to run.
Of that, 68 milliseconds (0.068 seconds) were spent in The Cooperative Multitasking Experience.
 124,832 bytes of memory allocated.
(DOTIMES (_ REPEAT) (SETQ Y (* X1 X2))) took 1,601 milliseconds (1.601 seconds) to run.
Of that, 61 milliseconds (0.061 seconds) were spent in The Cooperative Multitasking Experience.
 124,872 bytes of memory allocated.

N = 10000, Division (with remainder) x1 / x2, divide times by 10
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 1,112 milliseconds (1.112 seconds) to run.
Of that, 125 milliseconds (0.125 seconds) were spent in The Cooperative Multitasking Experience.
 208,280 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 997 milliseconds (0.997 seconds) to run.
Of that, 10 milliseconds (0.010 seconds) were spent in The Cooperative Multitasking Experience.
 208,272 bytes of memory allocated.
(DOTIMES (_ REPEAT) (MULTIPLE-VALUE-SETQ (Y Z) (FLOOR X1 X2))) took 1,045 milliseconds (1.045 seconds) to run.
Of that, 54 milliseconds (0.054 seconds) were spent in The Cooperative Multitasking Experience.
 208,280 bytes of memory allocated.

Addendum:

Tests under MacOS 9.0.4

here are the results from running a number of performance benchmarks
on OpenMCL (which I assume is comparable in speed to MCL) and CLISP,
on linuxppc. I have included your bignum tests, where CLISP is up to
20 times faster than OpenMCL. On other tests it is over 10 times
slower.

To interpret the results: the "Reference" column is the user time
taken by the reference implementation (here OpenMCL 0.7) in seconds,
and the other column is a multiple of this time (eg, a figure of 1.3
means 30% slower than the reference). A -1 means the corresponding
test was not executed (CLISP does not support certain types of method
combination, for example).

,----
| Benchmark                 Reference  CLISP
| ------------------------------------------
| Boyer                          4.86   4.02
| Browse                         1.96   2.70
| DDerviv                        2.69   3.34
| Deriv                          4.52   3.71
| Destructive                    2.42   5.36
| div2-test-1                    3.35   4.18
| div2-test2                     1.67   4.23
| FFT                           11.82   1.59
| frpoly/fixnum                  2.29   4.79
| frpoly/bignum                  4.36   2.57
| frpoly/float                   2.83   2.68
| Puzzle                        17.43   2.41
| CTak                           2.90   6.00
| Tak                            1.98  11.31
| RTak                           1.98  11.31
| takl                           6.55   5.02
| stak                           2.71   6.63
| fprint                         4.52   1.27
| traverse                       6.65  10.83
| triangle                       6.83  11.89
| factorial                      1.61   2.22
| fib                            0.46  11.24
| bignum/elem-100-10000         67.84   0.05
| bignum/elem-1000-1000        330.30   0.05
| bignum/elem-10000-10         314.55   0.04
| bignum/elem-100000-1          68.20   0.05
| bignum/pari-100-100            4.75   0.39
| bignum/pari-200-100           44.97   0.34
| bignum/pari-1000-1           132.34   0.28
| hashtable                      4.64   2.20
| CLOS/defclass                  0.61   3.90
| CLOS/defmethod                 0.25   2.28
| CLOS/instantiate              25.56   0.88
| CLOS/methodcalls              18.45   2.09
| CLOS/method+after              7.75   2.57
| CLOS/complex-methods           2.44  -1.00
| 1D-arrays                      4.68   5.30
| bitvectors                     8.44   0.48
| fill-strings                 183.24   0.61
| fill-strings/adjustable      100.52   2.02
|
| Reference implementation: OpenMCL Version (Beta: linux) 0.7
| Impl CLISP: CLISP 2.27 (released 2001-07-17) (built 3210398221) (memory 3210398634)
`----

This is on a PowerPC750 (G3) at 450MHz, 1024Kb L2 cache, 256MB RAM
running linuxppc 2.2.18. The programs are compiled with (speed 3)
(space 0) (safety 1). Source code for the tests is available at

   <URL:http://www.chez.com/emarsden/downloads/cl-bench.tar.gz>

Obviously, the best benchmark is your application.