(defun upgraded-complex-part-type (spec)
#!+sb-doc
- "Returns the element type of the most specialized COMPLEX number type that
+ "Return the element type of the most specialized COMPLEX number type that
can hold parts of type SPEC."
(cond ((unknown-type-p (specifier-type spec))
(error "undefined type: ~S" spec))
(defun conjugate (number)
#!+sb-doc
- "Returns the complex conjugate of NUMBER. For non-complex numbers, this is
+ "Return the complex conjugate of NUMBER. For non-complex numbers, this is
an identity."
(if (complexp number)
(complex (realpart number) (- (imagpart number)))
(res (car args) (,op res (car args))))
((null args) res))))))
(define-arith + 0
- "Returns the sum of its arguments. With no args, returns 0.")
+ "Return the sum of its arguments. With no args, returns 0.")
(define-arith * 1
- "Returns the product of its arguments. With no args, returns 1."))
+ "Return the product of its arguments. With no args, returns 1."))
(defun - (number &rest more-numbers)
#!+sb-doc
(defun 1+ (number)
#!+sb-doc
- "Returns NUMBER + 1."
+ "Return NUMBER + 1."
(1+ number))
(defun 1- (number)
#!+sb-doc
- "Returns NUMBER - 1."
+ "Return NUMBER - 1."
(1- number))
(eval-when (:compile-toplevel)
(defun truncate (number &optional (divisor 1))
#!+sb-doc
- "Returns number (or number/divisor) as an integer, rounded toward 0.
+ "Return number (or number/divisor) as an integer, rounded toward 0.
The second returned value is the remainder."
(macrolet ((truncate-float (rtype)
`(let* ((float-div (coerce divisor ',rtype))
(defun floor (number &optional (divisor 1))
#!+sb-doc
- "Returns the greatest integer not greater than number, or number/divisor.
+ "Return the greatest integer not greater than number, or number/divisor.
The second returned value is (mod number divisor)."
;; If the numbers do not divide exactly and the result of
;; (/ NUMBER DIVISOR) would be negative then decrement the quotient
(defun ceiling (number &optional (divisor 1))
#!+sb-doc
- "Returns the smallest integer not less than number, or number/divisor.
+ "Return the smallest integer not less than number, or number/divisor.
The second returned value is the remainder."
;; If the numbers do not divide exactly and the result of
;; (/ NUMBER DIVISOR) would be positive then increment the quotient
(defun rem (number divisor)
#!+sb-doc
- "Returns second result of TRUNCATE."
+ "Return second result of TRUNCATE."
(multiple-value-bind (tru rem) (truncate number divisor)
(declare (ignore tru))
rem))
(defun mod (number divisor)
#!+sb-doc
- "Returns second result of FLOOR."
+ "Return second result of FLOOR."
(let ((rem (rem number divisor)))
(if (and (not (zerop rem))
(if (minusp divisor)
(defun = (number &rest more-numbers)
#!+sb-doc
- "Returns T if all of its arguments are numerically equal, NIL otherwise."
+ "Return T if all of its arguments are numerically equal, NIL otherwise."
(do ((nlist more-numbers (cdr nlist)))
((atom nlist) T)
(declare (list nlist))
(defun /= (number &rest more-numbers)
#!+sb-doc
- "Returns T if no two of its arguments are numerically equal, NIL otherwise."
+ "Return T if no two of its arguments are numerically equal, NIL otherwise."
(do* ((head number (car nlist))
(nlist more-numbers (cdr nlist)))
((atom nlist) t)
(defun < (number &rest more-numbers)
#!+sb-doc
- "Returns T if its arguments are in strictly increasing order, NIL otherwise."
+ "Return T if its arguments are in strictly increasing order, NIL otherwise."
(do* ((n number (car nlist))
(nlist more-numbers (cdr nlist)))
((atom nlist) t)
(defun > (number &rest more-numbers)
#!+sb-doc
- "Returns T if its arguments are in strictly decreasing order, NIL otherwise."
+ "Return T if its arguments are in strictly decreasing order, NIL otherwise."
(do* ((n number (car nlist))
(nlist more-numbers (cdr nlist)))
((atom nlist) t)
(defun <= (number &rest more-numbers)
#!+sb-doc
- "Returns T if arguments are in strictly non-decreasing order, NIL otherwise."
+ "Return T if arguments are in strictly non-decreasing order, NIL otherwise."
(do* ((n number (car nlist))
(nlist more-numbers (cdr nlist)))
((atom nlist) t)
(defun >= (number &rest more-numbers)
#!+sb-doc
- "Returns T if arguments are in strictly non-increasing order, NIL otherwise."
+ "Return T if arguments are in strictly non-increasing order, NIL otherwise."
(do* ((n number (car nlist))
(nlist more-numbers (cdr nlist)))
((atom nlist) t)
(defun max (number &rest more-numbers)
#!+sb-doc
- "Returns the greatest of its arguments."
+ "Return the greatest of its arguments."
(do ((nlist more-numbers (cdr nlist))
(result number))
((null nlist) (return result))
(defun min (number &rest more-numbers)
#!+sb-doc
- "Returns the least of its arguments."
+ "Return the least of its arguments."
(do ((nlist more-numbers (cdr nlist))
(result number))
((null nlist) (return result))
(defun logior (&rest integers)
#!+sb-doc
- "Returns the bit-wise or of its arguments. Args must be integers."
+ "Return the bit-wise or of its arguments. Args must be integers."
(declare (list integers))
(if integers
(do ((result (pop integers) (logior result (pop integers))))
(defun logxor (&rest integers)
#!+sb-doc
- "Returns the bit-wise exclusive or of its arguments. Args must be integers."
+ "Return the bit-wise exclusive or of its arguments. Args must be integers."
(declare (list integers))
(if integers
(do ((result (pop integers) (logxor result (pop integers))))
(defun logand (&rest integers)
#!+sb-doc
- "Returns the bit-wise and of its arguments. Args must be integers."
+ "Return the bit-wise and of its arguments. Args must be integers."
(declare (list integers))
(if integers
(do ((result (pop integers) (logand result (pop integers))))
(defun logeqv (&rest integers)
#!+sb-doc
- "Returns the bit-wise equivalence of its arguments. Args must be integers."
+ "Return the bit-wise equivalence of its arguments. Args must be integers."
(declare (list integers))
(if integers
(do ((result (pop integers) (logeqv result (pop integers))))
(defun lognand (integer1 integer2)
#!+sb-doc
- "Returns the complement of the logical AND of integer1 and integer2."
+ "Return the complement of the logical AND of integer1 and integer2."
(lognand integer1 integer2))
(defun lognor (integer1 integer2)
#!+sb-doc
- "Returns the complement of the logical OR of integer1 and integer2."
+ "Return the complement of the logical OR of integer1 and integer2."
(lognor integer1 integer2))
(defun logandc1 (integer1 integer2)
#!+sb-doc
- "Returns the logical AND of (LOGNOT integer1) and integer2."
+ "Return the logical AND of (LOGNOT integer1) and integer2."
(logandc1 integer1 integer2))
(defun logandc2 (integer1 integer2)
#!+sb-doc
- "Returns the logical AND of integer1 and (LOGNOT integer2)."
+ "Return the logical AND of integer1 and (LOGNOT integer2)."
(logandc2 integer1 integer2))
(defun logorc1 (integer1 integer2)
#!+sb-doc
- "Returns the logical OR of (LOGNOT integer1) and integer2."
+ "Return the logical OR of (LOGNOT integer1) and integer2."
(logorc1 integer1 integer2))
(defun logorc2 (integer1 integer2)
#!+sb-doc
- "Returns the logical OR of integer1 and (LOGNOT integer2)."
+ "Return the logical OR of integer1 and (LOGNOT integer2)."
(logorc2 integer1 integer2))
(defun lognot (number)
#!+sb-doc
- "Returns the bit-wise logical not of integer."
+ "Return the bit-wise logical not of integer."
(etypecase number
(fixnum (lognot (truly-the fixnum number)))
(bignum (bignum-logical-not number))))
(defun integer-length (integer)
#!+sb-doc
- "Returns the number of significant bits in the absolute value of integer."
+ "Return the number of significant bits in the absolute value of integer."
(etypecase integer
(fixnum
(integer-length (truly-the fixnum integer)))
(defun byte (size position)
#!+sb-doc
- "Returns a byte specifier which may be used by other byte functions."
+ "Return a byte specifier which may be used by other byte functions
+ (e.g. LDB)."
(byte size position))
(defun byte-size (bytespec)
#!+sb-doc
- "Returns the size part of the byte specifier bytespec."
+ "Return the size part of the byte specifier bytespec."
(byte-size bytespec))
(defun byte-position (bytespec)
#!+sb-doc
- "Returns the position part of the byte specifier bytespec."
+ "Return the position part of the byte specifier bytespec."
(byte-position bytespec))
(defun ldb (bytespec integer)
(defun ldb-test (bytespec integer)
#!+sb-doc
- "Returns T if any of the specified bits in integer are 1's."
+ "Return T if any of the specified bits in integer are 1's."
(ldb-test bytespec integer))
(defun mask-field (bytespec integer)
(defun dpb (newbyte bytespec integer)
#!+sb-doc
- "Returns new integer with newbyte in specified position, newbyte is right justified."
+ "Return new integer with newbyte in specified position, newbyte is right justified."
(dpb newbyte bytespec integer))
(defun deposit-field (newbyte bytespec integer)
#!+sb-doc
- "Returns new integer with newbyte in specified position, newbyte is not right justified."
+ "Return new integer with newbyte in specified position, newbyte is not right justified."
(deposit-field newbyte bytespec integer))
(defun %ldb (size posn integer)
(defun gcd (&rest numbers)
#!+sb-doc
- "Returns the greatest common divisor of the arguments, which must be
+ "Return the greatest common divisor of the arguments, which must be
integers. Gcd with no arguments is defined to be 0."
(cond ((null numbers) 0)
((null (cdr numbers)) (abs (the integer (car numbers))))
(defun lcm (&rest numbers)
#!+sb-doc
- "Returns the least common multiple of one or more integers. LCM of no
+ "Return the least common multiple of one or more integers. LCM of no
arguments is defined to be 1."
(cond ((null numbers) 1)
((null (cdr numbers)) (abs (the integer (car numbers))))
;;; From discussion on comp.lang.lisp and Akira Kurihara.
(defun isqrt (n)
#!+sb-doc
- "Returns the root of the nearest integer less than n which is a perfect
+ "Return the root of the nearest integer less than n which is a perfect
square."
(declare (type unsigned-byte n) (values unsigned-byte))
;; Theoretically (> n 7), i.e., n-len-quarter > 0.
(macrolet ((def-frob (name doc)
`(defun ,name (number) ,doc (,name number))))
- (def-frob zerop "Returns T if number = 0, NIL otherwise.")
- (def-frob plusp "Returns T if number > 0, NIL otherwise.")
- (def-frob minusp "Returns T if number < 0, NIL otherwise.")
- (def-frob oddp "Returns T if number is odd, NIL otherwise.")
- (def-frob evenp "Returns T if number is even, NIL otherwise."))
+ (def-frob zerop "Is this number zero?")
+ (def-frob plusp "Is this real number strictly positive?")
+ (def-frob minusp "Is this real number strictly negative?")
+ (def-frob oddp "Is this integer odd?")
+ (def-frob evenp "Is this integer even?"))
projects / sbcl.git / blobdiff