numbers.lisp

   1 (in-package :alexandria)
   2
   3 (declaim (inline clamp))
   4 (defun clamp (number min max)
   5   "Clamps the NUMBER into [MIN, MAX] range. Returns MIN if NUMBER lesser then
   6 MIN and MAX if NUMBER is greater then MAX, otherwise returns NUMBER."
   7   (if (< number min)
   8       min
   9       (if (> number max)
  10           max
  11           number)))
  12
  13 (defun gaussian-random (&optional min max)
  14   "Returns two gaussian random double floats as the primary and secondary value,
  15 optionally constrained by MIN and MAX. Gaussian random numbers form a standard
  16 normal distribution around 0.0d0."
  17   (labels ((gauss ()
  18              (loop
  19                 for x1 = (- (random 2.0d0) 1.0d0)
  20                 for x2 = (- (random 2.0d0) 1.0d0)
  21                 for w = (+ (expt x1 2) (expt x2 2))
  22                 when (< w 1.0d0)
  23                 do (let ((v (sqrt (/ (* -2.0d0 (log w)) w))))
  24                      (return (values (* x1 v) (* x2 v))))))
  25            (guard (x min max)
  26              (unless (<= min x max)
  27                (tagbody
  28                 :retry
  29                   (multiple-value-bind (x1 x2) (gauss)
  30                     (when (<= min x1 max)
  31                       (setf x x1)
  32                       (go :done))
  33                     (when (<= min x2 max)
  34                       (setf x x2)
  35                       (go :done))
  36                     (go :retry))
  37                 :done))
  38              x))
  39     (multiple-value-bind (g1 g2) (gauss)
  40       (values (guard g1 (or min g1) (or max g1))
  41               (guard g2 (or min g2) (or max g2))))))
  42
  43 (declaim (inline iota))
  44 (defun iota (n &key (start 0) (step 1))
  45   "Return a list of n numbers, starting from START (with numeric contagion
  46 from STEP applied), each consequtive number being the sum of the previous one
  47 and STEP. START defaults to 0 and STEP to 0.
  48
  49 Examples:
  50
  51   (iota 4)                      => (0 1 2 3 4)
  52   (iota 3 :start 1 :step 1.0)   => (1.0 2.0 3.0)
  53   (iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)
  54 "
  55   (declare (type (integer 0) n) (number start step))
  56   (loop repeat n
  57      ;; KLUDGE: get numeric contagion right for the first element too
  58      for i = (+ start (- step step)) then (+ i step)
  59      collect i))
  60
  61 (declaim (inline map-iota))
  62 (defun map-iota (function n &key (start 0) (step 1))
  63   "Calls FUNCTION with N numbers, starting from START (with numeric contagion
  64 from STEP applied), each consequtive number being the sum of the previous one
  65 and STEP. START defaults to 0 and STEP to 0. Returns N.
  66
  67 Examples:
  68
  69   (iota 4)                      => (0 1 2 3 4)
  70   (iota 3 :start 1 :step 1.0)   => (1.0 2.0 3.0)
  71   (iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)
  72 "
  73   (declare (type (integer 0) n) (number start step))
  74   (loop repeat n
  75         ;; KLUDGE: get numeric contagion right for the first element too
  76         for i = (+ start (- step step)) then (+ i step)
  77         do (funcall function i))
  78   n)
  79
  80 (declaim (inline lerp))
  81 (defun lerp (v a b)
  82   "Returns the result of linear interpolation between A and B, using the
  83 interpolation coefficient V."
  84    (+ a (* v (- b a))))
  85
  86 (declaim (inline mean))
  87 (defun mean (sample)
  88   "Returns the mean of SAMPLE. SAMPLE must be a sequence of numbers."
  89   (/ (reduce #'+ sample) (length sample)))
  90
  91 (declaim (inline median))
  92 (defun median (sample)
  93   "Returns median of SAMPLE. SAMPLE must be a sequence of real numbers."
  94   (let* ((vector (sort (copy-sequence 'vector sample) #'<))
  95          (length (length vector))
  96          (middle (truncate length 2)))
  97     (if (oddp length)
  98         (aref vector middle)
  99         (/ (+ (aref vector middle) (aref vector (1+ middle))) 2))))
 100
 101 (declaim (inline variance))
 102 (defun variance (sample &key (biased t))
 103   "Variance of SAMPLE. Returns the biased variance if BIASED is true (the default),
 104 and the unbiased estimator of variance if BIASED is false. SAMPLE must be a
 105 sequence of numbers."
 106   (let ((mean (mean sample)))
 107     (/ (reduce (lambda (a b)
 108                  (+ a (expt (- b mean) 2)))
 109                sample
 110                :initial-value 0)
 111        (- (length sample) (if biased 0 1)))))
 112
 113 (declaim (inline standard-deviation))
 114 (defun standard-deviation (sample &key (biased t))
 115   "Standard deviation of SAMPLE. Returns the biased standard deviation if
 116 BIASED is true (the default), and the square root of the unbiased estimator
 117 for variance if BIASED is false (which is not the same as the unbiased
 118 estimator for standard deviation). SAMPLE must be a sequence of numbers."
 119   (sqrt (variance sample :biased biased)))
 120
 121 (define-modify-macro maxf (&rest numbers) max
 122   "Modify-macro for MAX. Sets place designated by the first argument to the
 123 maximum of its original value and NUMBERS.")
 124
 125 (define-modify-macro minf (&rest numbers) min
 126   "Modify-macro for MIN. Sets place designated by the first argument to the
 127 minimum of its original value and NUMBERS.")
 128
 129 ;;;; Factorial
 130
 131 ;;; KLUDGE: This is really dependant on the numbers in question: for
 132 ;;; small numbers this is larger, and vice versa. Ideally instead of a
 133 ;;; constant we would have RANGE-FAST-TO-MULTIPLY-DIRECTLY-P.
 134 (defconstant +factorial-bisection-range-limit+ 8)
 135
 136 ;;; KLUDGE: This is really platform dependant: ideally we would use
 137 ;;; (load-time-value (find-good-direct-multiplication-limit)) instead.
 138 (defconstant +factorial-direct-multiplication-limit+ 13)
 139
 140 (defun %multiply-range (i j)
 141   ;; We use a a bit of cleverness here:
 142   ;;
 143   ;; 1. For large factorials we bisect in order to avoid expensive bignum
 144   ;;    multiplications: 1 x 2 x 3 x ... runs into bignums pretty soon,
 145   ;;    and once it does that all further multiplications will be with bignums.
 146   ;;
 147   ;;    By instead doing the multiplication in a tree like
 148   ;;       ((1 x 2) x (3 x 4)) x ((5 x 6) x (7 x 8))
 149   ;;    we manage to get less bignums.
 150   ;;
 151   ;; 2. Division isn't exactly free either, however, so we don't bisect
 152   ;;    all the way down, but multiply ranges of integers close to each
 153   ;;    other directly.
 154   ;;
 155   ;; For even better results it should be possible to use prime
 156   ;; factorization magic, but Nikodemus ran out of steam.
 157   ;;
 158   ;; KLUDGE: We support factorials of bignums, but it seems quite
 159   ;; unlikely anyone would ever be able to use them on a modern lisp,
 160   ;; since the resulting numbers are unlikely to fit in memory... but
 161   ;; it would be extremely unelegant to define FACTORIAL only on
 162   ;; fixnums, _and_ on lisps with 16 bit fixnums this can actually be
 163   ;; needed.
 164   (labels ((bisect (j k)
 165              (declare (type (integer 1 #.most-positive-fixnum) j k))
 166              (if (< (- k j) +factorial-bisection-range-limit+)
 167                  (multiply-range j k)
 168                  (let ((middle (+ j (truncate (- k j) 2))))
 169                    (* (bisect j middle)
 170                       (bisect (+ middle 1) k)))))
 171            (bisect-big (j k)
 172              (declare (type (integer 1) j k))
 173              (if (= j k)
 174                  j
 175                  (let ((middle (+ j (truncate (- k j) 2))))
 176                    (* (if (<= middle most-positive-fixnum)
 177                           (bisect j middle)
 178                           (bisect-big j middle))
 179                       (bisect-big (+ middle 1) k)))))
 180            (multiply-range (j k)
 181              (declare (type (integer 1 #.most-positive-fixnum) j k))
 182              (do ((f k (* f m))
 183                   (m (1- k) (1- m)))
 184                  ((< m j) f)
 185                (declare (type (integer 0 (#.most-positive-fixnum)) m)
 186                         (type unsigned-byte f)))))
 187     (bisect i j)))
 188
 189 (declaim (inline factorial))
 190 (defun %factorial (n)
 191   (if (< n 2)
 192       1
 193       (%multiply-range 1 n)))
 194
 195 (defun factorial (n)
 196   "Factorial of non-negative integer N."
 197   (check-type n (integer 0))
 198   (%factorial n))
 199
 200 ;;;; Combinatorics
 201
 202 (defun binomial-coefficient (n k)
 203   "Binomial coefficient of N and K, also expressed as N choose K. This is the
 204 number of K element combinations given N choises. N must be equal to or
 205 greater then K."
 206   (check-type n (integer 0))
 207   (check-type k (integer 0))
 208   (assert (>= n k))
 209   (if (or (zerop k) (= n k))
 210       1
 211       (let ((n-k (- n k)))
 212         (if (= 1 n-k)
 213             n
 214             ;; General case, avoid computing the 1x...xK twice:
 215             ;;
 216             ;;    N!           1x...xN          (K+1)x...xN
 217             ;; --------  =  ---------------- =  ------------, N>1
 218             ;; K!(N-K)!     1x...xK x (N-K)!       (N-K)!
 219             (/ (%multiply-range (+ k 1) n)
 220                (%factorial n-k))))))
 221
 222 (defun subfactorial (n)
 223   "Subfactorial of the non-negative integer N."
 224   (check-type n (integer 0))
 225   (case n
 226     (0 1)
 227     (1 0)
 228     (otherwise
 229      (floor (/ (+ 1 (factorial n)) (exp 1))))))
 230
 231 (defun count-permutations (n &optional (k n))
 232   "Number of K element permutations for a sequence of N objects.
 233 R defaults to N"
 234   ;; FIXME: Use %multiply-range and take care of 1 and 2, plus
 235   ;; check types.
 236   (/ (factorial n)
 237      (factorial (- n k))))