(index ("infinite?" 0) ("nan?" 476) ("exact" 618) ("inexact" 618) ("exact-integer-sqrt" 880) ("exact-integer-nth-root" 1325) ("exact-integer?" 1662) ("quotient&remainder" 1767) ("quotient&modulo" 2162) ("floor/" 2362) ("floor-quotient" 2362) ("floor-remainder" 2362) ("truncate/" 2362) ("truncate-quotient" 2362) ("truncate-remainder" 2362) ("conj" 3784) ("bignum?" 3882) ("ratnum?" 3975) ("cplxnum?" 4046) ("rectnum?" 4121) ("compnum?" 4251) ("cflonum?" 4335) ("cintnum?" 4443) ("integer-length" 4541))
(def (sig (procedure "(infinite? Z)" (id infinite?))) (p "Is the number " (tt "Z") " " (tt "+inf.0") " or " (tt "-inf.0") ", or a complex number containing either infinity as its real or imaginary part?") (p "From R6RS and R7RS.") (p (b "Note") ": This is " (b "not") " the inverse of " (tt "finite?") ", since it produces " (tt "#f") " on " (tt "nan.0") " (or complex numbers containing " (tt "nan.0") "), while " (tt "finite?") " also returns " (tt "#f") " in that case."))
(def (sig (procedure "(nan? Z)" (id nan?))) (p "Is the object " (tt "Z") " a real representing " (tt "nan.0") "?") (p "From R6RS and R7RS."))
(def (sig (procedure "(exact Z)" (id exact)) (procedure "(inexact Z)" (id inexact))) (p "Convert " (tt "Z") " to an exact or an inexact number, respectively.  These are just the R6RS and R7RS names for " (tt "inexact->exact") " and " (tt "exact->inexact") "."))
(def (sig (procedure "(exact-integer-sqrt K)" (id exact-integer-sqrt))) (p "Returns two values " (tt "s") " and " (tt "r") ", where " (tt "s^2 + r = K") " and " (tt "K < (s+1)^2") ". In other words, " (tt "s") " is the closest square root we can find that's equal to or smaller than " (tt "K") ", and " (tt "r") " is the rest if " (tt "K") " isn't a neat square of two numbers.") (p "This procedure is compatible with the R7RS specification."))
(def (sig (procedure "(exact-integer-nth-root K N)" (id exact-integer-nth-root))) (p "Like " (tt "exact-integer-sqrt") ", but with any base value.  Calculates " (tt "\\sqrt[N]{K") "}, the " (tt "N") "th root of " (tt "K") " and returns two values " (tt "s") " and " (tt "r") " where " (tt "s^N + r = K") " and " (tt "K < (s+1)^N") "."))
(def (sig (procedure "(exact-integer? X)" (id exact-integer?))) (p "Is " (tt "X") " an exact integer?"))
(def (sig (procedure "(quotient&remainder A B)" (id quotient&remainder))) (p "Return the quotient " (i "and") " the remainder of A divided by B.") (p "This is especially useful for bignums, since both numbers are derived simultaneously.  This saves performing the division algorithm twice.") (p "This name is deprecated in favor of its more \"regular\" alias from R7RS, " (tt "truncate/") "."))
(def (sig (procedure "(quotient&modulo A B)" (id quotient&modulo))) (p "Like " (tt "quotient&remainder") ", except return the modulo instead of remainder.") (p "This procedure has been deprecated."))
(def (sig (procedure "(floor/ A B)" (id floor/)) (procedure "(floor-quotient A B)" (id floor-quotient)) (procedure "(floor-remainder A B)" (id floor-remainder)) (procedure "(truncate/ A B)" (id truncate/)) (procedure "(truncate-quotient A B)" (id truncate-quotient)) (procedure "(truncate-remainder A B)" (id truncate-remainder))) (p "These procedures are from R7RS.") (p "The " (tt "floor/") " and " (tt "truncate/") " versions return two values: the quotient and remainder obtained after dividing " (tt "A") " by " (tt "B") ".  The " (tt "-quotient") " and " (tt "-remainder procedures") " simply return only the corresponding value of the \"full\" computation.") (p "The difference is in how the values are derived for negative values.") (p "If both values are desired, the two-value versions are recommended, as they perform the computation only once.") (p "All the procedures compute a quotient " (tt "q") " and remainder " (tt "r") " such that " (tt "A = nq + r") ".  The remainder is determined by the choice for " (tt "q") ", through the relation " (tt "r = A - nq") ".  The " (tt "floor") " procedures compute " (tt "q = floor(A/B)") " and the " (tt "truncate") " procedures compute " (tt "q = truncate(A/B)") ".") (p "See " (link "http://people.csail.mit.edu/riastradh/tmp/division.txt" "Riastradh's proposal for Division operators in Scheme") " for a full explanation of the intricacies of these procedures."))
(def (sig (procedure "(conj Z)" (id conj))) (p "Returns the conjugate of the complex number Z."))
(def (sig (procedure "(bignum? X)" (id bignum?))) (p "Is X an extended-precision integer?"))
(def (sig (procedure "(ratnum? X)" (id ratnum?))) (p "Is X a ratio?"))
(def (sig (procedure "(cplxnum? X)" (id cplxnum?))) (p "Is X a complex?"))
(def (sig (procedure "(rectnum? X)" (id rectnum?))) (p "Is X an exact-complex? (Treats an integer-floatingpoint as \"exact\".)"))
(def (sig (procedure "(compnum? X)" (id compnum?))) (p "Is X an inexact-complex?"))
(def (sig (procedure "(cflonum? X)" (id cflonum?))) (p "Is X a floatingpoint-complex or a floatingpoint?"))
(def (sig (procedure "(cintnum? X)" (id cintnum?))) (p "Is X an integer-complex or an integer?"))
(def (sig (procedure "(integer-length X)" (id integer-length))) (p "From " (link "http://srfi.schemers.org/srfi-60" "SRFI-60") "; get the number of bits required to represent the integer " (tt "X") " in 2s complement notation."))
