src/code/numbers.lisp

   1 ;;;; This file contains the definitions of most number functions.
   2
   3 ;;;; This software is part of the SBCL system. See the README file for
   4 ;;;; more information.
   5 ;;;;
   6 ;;;; This software is derived from the CMU CL system, which was
   7 ;;;; written at Carnegie Mellon University and released into the
   8 ;;;; public domain. The software is in the public domain and is
   9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  10 ;;;; files for more information.
  11
  12 (in-package "SB!KERNEL")
  13 \f
  14 ;;;; the NUMBER-DISPATCH macro
  15
  16 (eval-when (:compile-toplevel :load-toplevel :execute)
  17
  18 ;;; Grovel an individual case to NUMBER-DISPATCH, augmenting RESULT
  19 ;;; with the type dispatches and bodies. Result is a tree built of
  20 ;;; alists representing the dispatching off each arg (in order). The
  21 ;;; leaf is the body to be executed in that case.
  22 (defun parse-number-dispatch (vars result types var-types body)
  23   (cond ((null vars)
  24          (unless (null types) (error "More types than vars."))
  25          (when (cdr result)
  26            (error "Duplicate case: ~S." body))
  27          (setf (cdr result)
  28                (sublis var-types body :test #'equal)))
  29         ((null types)
  30          (error "More vars than types."))
  31         (t
  32          (flet ((frob (var type)
  33                   (parse-number-dispatch
  34                    (rest vars)
  35                    (or (assoc type (cdr result) :test #'equal)
  36                        (car (setf (cdr result)
  37                                   (acons type nil (cdr result)))))
  38                    (rest types)
  39                    (acons `(dispatch-type ,var) type var-types)
  40                    body)))
  41            (let ((type (first types))
  42                  (var (first vars)))
  43              (if (and (consp type) (eq (first type) 'foreach))
  44                  (dolist (type (rest type))
  45                    (frob var type))
  46                  (frob var type)))))))
  47
  48 ;;; our guess for the preferred order in which to do type tests
  49 ;;; (cheaper and/or more probable first.)
  50 (defparameter *type-test-ordering*
  51   '(fixnum single-float double-float integer #!+long-float long-float bignum
  52     complex ratio))
  53
  54 ;;; Should TYPE1 be tested before TYPE2?
  55 (defun type-test-order (type1 type2)
  56   (let ((o1 (position type1 *type-test-ordering*))
  57         (o2 (position type2 *type-test-ordering*)))
  58     (cond ((not o1) nil)
  59           ((not o2) t)
  60           (t
  61            (< o1 o2)))))
  62
  63 ;;; Return an ETYPECASE form that does the type dispatch, ordering the
  64 ;;; cases for efficiency.
  65 (defun generate-number-dispatch (vars error-tags cases)
  66   (if vars
  67       (let ((var (first vars))
  68             (cases (sort cases #'type-test-order :key #'car)))
  69         `((typecase ,var
  70             ,@(mapcar (lambda (case)
  71                         `(,(first case)
  72                           ,@(generate-number-dispatch (rest vars)
  73                                                       (rest error-tags)
  74                                                       (cdr case))))
  75                       cases)
  76             (t (go ,(first error-tags))))))
  77       cases))
  78
  79 ) ; EVAL-WHEN
  80
  81 ;;; This is a vaguely case-like macro that does number cross-product
  82 ;;; dispatches. The Vars are the variables we are dispatching off of.
  83 ;;; The Type paired with each Var is used in the error message when no
  84 ;;; case matches. Each case specifies a Type for each var, and is
  85 ;;; executed when that signature holds. A type may be a list
  86 ;;; (FOREACH Each-Type*), causing that case to be repeatedly
  87 ;;; instantiated for every Each-Type. In the body of each case, any
  88 ;;; list of the form (DISPATCH-TYPE Var-Name) is substituted with the
  89 ;;; type of that var in that instance of the case.
  90 ;;;
  91 ;;; As an alternate to a case spec, there may be a form whose CAR is a
  92 ;;; symbol. In this case, we apply the CAR of the form to the CDR and
  93 ;;; treat the result of the call as a list of cases. This process is
  94 ;;; not applied recursively.
  95 (defmacro number-dispatch (var-specs &body cases)
  96   (let ((res (list nil))
  97         (vars (mapcar #'car var-specs))
  98         (block (gensym)))
  99     (dolist (case cases)
 100       (if (symbolp (first case))
 101           (let ((cases (apply (symbol-function (first case)) (rest case))))
 102             (dolist (case cases)
 103               (parse-number-dispatch vars res (first case) nil (rest case))))
 104           (parse-number-dispatch vars res (first case) nil (rest case))))
 105
 106     (collect ((errors)
 107               (error-tags))
 108       (dolist (spec var-specs)
 109         (let ((var (first spec))
 110               (type (second spec))
 111               (tag (gensym)))
 112           (error-tags tag)
 113           (errors tag)
 114           (errors `(return-from
 115                     ,block
 116                     (error 'simple-type-error :datum ,var
 117                            :expected-type ',type
 118                            :format-control
 119                            "~@<Argument ~A is not a ~S: ~2I~_~S~:>"
 120                            :format-arguments
 121                            (list ',var ',type ,var))))))
 122
 123       `(block ,block
 124          (tagbody
 125            (return-from ,block
 126                         ,@(generate-number-dispatch vars (error-tags)
 127                                                     (cdr res)))
 128            ,@(errors))))))
 129 \f
 130 ;;;; binary operation dispatching utilities
 131
 132 (eval-when (:compile-toplevel :execute)
 133
 134 ;;; Return NUMBER-DISPATCH forms for rational X float.
 135 (defun float-contagion (op x y &optional (rat-types '(fixnum bignum ratio)))
 136   `(((single-float single-float) (,op ,x ,y))
 137     (((foreach ,@rat-types)
 138       (foreach single-float double-float #!+long-float long-float))
 139      (,op (coerce ,x '(dispatch-type ,y)) ,y))
 140     (((foreach single-float double-float #!+long-float long-float)
 141       (foreach ,@rat-types))
 142      (,op ,x (coerce ,y '(dispatch-type ,x))))
 143     #!+long-float
 144     (((foreach single-float double-float long-float) long-float)
 145      (,op (coerce ,x 'long-float) ,y))
 146     #!+long-float
 147     ((long-float (foreach single-float double-float))
 148      (,op ,x (coerce ,y 'long-float)))
 149     (((foreach single-float double-float) double-float)
 150      (,op (coerce ,x 'double-float) ,y))
 151     ((double-float single-float)
 152      (,op ,x (coerce ,y 'double-float)))))
 153
 154 ;;; Return NUMBER-DISPATCH forms for bignum X fixnum.
 155 (defun bignum-cross-fixnum (fix-op big-op)
 156   `(((fixnum fixnum) (,fix-op x y))
 157     ((fixnum bignum)
 158      (,big-op (make-small-bignum x) y))
 159     ((bignum fixnum)
 160      (,big-op x (make-small-bignum y)))
 161     ((bignum bignum)
 162      (,big-op x y))))
 163
 164 ) ; EVAL-WHEN
 165 \f
 166 ;;;; canonicalization utilities
 167
 168 ;;; If IMAGPART is 0, return REALPART, otherwise make a complex. This is
 169 ;;; used when we know that REALPART and IMAGPART are the same type, but
 170 ;;; rational canonicalization might still need to be done.
 171 #!-sb-fluid (declaim (inline canonical-complex))
 172 (defun canonical-complex (realpart imagpart)
 173   (if (eql imagpart 0)
 174       realpart
 175       (cond #!+long-float
 176             ((and (typep realpart 'long-float)
 177                   (typep imagpart 'long-float))
 178              (truly-the (complex long-float) (complex realpart imagpart)))
 179             ((and (typep realpart 'double-float)
 180                   (typep imagpart 'double-float))
 181              (truly-the (complex double-float) (complex realpart imagpart)))
 182             ((and (typep realpart 'single-float)
 183                   (typep imagpart 'single-float))
 184              (truly-the (complex single-float) (complex realpart imagpart)))
 185             (t
 186              (%make-complex realpart imagpart)))))
 187
 188 ;;; Given a numerator and denominator with the GCD already divided
 189 ;;; out, make a canonical rational. We make the denominator positive,
 190 ;;; and check whether it is 1.
 191 #!-sb-fluid (declaim (inline build-ratio))
 192 (defun build-ratio (num den)
 193   (multiple-value-bind (num den)
 194       (if (minusp den)
 195           (values (- num) (- den))
 196           (values num den))
 197     (cond
 198       ((eql den 0)
 199        (error 'division-by-zero
 200               :operands (list num den)
 201               :operation 'build-ratio))
 202       ((eql den 1) num)
 203       (t (%make-ratio num den)))))
 204
 205 ;;; Truncate X and Y, but bum the case where Y is 1.
 206 #!-sb-fluid (declaim (inline maybe-truncate))
 207 (defun maybe-truncate (x y)
 208   (if (eql y 1)
 209       x
 210       (truncate x y)))
 211 \f
 212 ;;;; COMPLEXes
 213
 214 (defun complex (realpart &optional (imagpart 0))
 215   #!+sb-doc
 216   "Return a complex number with the specified real and imaginary components."
 217   (flet ((%%make-complex (realpart imagpart)
 218            (cond #!+long-float
 219                  ((and (typep realpart 'long-float)
 220                        (typep imagpart 'long-float))
 221                   (truly-the (complex long-float)
 222                              (complex realpart imagpart)))
 223                  ((and (typep realpart 'double-float)
 224                        (typep imagpart 'double-float))
 225                   (truly-the (complex double-float)
 226                              (complex realpart imagpart)))
 227                  ((and (typep realpart 'single-float)
 228                        (typep imagpart 'single-float))
 229                   (truly-the (complex single-float)
 230                              (complex realpart imagpart)))
 231                  (t
 232                   (%make-complex realpart imagpart)))))
 233   (number-dispatch ((realpart real) (imagpart real))
 234     ((rational rational)
 235      (canonical-complex realpart imagpart))
 236     (float-contagion %%make-complex realpart imagpart (rational)))))
 237
 238 (defun realpart (number)
 239   #!+sb-doc
 240   "Extract the real part of a number."
 241   (typecase number
 242     #!+long-float
 243     ((complex long-float)
 244      (truly-the long-float (realpart number)))
 245     ((complex double-float)
 246      (truly-the double-float (realpart number)))
 247     ((complex single-float)
 248      (truly-the single-float (realpart number)))
 249     ((complex rational)
 250      (sb!kernel:%realpart number))
 251     (t
 252      number)))
 253
 254 (defun imagpart (number)
 255   #!+sb-doc
 256   "Extract the imaginary part of a number."
 257   (typecase number
 258     #!+long-float
 259     ((complex long-float)
 260      (truly-the long-float (imagpart number)))
 261     ((complex double-float)
 262      (truly-the double-float (imagpart number)))
 263     ((complex single-float)
 264      (truly-the single-float (imagpart number)))
 265     ((complex rational)
 266      (sb!kernel:%imagpart number))
 267     (float
 268      (* 0 number))
 269     (t
 270      0)))
 271
 272 (defun conjugate (number)
 273   #!+sb-doc
 274   "Return the complex conjugate of NUMBER. For non-complex numbers, this is
 275   an identity."
 276   (if (complexp number)
 277       (complex (realpart number) (- (imagpart number)))
 278       number))
 279
 280 (defun signum (number)
 281   #!+sb-doc
 282   "If NUMBER is zero, return NUMBER, else return (/ NUMBER (ABS NUMBER))."
 283   (if (zerop number)
 284       number
 285       (if (rationalp number)
 286           (if (plusp number) 1 -1)
 287           (/ number (abs number)))))
 288 \f
 289 ;;;; ratios
 290
 291 (defun numerator (number)
 292   #!+sb-doc
 293   "Return the numerator of NUMBER, which must be rational."
 294   (numerator number))
 295
 296 (defun denominator (number)
 297   #!+sb-doc
 298   "Return the denominator of NUMBER, which must be rational."
 299   (denominator number))
 300 \f
 301 ;;;; arithmetic operations
 302
 303 (macrolet ((define-arith (op init doc)
 304              #!-sb-doc (declare (ignore doc))
 305              `(defun ,op (&rest args)
 306                 #!+sb-doc ,doc
 307                 (if (null args) ,init
 308                     (do ((args (cdr args) (cdr args))
 309                          (result (car args) (,op result (car args))))
 310                         ((null args) result)
 311                       ;; to signal TYPE-ERROR when exactly 1 arg of wrong type:
 312                       (declare (type number result)))))))
 313   (define-arith + 0
 314     "Return the sum of its arguments. With no args, returns 0.")
 315   (define-arith * 1
 316     "Return the product of its arguments. With no args, returns 1."))
 317
 318 (defun - (number &rest more-numbers)
 319   #!+sb-doc
 320   "Subtract the second and all subsequent arguments from the first;
 321   or with one argument, negate the first argument."
 322   (if more-numbers
 323       (do ((nlist more-numbers (cdr nlist))
 324            (result number))
 325           ((atom nlist) result)
 326          (declare (list nlist))
 327          (setq result (- result (car nlist))))
 328       (- number)))
 329
 330 (defun / (number &rest more-numbers)
 331   #!+sb-doc
 332   "Divide the first argument by each of the following arguments, in turn.
 333   With one argument, return reciprocal."
 334   (if more-numbers
 335       (do ((nlist more-numbers (cdr nlist))
 336            (result number))
 337           ((atom nlist) result)
 338          (declare (list nlist))
 339          (setq result (/ result (car nlist))))
 340       (/ number)))
 341
 342 (defun 1+ (number)
 343   #!+sb-doc
 344   "Return NUMBER + 1."
 345   (1+ number))
 346
 347 (defun 1- (number)
 348   #!+sb-doc
 349   "Return NUMBER - 1."
 350   (1- number))
 351
 352 (eval-when (:compile-toplevel)
 353
 354 (sb!xc:defmacro two-arg-+/- (name op big-op)
 355   `(defun ,name (x y)
 356      (number-dispatch ((x number) (y number))
 357        (bignum-cross-fixnum ,op ,big-op)
 358        (float-contagion ,op x y)
 359
 360        ((complex complex)
 361         (canonical-complex (,op (realpart x) (realpart y))
 362                            (,op (imagpart x) (imagpart y))))
 363        (((foreach bignum fixnum ratio single-float double-float
 364                   #!+long-float long-float) complex)
 365         (complex (,op x (realpart y)) (,op (imagpart y))))
 366        ((complex (or rational float))
 367         (complex (,op (realpart x) y) (imagpart x)))
 368
 369        (((foreach fixnum bignum) ratio)
 370         (let* ((dy (denominator y))
 371                (n (,op (* x dy) (numerator y))))
 372           (%make-ratio n dy)))
 373        ((ratio integer)
 374         (let* ((dx (denominator x))
 375                (n (,op (numerator x) (* y dx))))
 376           (%make-ratio n dx)))
 377        ((ratio ratio)
 378         (let* ((nx (numerator x))
 379                (dx (denominator x))
 380                (ny (numerator y))
 381                (dy (denominator y))
 382                (g1 (gcd dx dy)))
 383           (if (eql g1 1)
 384               (%make-ratio (,op (* nx dy) (* dx ny)) (* dx dy))
 385               (let* ((t1 (,op (* nx (truncate dy g1)) (* (truncate dx g1) ny)))
 386                      (g2 (gcd t1 g1))
 387                      (t2 (truncate dx g1)))
 388                 (cond ((eql t1 0) 0)
 389                       ((eql g2 1)
 390                        (%make-ratio t1 (* t2 dy)))
 391                       (T (let* ((nn (truncate t1 g2))
 392                                 (t3 (truncate dy g2))
 393                                 (nd (if (eql t2 1) t3 (* t2 t3))))
 394                            (if (eql nd 1) nn (%make-ratio nn nd))))))))))))
 395
 396 ) ; EVAL-WHEN
 397
 398 (two-arg-+/- two-arg-+ + add-bignums)
 399 (two-arg-+/- two-arg-- - subtract-bignum)
 400
 401 (defun two-arg-* (x y)
 402   (flet ((integer*ratio (x y)
 403            (if (eql x 0) 0
 404                (let* ((ny (numerator y))
 405                       (dy (denominator y))
 406                       (gcd (gcd x dy)))
 407                  (if (eql gcd 1)
 408                      (%make-ratio (* x ny) dy)
 409                      (let ((nn (* (truncate x gcd) ny))
 410                            (nd (truncate dy gcd)))
 411                        (if (eql nd 1)
 412                            nn
 413                            (%make-ratio nn nd)))))))
 414          (complex*real (x y)
 415            (canonical-complex (* (realpart x) y) (* (imagpart x) y))))
 416     (number-dispatch ((x number) (y number))
 417       (float-contagion * x y)
 418
 419       ((fixnum fixnum) (multiply-fixnums x y))
 420       ((bignum fixnum) (multiply-bignum-and-fixnum x y))
 421       ((fixnum bignum) (multiply-bignum-and-fixnum y x))
 422       ((bignum bignum) (multiply-bignums x y))
 423
 424       ((complex complex)
 425        (let* ((rx (realpart x))
 426               (ix (imagpart x))
 427               (ry (realpart y))
 428               (iy (imagpart y)))
 429          (canonical-complex (- (* rx ry) (* ix iy)) (+ (* rx iy) (* ix ry)))))
 430       (((foreach bignum fixnum ratio single-float double-float
 431                  #!+long-float long-float)
 432         complex)
 433        (complex*real y x))
 434       ((complex (or rational float))
 435        (complex*real x y))
 436
 437       (((foreach bignum fixnum) ratio) (integer*ratio x y))
 438       ((ratio integer) (integer*ratio y x))
 439       ((ratio ratio)
 440        (let* ((nx (numerator x))
 441               (dx (denominator x))
 442               (ny (numerator y))
 443               (dy (denominator y))
 444               (g1 (gcd nx dy))
 445               (g2 (gcd dx ny)))
 446          (build-ratio (* (maybe-truncate nx g1)
 447                          (maybe-truncate ny g2))
 448                       (* (maybe-truncate dx g2)
 449                          (maybe-truncate dy g1))))))))
 450
 451 ;;; Divide two integers, producing a canonical rational. If a fixnum,
 452 ;;; we see whether they divide evenly before trying the GCD. In the
 453 ;;; bignum case, we don't bother, since bignum division is expensive,
 454 ;;; and the test is not very likely to succeed.
 455 (defun integer-/-integer (x y)
 456   (if (and (typep x 'fixnum) (typep y 'fixnum))
 457       (multiple-value-bind (quo rem) (truncate x y)
 458         (if (zerop rem)
 459             quo
 460             (let ((gcd (gcd x y)))
 461               (declare (fixnum gcd))
 462               (if (eql gcd 1)
 463                   (build-ratio x y)
 464                   (build-ratio (truncate x gcd) (truncate y gcd))))))
 465       (let ((gcd (gcd x y)))
 466         (if (eql gcd 1)
 467             (build-ratio x y)
 468             (build-ratio (truncate x gcd) (truncate y gcd))))))
 469
 470 (defun two-arg-/ (x y)
 471   (number-dispatch ((x number) (y number))
 472     (float-contagion / x y (ratio integer))
 473
 474     ((complex complex)
 475      (let* ((rx (realpart x))
 476             (ix (imagpart x))
 477             (ry (realpart y))
 478             (iy (imagpart y)))
 479        (if (> (abs ry) (abs iy))
 480            (let* ((r (/ iy ry))
 481                   (dn (* ry (+ 1 (* r r)))))
 482              (canonical-complex (/ (+ rx (* ix r)) dn)
 483                                 (/ (- ix (* rx r)) dn)))
 484            (let* ((r (/ ry iy))
 485                   (dn (* iy (+ 1 (* r r)))))
 486              (canonical-complex (/ (+ (* rx r) ix) dn)
 487                                 (/ (- (* ix r) rx) dn))))))
 488     (((foreach integer ratio single-float double-float) complex)
 489      (let* ((ry (realpart y))
 490             (iy (imagpart y)))
 491        (if (> (abs ry) (abs iy))
 492            (let* ((r (/ iy ry))
 493                   (dn (* ry (+ 1 (* r r)))))
 494              (canonical-complex (/ x dn)
 495                                 (/ (- (* x r)) dn)))
 496            (let* ((r (/ ry iy))
 497                   (dn (* iy (+ 1 (* r r)))))
 498              (canonical-complex (/ (* x r) dn)
 499                                 (/ (- x) dn))))))
 500     ((complex (or rational float))
 501      (canonical-complex (/ (realpart x) y)
 502                         (/ (imagpart x) y)))
 503
 504     ((ratio ratio)
 505      (let* ((nx (numerator x))
 506             (dx (denominator x))
 507             (ny (numerator y))
 508             (dy (denominator y))
 509             (g1 (gcd nx ny))
 510             (g2 (gcd dx dy)))
 511        (build-ratio (* (maybe-truncate nx g1) (maybe-truncate dy g2))
 512                     (* (maybe-truncate dx g2) (maybe-truncate ny g1)))))
 513
 514     ((integer integer)
 515      (integer-/-integer x y))
 516
 517     ((integer ratio)
 518      (if (zerop x)
 519          0
 520          (let* ((ny (numerator y))
 521                 (dy (denominator y))
 522                 (gcd (gcd x ny)))
 523            (build-ratio (* (maybe-truncate x gcd) dy)
 524                         (maybe-truncate ny gcd)))))
 525
 526     ((ratio integer)
 527      (let* ((nx (numerator x))
 528             (gcd (gcd nx y)))
 529        (build-ratio (maybe-truncate nx gcd)
 530                     (* (maybe-truncate y gcd) (denominator x)))))))
 531
 532 (defun %negate (n)
 533   (number-dispatch ((n number))
 534     (((foreach fixnum single-float double-float #!+long-float long-float))
 535      (%negate n))
 536     ((bignum)
 537      (negate-bignum n))
 538     ((ratio)
 539      (%make-ratio (- (numerator n)) (denominator n)))
 540     ((complex)
 541      (complex (- (realpart n)) (- (imagpart n))))))
 542 \f
 543 ;;;; TRUNCATE and friends
 544
 545 (defun truncate (number &optional (divisor 1))
 546   #!+sb-doc
 547   "Return number (or number/divisor) as an integer, rounded toward 0.
 548   The second returned value is the remainder."
 549   (macrolet ((truncate-float (rtype)
 550                `(let* ((float-div (coerce divisor ',rtype))
 551                        (res (%unary-truncate (/ number float-div))))
 552                   (values res
 553                           (- number
 554                              (* (coerce res ',rtype) float-div))))))
 555     (number-dispatch ((number real) (divisor real))
 556       ((fixnum fixnum) (truncate number divisor))
 557       (((foreach fixnum bignum) ratio)
 558        (let ((q (truncate (* number (denominator divisor))
 559                           (numerator divisor))))
 560          (values q (- number (* q divisor)))))
 561       ((fixnum bignum)
 562        (bignum-truncate (make-small-bignum number) divisor))
 563       ((ratio (or float rational))
 564        (let ((q (truncate (numerator number)
 565                           (* (denominator number) divisor))))
 566          (values q (- number (* q divisor)))))
 567       ((bignum fixnum)
 568        (bignum-truncate number (make-small-bignum divisor)))
 569       ((bignum bignum)
 570        (bignum-truncate number divisor))
 571
 572       (((foreach single-float double-float #!+long-float long-float)
 573         (or rational single-float))
 574        (if (eql divisor 1)
 575            (let ((res (%unary-truncate number)))
 576              (values res (- number (coerce res '(dispatch-type number)))))
 577            (truncate-float (dispatch-type number))))
 578       #!+long-float
 579       ((long-float (or single-float double-float long-float))
 580        (truncate-float long-float))
 581       #!+long-float
 582       (((foreach double-float single-float) long-float)
 583        (truncate-float long-float))
 584       ((double-float (or single-float double-float))
 585        (truncate-float double-float))
 586       ((single-float double-float)
 587        (truncate-float double-float))
 588       (((foreach fixnum bignum ratio)
 589         (foreach single-float double-float #!+long-float long-float))
 590        (truncate-float (dispatch-type divisor))))))
 591
 592 ;;; Declare these guys inline to let them get optimized a little.
 593 ;;; ROUND and FROUND are not declared inline since they seem too
 594 ;;; obscure and too big to inline-expand by default. Also, this gives
 595 ;;; the compiler a chance to pick off the unary float case. Similarly,
 596 ;;; CEILING and FLOOR are only maybe-inline for now, so that the
 597 ;;; power-of-2 CEILING and FLOOR transforms get a chance.
 598 #!-sb-fluid (declaim (inline rem mod fceiling ffloor ftruncate))
 599 (declaim (maybe-inline ceiling floor))
 600
 601 (defun floor (number &optional (divisor 1))
 602   #!+sb-doc
 603   "Return the greatest integer not greater than number, or number/divisor.
 604   The second returned value is (mod number divisor)."
 605   ;; If the numbers do not divide exactly and the result of
 606   ;; (/ NUMBER DIVISOR) would be negative then decrement the quotient
 607   ;; and augment the remainder by the divisor.
 608   (multiple-value-bind (tru rem) (truncate number divisor)
 609     (if (and (not (zerop rem))
 610              (if (minusp divisor)
 611                  (plusp number)
 612                  (minusp number)))
 613         (values (1- tru) (+ rem divisor))
 614         (values tru rem))))
 615
 616 (defun ceiling (number &optional (divisor 1))
 617   #!+sb-doc
 618   "Return the smallest integer not less than number, or number/divisor.
 619   The second returned value is the remainder."
 620   ;; If the numbers do not divide exactly and the result of
 621   ;; (/ NUMBER DIVISOR) would be positive then increment the quotient
 622   ;; and decrement the remainder by the divisor.
 623   (multiple-value-bind (tru rem) (truncate number divisor)
 624     (if (and (not (zerop rem))
 625              (if (minusp divisor)
 626                  (minusp number)
 627                  (plusp number)))
 628         (values (+ tru 1) (- rem divisor))
 629         (values tru rem))))
 630
 631 (defun round (number &optional (divisor 1))
 632   #!+sb-doc
 633   "Rounds number (or number/divisor) to nearest integer.
 634   The second returned value is the remainder."
 635   (if (eql divisor 1)
 636       (round number)
 637       (multiple-value-bind (tru rem) (truncate number divisor)
 638         (if (zerop rem)
 639             (values tru rem)
 640             (let ((thresh (/ (abs divisor) 2)))
 641               (cond ((or (> rem thresh)
 642                          (and (= rem thresh) (oddp tru)))
 643                      (if (minusp divisor)
 644                          (values (- tru 1) (+ rem divisor))
 645                          (values (+ tru 1) (- rem divisor))))
 646                     ((let ((-thresh (- thresh)))
 647                        (or (< rem -thresh)
 648                            (and (= rem -thresh) (oddp tru))))
 649                      (if (minusp divisor)
 650                          (values (+ tru 1) (- rem divisor))
 651                          (values (- tru 1) (+ rem divisor))))
 652                     (t (values tru rem))))))))
 653
 654 (defun rem (number divisor)
 655   #!+sb-doc
 656   "Return second result of TRUNCATE."
 657   (multiple-value-bind (tru rem) (truncate number divisor)
 658     (declare (ignore tru))
 659     rem))
 660
 661 (defun mod (number divisor)
 662   #!+sb-doc
 663   "Return second result of FLOOR."
 664   (let ((rem (rem number divisor)))
 665     (if (and (not (zerop rem))
 666              (if (minusp divisor)
 667                  (plusp number)
 668                  (minusp number)))
 669         (+ rem divisor)
 670         rem)))
 671
 672 (defmacro !define-float-rounding-function (name op doc)
 673   `(defun ,name (number &optional (divisor 1))
 674     ,doc
 675     (multiple-value-bind (res rem) (,op number divisor)
 676       (values (float res (if (floatp rem) rem 1.0)) rem))))
 677
 678 (!define-float-rounding-function ffloor floor
 679   "Same as FLOOR, but returns first value as a float.")
 680 (!define-float-rounding-function fceiling ceiling
 681   "Same as CEILING, but returns first value as a float." )
 682 (!define-float-rounding-function ftruncate truncate
 683   "Same as TRUNCATE, but returns first value as a float.")
 684 (!define-float-rounding-function fround round
 685   "Same as ROUND, but returns first value as a float.")
 686 \f
 687 ;;;; comparisons
 688
 689 (defun = (number &rest more-numbers)
 690   #!+sb-doc
 691   "Return T if all of its arguments are numerically equal, NIL otherwise."
 692   (the number number)
 693   (do ((nlist more-numbers (cdr nlist)))
 694       ((atom nlist) T)
 695      (declare (list nlist))
 696      (if (not (= (car nlist) number)) (return nil))))
 697
 698 (defun /= (number &rest more-numbers)
 699   #!+sb-doc
 700   "Return T if no two of its arguments are numerically equal, NIL otherwise."
 701   (do* ((head (the number number) (car nlist))
 702         (nlist more-numbers (cdr nlist)))
 703        ((atom nlist) t)
 704      (declare (list nlist))
 705      (unless (do* ((nl nlist (cdr nl)))
 706                   ((atom nl) T)
 707                (declare (list nl))
 708                (if (= head (car nl)) (return nil)))
 709        (return nil))))
 710
 711 (defun < (number &rest more-numbers)
 712   #!+sb-doc
 713   "Return T if its arguments are in strictly increasing order, NIL otherwise."
 714   (do* ((n (the number number) (car nlist))
 715         (nlist more-numbers (cdr nlist)))
 716        ((atom nlist) t)
 717      (declare (list nlist))
 718      (if (not (< n (car nlist))) (return nil))))
 719
 720 (defun > (number &rest more-numbers)
 721   #!+sb-doc
 722   "Return T if its arguments are in strictly decreasing order, NIL otherwise."
 723   (do* ((n (the number number) (car nlist))
 724         (nlist more-numbers (cdr nlist)))
 725        ((atom nlist) t)
 726      (declare (list nlist))
 727      (if (not (> n (car nlist))) (return nil))))
 728
 729 (defun <= (number &rest more-numbers)
 730   #!+sb-doc
 731   "Return T if arguments are in strictly non-decreasing order, NIL otherwise."
 732   (do* ((n (the number number) (car nlist))
 733         (nlist more-numbers (cdr nlist)))
 734        ((atom nlist) t)
 735      (declare (list nlist))
 736      (if (not (<= n (car nlist))) (return nil))))
 737
 738 (defun >= (number &rest more-numbers)
 739   #!+sb-doc
 740   "Return T if arguments are in strictly non-increasing order, NIL otherwise."
 741   (do* ((n (the number number) (car nlist))
 742         (nlist more-numbers (cdr nlist)))
 743        ((atom nlist) t)
 744      (declare (list nlist))
 745      (if (not (>= n (car nlist))) (return nil))))
 746
 747 (defun max (number &rest more-numbers)
 748   #!+sb-doc
 749   "Return the greatest of its arguments; among EQUALP greatest, return
 750 the first."
 751   (do ((nlist more-numbers (cdr nlist))
 752        (result number))
 753       ((null nlist) (return result))
 754      (declare (list nlist))
 755      (declare (type real number result))
 756      (if (> (car nlist) result) (setq result (car nlist)))))
 757
 758 (defun min (number &rest more-numbers)
 759   #!+sb-doc
 760   "Return the least of its arguments; among EQUALP least, return
 761 the first."
 762   (do ((nlist more-numbers (cdr nlist))
 763        (result number))
 764       ((null nlist) (return result))
 765      (declare (list nlist))
 766      (declare (type real number result))
 767      (if (< (car nlist) result) (setq result (car nlist)))))
 768
 769 (eval-when (:compile-toplevel :execute)
 770
 771 ;;; The INFINITE-X-FINITE-Y and INFINITE-Y-FINITE-X args tell us how
 772 ;;; to handle the case when X or Y is a floating-point infinity and
 773 ;;; the other arg is a rational. (Section 12.1.4.1 of the ANSI spec
 774 ;;; says that comparisons are done by converting the float to a
 775 ;;; rational when comparing with a rational, but infinities can't be
 776 ;;; converted to a rational, so we show some initiative and do it this
 777 ;;; way instead.)
 778 (defun basic-compare (op &key infinite-x-finite-y infinite-y-finite-x)
 779   `(((fixnum fixnum) (,op x y))
 780
 781     ((single-float single-float) (,op x y))
 782     #!+long-float
 783     (((foreach single-float double-float long-float) long-float)
 784      (,op (coerce x 'long-float) y))
 785     #!+long-float
 786     ((long-float (foreach single-float double-float))
 787      (,op x (coerce y 'long-float)))
 788     (((foreach single-float double-float) double-float)
 789      (,op (coerce x 'double-float) y))
 790     ((double-float single-float)
 791      (,op x (coerce y 'double-float)))
 792     (((foreach single-float double-float #!+long-float long-float) rational)
 793      (if (eql y 0)
 794          (,op x (coerce 0 '(dispatch-type x)))
 795          (if (float-infinity-p x)
 796              ,infinite-x-finite-y
 797              (,op (rational x) y))))
 798     (((foreach bignum fixnum ratio) float)
 799      (if (float-infinity-p y)
 800          ,infinite-y-finite-x
 801          (,op x (rational y))))))
 802 ) ; EVAL-WHEN
 803
 804 (macrolet ((def-two-arg-</> (name op ratio-arg1 ratio-arg2 &rest cases)
 805              `(defun ,name (x y)
 806                 (number-dispatch ((x real) (y real))
 807                                  (basic-compare
 808                                   ,op
 809                                   :infinite-x-finite-y
 810                                   (,op x (coerce 0 '(dispatch-type x)))
 811                                   :infinite-y-finite-x
 812                                   (,op (coerce 0 '(dispatch-type y)) y))
 813                                  (((foreach fixnum bignum) ratio)
 814                                   (,op x (,ratio-arg2 (numerator y)
 815                                                       (denominator y))))
 816                                  ((ratio integer)
 817                                   (,op (,ratio-arg1 (numerator x)
 818                                                     (denominator x))
 819                                        y))
 820                                  ((ratio ratio)
 821                                   (,op (* (numerator   (truly-the ratio x))
 822                                           (denominator (truly-the ratio y)))
 823                                        (* (numerator   (truly-the ratio y))
 824                                           (denominator (truly-the ratio x)))))
 825                                  ,@cases))))
 826   (def-two-arg-</> two-arg-< < floor ceiling
 827     ((fixnum bignum)
 828      (bignum-plus-p y))
 829     ((bignum fixnum)
 830      (not (bignum-plus-p x)))
 831     ((bignum bignum)
 832      (minusp (bignum-compare x y))))
 833   (def-two-arg-</> two-arg-> > ceiling floor
 834     ((fixnum bignum)
 835      (not (bignum-plus-p y)))
 836     ((bignum fixnum)
 837      (bignum-plus-p x))
 838     ((bignum bignum)
 839      (plusp (bignum-compare x y)))))
 840
 841 (defun two-arg-= (x y)
 842   (number-dispatch ((x number) (y number))
 843     (basic-compare =
 844                    ;; An infinite value is never equal to a finite value.
 845                    :infinite-x-finite-y nil
 846                    :infinite-y-finite-x nil)
 847     ((fixnum (or bignum ratio)) nil)
 848
 849     ((bignum (or fixnum ratio)) nil)
 850     ((bignum bignum)
 851      (zerop (bignum-compare x y)))
 852
 853     ((ratio integer) nil)
 854     ((ratio ratio)
 855      (and (eql (numerator x) (numerator y))
 856           (eql (denominator x) (denominator y))))
 857
 858     ((complex complex)
 859      (and (= (realpart x) (realpart y))
 860           (= (imagpart x) (imagpart y))))
 861     (((foreach fixnum bignum ratio single-float double-float
 862                #!+long-float long-float) complex)
 863      (and (= x (realpart y))
 864           (zerop (imagpart y))))
 865     ((complex (or float rational))
 866      (and (= (realpart x) y)
 867           (zerop (imagpart x))))))
 868
 869 (defun eql (obj1 obj2)
 870   #!+sb-doc
 871   "Return T if OBJ1 and OBJ2 represent the same object, otherwise NIL."
 872   (or (eq obj1 obj2)
 873       (if (or (typep obj2 'fixnum)
 874               (not (typep obj2 'number)))
 875           nil
 876           (macrolet ((foo (&rest stuff)
 877                        `(typecase obj2
 878                           ,@(mapcar (lambda (foo)
 879                                       (let ((type (car foo))
 880                                             (fn (cadr foo)))
 881                                         `(,type
 882                                           (and (typep obj1 ',type)
 883                                                (,fn obj1 obj2)))))
 884                                     stuff))))
 885             (foo
 886               (single-float eql)
 887               (double-float eql)
 888               #!+long-float
 889               (long-float eql)
 890               (bignum
 891                (lambda (x y)
 892                  (zerop (bignum-compare x y))))
 893               (ratio
 894                (lambda (x y)
 895                  (and (eql (numerator x) (numerator y))
 896                       (eql (denominator x) (denominator y)))))
 897               (complex
 898                (lambda (x y)
 899                  (and (eql (realpart x) (realpart y))
 900                       (eql (imagpart x) (imagpart y))))))))))
 901 \f
 902 ;;;; logicals
 903
 904 (defun logior (&rest integers)
 905   #!+sb-doc
 906   "Return the bit-wise or of its arguments. Args must be integers."
 907   (declare (list integers))
 908   (if integers
 909       (do ((result (pop integers) (logior result (pop integers))))
 910           ((null integers) result)
 911         (declare (integer result)))
 912       0))
 913
 914 (defun logxor (&rest integers)
 915   #!+sb-doc
 916   "Return the bit-wise exclusive or of its arguments. Args must be integers."
 917   (declare (list integers))
 918   (if integers
 919       (do ((result (pop integers) (logxor result (pop integers))))
 920           ((null integers) result)
 921         (declare (integer result)))
 922       0))
 923
 924 (defun logand (&rest integers)
 925   #!+sb-doc
 926   "Return the bit-wise and of its arguments. Args must be integers."
 927   (declare (list integers))
 928   (if integers
 929       (do ((result (pop integers) (logand result (pop integers))))
 930           ((null integers) result)
 931         (declare (integer result)))
 932       -1))
 933
 934 (defun logeqv (&rest integers)
 935   #!+sb-doc
 936   "Return the bit-wise equivalence of its arguments. Args must be integers."
 937   (declare (list integers))
 938   (if integers
 939       (do ((result (pop integers) (logeqv result (pop integers))))
 940           ((null integers) result)
 941         (declare (integer result)))
 942       -1))
 943
 944 (defun lognot (number)
 945   #!+sb-doc
 946   "Return the bit-wise logical not of integer."
 947   (etypecase number
 948     (fixnum (lognot (truly-the fixnum number)))
 949     (bignum (bignum-logical-not number))))
 950
 951 (macrolet ((def (name op big-op &optional doc)
 952              `(defun ,name (integer1 integer2)
 953                 ,@(when doc
 954                     (list doc))
 955                 (let ((x integer1)
 956                       (y integer2))
 957                   (number-dispatch ((x integer) (y integer))
 958                     (bignum-cross-fixnum ,op ,big-op))))))
 959   (def two-arg-and logand bignum-logical-and)
 960   (def two-arg-ior logior bignum-logical-ior)
 961   (def two-arg-xor logxor bignum-logical-xor)
 962   ;; BIGNUM-LOGICAL-{AND,IOR,XOR} need not return a bignum, so must
 963   ;; call the generic LOGNOT...
 964   (def two-arg-eqv logeqv (lambda (x y) (lognot (bignum-logical-xor x y))))
 965   (def lognand lognand
 966        (lambda (x y) (lognot (bignum-logical-and x y)))
 967        #!+sb-doc "Complement the logical AND of INTEGER1 and INTEGER2.")
 968   (def lognor lognor
 969        (lambda (x y) (lognot (bignum-logical-ior x y)))
 970        #!+sb-doc "Complement the logical AND of INTEGER1 and INTEGER2.")
 971   ;; ... but BIGNUM-LOGICAL-NOT on a bignum will always return a bignum
 972   (def logandc1 logandc1
 973        (lambda (x y) (bignum-logical-and (bignum-logical-not x) y))
 974        #!+sb-doc "Bitwise AND (LOGNOT INTEGER1) with INTEGER2.")
 975   (def logandc2 logandc2
 976        (lambda (x y) (bignum-logical-and x (bignum-logical-not y)))
 977        #!+sb-doc "Bitwise AND INTEGER1 with (LOGNOT INTEGER2).")
 978   (def logorc1 logorc1
 979        (lambda (x y) (bignum-logical-ior (bignum-logical-not x) y))
 980        #!+sb-doc "Bitwise OR (LOGNOT INTEGER1) with INTEGER2.")
 981   (def logorc2 logorc2
 982        (lambda (x y) (bignum-logical-ior x (bignum-logical-not y)))
 983        #!+sb-doc "Bitwise OR INTEGER1 with (LOGNOT INTEGER2)."))
 984
 985 (defun logcount (integer)
 986   #!+sb-doc
 987   "Count the number of 1 bits if INTEGER is positive, and the number of 0 bits
 988   if INTEGER is negative."
 989   (etypecase integer
 990     (fixnum
 991      (logcount (truly-the (integer 0
 992                                    #.(max sb!xc:most-positive-fixnum
 993                                           (lognot sb!xc:most-negative-fixnum)))
 994                           (if (minusp (truly-the fixnum integer))
 995                               (lognot (truly-the fixnum integer))
 996                               integer))))
 997     (bignum
 998      (bignum-logcount integer))))
 999
1000 (defun logtest (integer1 integer2)
1001   #!+sb-doc
1002   "Predicate which returns T if logand of integer1 and integer2 is not zero."
1003   (logtest integer1 integer2))
1004
1005 (defun logbitp (index integer)
1006   #!+sb-doc
1007   "Predicate returns T if bit index of integer is a 1."
1008   (number-dispatch ((index integer) (integer integer))
1009     ((fixnum fixnum) (if (> index #.(- sb!vm:n-word-bits sb!vm:n-lowtag-bits))
1010                          (minusp integer)
1011                          (not (zerop (logand integer (ash 1 index))))))
1012     ((fixnum bignum) (bignum-logbitp index integer))
1013     ((bignum (foreach fixnum bignum)) (minusp integer))))
1014
1015 (defun ash (integer count)
1016   #!+sb-doc
1017   "Shifts integer left by count places preserving sign. - count shifts right."
1018   (declare (integer integer count))
1019   (etypecase integer
1020     (fixnum
1021      (cond ((zerop integer)
1022             0)
1023            ((fixnump count)
1024             (let ((length (integer-length (truly-the fixnum integer)))
1025                   (count (truly-the fixnum count)))
1026               (declare (fixnum length count))
1027               (cond ((and (plusp count)
1028                           (> (+ length count)
1029                              (integer-length most-positive-fixnum)))
1030                      (bignum-ashift-left (make-small-bignum integer) count))
1031                     (t
1032                      (truly-the fixnum
1033                                 (ash (truly-the fixnum integer) count))))))
1034            ((minusp count)
1035             (if (minusp integer) -1 0))
1036            (t
1037             (bignum-ashift-left (make-small-bignum integer) count))))
1038     (bignum
1039      (if (plusp count)
1040          (bignum-ashift-left integer count)
1041          (bignum-ashift-right integer (- count))))))
1042
1043 (defun integer-length (integer)
1044   #!+sb-doc
1045   "Return the number of significant bits in the absolute value of integer."
1046   (etypecase integer
1047     (fixnum
1048      (integer-length (truly-the fixnum integer)))
1049     (bignum
1050      (bignum-integer-length integer))))
1051 \f
1052 ;;;; BYTE, bytespecs, and related operations
1053
1054 (defun byte (size position)
1055   #!+sb-doc
1056   "Return a byte specifier which may be used by other byte functions
1057   (e.g. LDB)."
1058   (byte size position))
1059
1060 (defun byte-size (bytespec)
1061   #!+sb-doc
1062   "Return the size part of the byte specifier bytespec."
1063   (byte-size bytespec))
1064
1065 (defun byte-position (bytespec)
1066   #!+sb-doc
1067   "Return the position part of the byte specifier bytespec."
1068   (byte-position bytespec))
1069
1070 (defun ldb (bytespec integer)
1071   #!+sb-doc
1072   "Extract the specified byte from integer, and right justify result."
1073   (ldb bytespec integer))
1074
1075 (defun ldb-test (bytespec integer)
1076   #!+sb-doc
1077   "Return T if any of the specified bits in integer are 1's."
1078   (ldb-test bytespec integer))
1079
1080 (defun mask-field (bytespec integer)
1081   #!+sb-doc
1082   "Extract the specified byte from integer,  but do not right justify result."
1083   (mask-field bytespec integer))
1084
1085 (defun dpb (newbyte bytespec integer)
1086   #!+sb-doc
1087   "Return new integer with newbyte in specified position, newbyte is right justified."
1088   (dpb newbyte bytespec integer))
1089
1090 (defun deposit-field (newbyte bytespec integer)
1091   #!+sb-doc
1092   "Return new integer with newbyte in specified position, newbyte is not right justified."
1093   (deposit-field newbyte bytespec integer))
1094
1095 (defun %ldb (size posn integer)
1096   (logand (ash integer (- posn))
1097           (1- (ash 1 size))))
1098
1099 (defun %mask-field (size posn integer)
1100   (logand integer (ash (1- (ash 1 size)) posn)))
1101
1102 (defun %dpb (newbyte size posn integer)
1103   (let ((mask (1- (ash 1 size))))
1104     (logior (logand integer (lognot (ash mask posn)))
1105             (ash (logand newbyte mask) posn))))
1106
1107 (defun %deposit-field (newbyte size posn integer)
1108   (let ((mask (ash (ldb (byte size 0) -1) posn)))
1109     (logior (logand newbyte mask)
1110             (logand integer (lognot mask)))))
1111 \f
1112 ;;;; BOOLE
1113
1114 ;;; The boole function dispaches to any logic operation depending on
1115 ;;;     the value of a variable. Presently, legal selector values are [0..15].
1116 ;;;     boole is open coded for calls with a constant selector. or with calls
1117 ;;;     using any of the constants declared below.
1118
1119 (defconstant boole-clr 0
1120   #!+sb-doc
1121   "Boole function op, makes BOOLE return 0.")
1122
1123 (defconstant boole-set 1
1124   #!+sb-doc
1125   "Boole function op, makes BOOLE return -1.")
1126
1127 (defconstant boole-1   2
1128   #!+sb-doc
1129   "Boole function op, makes BOOLE return integer1.")
1130
1131 (defconstant boole-2   3
1132   #!+sb-doc
1133   "Boole function op, makes BOOLE return integer2.")
1134
1135 (defconstant boole-c1  4
1136   #!+sb-doc
1137   "Boole function op, makes BOOLE return complement of integer1.")
1138
1139 (defconstant boole-c2  5
1140   #!+sb-doc
1141   "Boole function op, makes BOOLE return complement of integer2.")
1142
1143 (defconstant boole-and 6
1144   #!+sb-doc
1145   "Boole function op, makes BOOLE return logand of integer1 and integer2.")
1146
1147 (defconstant boole-ior 7
1148   #!+sb-doc
1149   "Boole function op, makes BOOLE return logior of integer1 and integer2.")
1150
1151 (defconstant boole-xor 8
1152   #!+sb-doc
1153   "Boole function op, makes BOOLE return logxor of integer1 and integer2.")
1154
1155 (defconstant boole-eqv 9
1156   #!+sb-doc
1157   "Boole function op, makes BOOLE return logeqv of integer1 and integer2.")
1158
1159 (defconstant boole-nand  10
1160   #!+sb-doc
1161   "Boole function op, makes BOOLE return log nand of integer1 and integer2.")
1162
1163 (defconstant boole-nor   11
1164   #!+sb-doc
1165   "Boole function op, makes BOOLE return lognor of integer1 and integer2.")
1166
1167 (defconstant boole-andc1 12
1168   #!+sb-doc
1169   "Boole function op, makes BOOLE return logandc1 of integer1 and integer2.")
1170
1171 (defconstant boole-andc2 13
1172   #!+sb-doc
1173   "Boole function op, makes BOOLE return logandc2 of integer1 and integer2.")
1174
1175 (defconstant boole-orc1  14
1176   #!+sb-doc
1177   "Boole function op, makes BOOLE return logorc1 of integer1 and integer2.")
1178
1179 (defconstant boole-orc2  15
1180   #!+sb-doc
1181   "Boole function op, makes BOOLE return logorc2 of integer1 and integer2.")
1182
1183 (defun boole (op integer1 integer2)
1184   #!+sb-doc
1185   "Bit-wise boolean function on two integers. Function chosen by OP:
1186         0       BOOLE-CLR
1187         1       BOOLE-SET
1188         2       BOOLE-1
1189         3       BOOLE-2
1190         4       BOOLE-C1
1191         5       BOOLE-C2
1192         6       BOOLE-AND
1193         7       BOOLE-IOR
1194         8       BOOLE-XOR
1195         9       BOOLE-EQV
1196         10      BOOLE-NAND
1197         11      BOOLE-NOR
1198         12      BOOLE-ANDC1
1199         13      BOOLE-ANDC2
1200         14      BOOLE-ORC1
1201         15      BOOLE-ORC2"
1202   (case op
1203     (0 (boole 0 integer1 integer2))
1204     (1 (boole 1 integer1 integer2))
1205     (2 (boole 2 integer1 integer2))
1206     (3 (boole 3 integer1 integer2))
1207     (4 (boole 4 integer1 integer2))
1208     (5 (boole 5 integer1 integer2))
1209     (6 (boole 6 integer1 integer2))
1210     (7 (boole 7 integer1 integer2))
1211     (8 (boole 8 integer1 integer2))
1212     (9 (boole 9 integer1 integer2))
1213     (10 (boole 10 integer1 integer2))
1214     (11 (boole 11 integer1 integer2))
1215     (12 (boole 12 integer1 integer2))
1216     (13 (boole 13 integer1 integer2))
1217     (14 (boole 14 integer1 integer2))
1218     (15 (boole 15 integer1 integer2))
1219     (t (error 'type-error :datum op :expected-type '(mod 16)))))
1220 \f
1221 ;;;; GCD and LCM
1222
1223 (defun gcd (&rest numbers)
1224   #!+sb-doc
1225   "Return the greatest common divisor of the arguments, which must be
1226   integers. Gcd with no arguments is defined to be 0."
1227   (cond ((null numbers) 0)
1228         ((null (cdr numbers)) (abs (the integer (car numbers))))
1229         (t
1230          (do ((gcd (the integer (car numbers))
1231                    (gcd gcd (the integer (car rest))))
1232               (rest (cdr numbers) (cdr rest)))
1233              ((null rest) gcd)
1234            (declare (integer gcd)
1235                     (list rest))))))
1236
1237 (defun lcm (&rest numbers)
1238   #!+sb-doc
1239   "Return the least common multiple of one or more integers. LCM of no
1240   arguments is defined to be 1."
1241   (cond ((null numbers) 1)
1242         ((null (cdr numbers)) (abs (the integer (car numbers))))
1243         (t
1244          (do ((lcm (the integer (car numbers))
1245                    (lcm lcm (the integer (car rest))))
1246               (rest (cdr numbers) (cdr rest)))
1247              ((null rest) lcm)
1248            (declare (integer lcm) (list rest))))))
1249
1250 (defun two-arg-lcm (n m)
1251   (declare (integer n m))
1252   (if (or (zerop n) (zerop m))
1253       0
1254       ;; KLUDGE: I'm going to assume that it was written this way
1255       ;; originally for a reason.  However, this is a somewhat
1256       ;; complicated way of writing the algorithm in the CLHS page for
1257       ;; LCM, and I don't know why.  To be investigated.  -- CSR,
1258       ;; 2003-09-11
1259       (let ((m (abs m))
1260             (n (abs n)))
1261         (multiple-value-bind (max min)
1262             (if (> m n)
1263                 (values m n)
1264                 (values n m))
1265           (* (truncate max (gcd n m)) min)))))
1266
1267 ;;; Do the GCD of two integer arguments. With fixnum arguments, we use the
1268 ;;; binary GCD algorithm from Knuth's seminumerical algorithms (slightly
1269 ;;; structurified), otherwise we call BIGNUM-GCD. We pick off the special case
1270 ;;; of 0 before the dispatch so that the bignum code doesn't have to worry
1271 ;;; about "small bignum" zeros.
1272 (defun two-arg-gcd (u v)
1273   (cond ((eql u 0) (abs v))
1274         ((eql v 0) (abs u))
1275         (t
1276          (number-dispatch ((u integer) (v integer))
1277            ((fixnum fixnum)
1278             (locally
1279               (declare (optimize (speed 3) (safety 0)))
1280               (do ((k 0 (1+ k))
1281                    (u (abs u) (ash u -1))
1282                    (v (abs v) (ash v -1)))
1283                   ((oddp (logior u v))
1284                    (do ((temp (if (oddp u) (- v) (ash u -1))
1285                               (ash temp -1)))
1286                        (nil)
1287                      (declare (fixnum temp))
1288                      (when (oddp temp)
1289                        (if (plusp temp)
1290                            (setq u temp)
1291                            (setq v (- temp)))
1292                        (setq temp (- u v))
1293                        (when (zerop temp)
1294                          (let ((res (ash u k)))
1295                            (declare (type (signed-byte 31) res)
1296                                     (optimize (inhibit-warnings 3)))
1297                            (return res))))))
1298                 (declare (type (mod 30) k)
1299                          (type (signed-byte 31) u v)))))
1300            ((bignum bignum)
1301             (bignum-gcd u v))
1302            ((bignum fixnum)
1303             (bignum-gcd u (make-small-bignum v)))
1304            ((fixnum bignum)
1305             (bignum-gcd (make-small-bignum u) v))))))
1306 \f
1307 ;;; From discussion on comp.lang.lisp and Akira Kurihara.
1308 (defun isqrt (n)
1309   #!+sb-doc
1310   "Return the root of the nearest integer less than n which is a perfect
1311    square."
1312   (declare (type unsigned-byte n) (values unsigned-byte))
1313   ;; Theoretically (> n 7), i.e., n-len-quarter > 0.
1314   (if (and (fixnump n) (<= n 24))
1315       (cond ((> n 15) 4)
1316             ((> n  8) 3)
1317             ((> n  3) 2)
1318             ((> n  0) 1)
1319             (t 0))
1320       (let* ((n-len-quarter (ash (integer-length n) -2))
1321              (n-half (ash n (- (ash n-len-quarter 1))))
1322              (n-half-isqrt (isqrt n-half))
1323              (init-value (ash (1+ n-half-isqrt) n-len-quarter)))
1324         (loop
1325           (let ((iterated-value
1326                  (ash (+ init-value (truncate n init-value)) -1)))
1327             (unless (< iterated-value init-value)
1328               (return init-value))
1329             (setq init-value iterated-value))))))
1330 \f
1331 ;;;; miscellaneous number predicates
1332
1333 (macrolet ((def (name doc)
1334              `(defun ,name (number) ,doc (,name number))))
1335   (def zerop "Is this number zero?")
1336   (def plusp "Is this real number strictly positive?")
1337   (def minusp "Is this real number strictly negative?")
1338   (def oddp "Is this integer odd?")
1339   (def evenp "Is this integer even?"))
1340 \f
1341 ;;;; modular functions
1342 #.
1343 (collect ((forms))
1344   (flet ((definition (name lambda-list width pattern)
1345            `(defun ,name ,lambda-list
1346               (flet ((prepare-argument (x)
1347                        (declare (integer x))
1348                        (etypecase x
1349                          ((unsigned-byte ,width) x)
1350                          (fixnum (logand x ,pattern))
1351                          (bignum (logand x ,pattern)))))
1352                 (,name ,@(loop for arg in lambda-list
1353                                collect `(prepare-argument ,arg)))))))
1354     (loop for infos being each hash-value of sb!c::*modular-funs*
1355           ;; FIXME: We need to process only "toplevel" functions
1356           when (listp infos)
1357           do (loop for info in infos
1358                    for name = (sb!c::modular-fun-info-name info)
1359                    and width = (sb!c::modular-fun-info-width info)
1360                    and lambda-list = (sb!c::modular-fun-info-lambda-list info)
1361                    for pattern = (1- (ash 1 width))
1362                    do (forms (definition name lambda-list width pattern)))))
1363   `(progn ,@(forms)))
1364
1365 ;;; KLUDGE: these out-of-line definitions can't use the modular
1366 ;;; arithmetic, as that is only (currently) defined for constant
1367 ;;; shifts.  See also the comment in (LOGAND OPTIMIZER) for more
1368 ;;; discussion of this hack.  -- CSR, 2003-10-09
1369 #!-alpha
1370 (defun sb!vm::ash-left-mod32 (integer amount)
1371   (etypecase integer
1372     ((unsigned-byte 32) (ldb (byte 32 0) (ash integer amount)))
1373     (fixnum (ldb (byte 32 0) (ash (logand integer #xffffffff) amount)))
1374     (bignum (ldb (byte 32 0) (ash (logand integer #xffffffff) amount)))))
1375 #!+alpha
1376 (defun sb!vm::ash-left-mod64 (integer amount)
1377   (etypecase integer
1378     ((unsigned-byte 64) (ldb (byte 64 0) (ash integer amount)))
1379     (fixnum (ldb (byte 64 0) (ash (logand integer #xffffffffffffffff) amount)))
1380     (bignum (ldb (byte 64 0)
1381                  (ash (logand integer #xffffffffffffffff) amount)))))