Revised⁷ Report on the Algorithmic Language Scheme
The Valued Fascicle

1.1: Disjointness of types

No object satisfies more than one of the following predicates:

• boolean?
• char?
• null?
• pair?
• procedure?
• symbol?
• bytevector?
• eof-object?
• number?
• port?
• string?
• vector?
• ⟨n⟩vector?

and all predicates created by define-record-type.TODO: Link to records section, and maybe add other types

There is one exception to the disjointness of number vector types: u8vectors and bytevectors are the same type.

Although there is a separate boolean type, any Scheme value can be used as a boolean value for the purpose of a conditional test. As explained in section 5, all values count as true in such a test except for #f. This report uses the word “true” to refer to any Scheme value except #f, and the word “false” to refer to #f.

1.2: External representations

An important concept in Scheme (and Lisp) is that of the external representation of an object as a sequence of characters. For example, an external representation of the integer 28 is the sequence of characters “28”, and an external representation of a list consisting of the integers 8 and 13 is the sequence of characters “(8 13)”.

The external representation of an object is not necessarily unique. The integer 28 also has representations “#e28.000” and “#x1c”, and the list in the previous paragraph also has the representations “( 08 13 )” and “(8 . (13 . ()))” (see section 6).

Many objects have standard external representations, but some, such as procedures, do not have standard representations (although particular implementations may define representations for them).

An external representation can be written in a program to obtain the corresponding object (see quote, section TODO).

TODO: read and write

Note that the sequence of characters “(+ 2 6)” is not an external representation of the integer 8, even though it is an expression evaluating to the integer 8; rather, it is an external representation of a three-element list, the elements of which are the symbol + and the integers 2 and 6. Scheme’s syntax has the property that any sequence of characters that is an expression is also the external representation of some object. This can lead to confusion, since it is not always obvious out of context whether a given sequence of characters is intended to denote data or program, but it is also a source of power, since it facilitates writing programs such as interpreters and compilers that treat programs as data (or vice versa).

The syntax of external representations of various kinds of objects accompanies the description of the primitives for manipulating the objects in the appropriate sections.

1.3: Storage model

Every object that denotes locations is either mutable or immutable. Literal constants, and other values explicitly designated as immutable are immutable objects. All objects created by the other procedures listed in this report are mutable. It is undefined behavior to attempt to store a new value into a location that is denoted by an immutable object. An attempt to store a new value into a location referred to by an immutable object should raise an exception.

2.2: Quasiquotation

• (quasiquote ⟨qq template⟩) syntax
• `⟨qq template⟩ lexical syntax
• unquote auxiliary syntax
• ,⟨expression⟩ lexical syntax
• unquote-splicing auxiliary syntax
• ,@⟨expression⟩ lexical syntax

`(list ,(+ 1 2) 4)⇒ (list 3 4)

(let ((name 'a)) `(list ,name ',name))⇒ (list a (quote a))

`(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b)⇒ (a 3 4 5 6 b)

`(( foo ,(- 10 3)) ,@(cdr '(c)) . ,(car '(cons)))⇒ ((foo 7) . cons)

`#(10 5 ,(sqrt 4) ,@(map sqrt '(16 9)) 8)⇒ #(10 5 2 4 3 8)

(let ((foo '(foo bar)) (@baz 'baz))
  `(list ,@foo , @baz))⇒ (list foo bar baz)

`(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)⇒ (a `(b ,(+ 1 2) ,(foo 4 d) e) f)

(let ((name1 'x)
      (name2 'y))
  `(a `(b ,,name1 ,',name2 d) e))⇒ (a `(b ,x ,'y d) e)

(let ((a 3)) `((1 2) ,a ,4 ,'five 6))

`((1 2) 3 4 five 6)

(let ((a 3))
  (cons '(1 2)
        (cons a (cons 4 (cons 'five '(6))))))

(let ((a 3)) (list (list 1 2) a 4 'five 6))

2.3: Quasiquote syntax

The following grammar for quasiquote expressions is not context-free. It is presented as a recipe for generating an infinite number of production rules. Imagine a copy of the following rules for D = 1, 2, 3, …, where D is the nesting depth.

⟨quasiquotation⟩

::= ⟨quasiquotation 1⟩

⟨qq template 0⟩

::= ⟨expression⟩

⟨quasiquotation D⟩

::= `⟨qq template D⟩

::= (quasiquote ⟨qq template D⟩)

⟨qq template D⟩

::= ⟨simple datum⟩

::= ⟨list qq template D⟩

::= ⟨vector qq template D⟩

::= ⟨unquotation D⟩

⟨list qq template D⟩

::= (⟨qq template or splice D⟩^*)

::= (⟨qq template or splice D⟩⁺ . ⟨qq template D⟩)

::= '⟨qq template D⟩

::= ⟨quasiquotation D + 1⟩

⟨vector qq template D⟩

::= #(⟨qq template or splice D⟩^*)

⟨unquotation D⟩

::= ,⟨qq template D − 1⟩

::= (unquote ⟨qq template D − 1⟩)

⟨qq template or splice D⟩

::= ⟨qq template D⟩

::= ⟨splicing unquotation D⟩

⟨splicing unquotation D⟩

::= ,@⟨qq template D − 1⟩

::= (unquote-splicing ⟨qq template D − 1⟩)

4.1: Numerical tower

Numbers may be arranged into a tower of subsets in which each level is a subset of the level above it:

• number

• complex number

• real number

• rational number

• integer

For example, 5 is an integer. Therefore 5 is also a rational, a real, and a complex. The same is true of the number objects that model 5.

Numbers are organized as a corresponding tower of subtypes defined by the predicates number?, complex?, real?, rational?, and integer?; see section 4.6.

There is no simple relationship between a number’s type and its representation inside a computer. Although most implementations of Scheme will offer at least two different representations of 3, these different representations denote the same integer.

Scheme’s numerical operations treat numbers as abstract data, as independent of their representation as possible. Although an implementation of Scheme may use multiple internal representations of numbers, this ought not to be apparent to a casual programmer writing simple programs.

4.2: Exactness

It is useful to distinguish between numbers that are represented exactly, and those that might not be. For example, index operations into data structures may need to know the index exactly, as may some operations on polynomial coefficients in a symbolic algebra system. On the other hand, the results of measurements are inherently inexact, and irrational numbers may be approximated by rational and therefore inexact approximations. In order to catch uses of numbers known only inexactly where exact numbers are required, Scheme explicitly distinguishes exact from inexact numbers. This distinction is orthogonal to the dimension of type.

A number is exact if it is the value of an exact numerical literal or was derived from exact numbers using only exact operations. Exact numbers correspond to mathematical numbers in the obvious way.

Conversely, a number is inexact if it is the value of an inexact numerical literal, or was derived from inexact numbers, or was derived using inexact operations. Thus inexactness is contagious.

Exact arithmetic is reliable in the following sense: If exact numbers are passed to any of the arithmetic procedures described in section TODO, and an exact number object is returned, then the result is mathematically correct. This is generally not true of computations involving inexact numbers because approximate methods such as floating-point arithmetic may be used, but it is the duty of each implementation to make the result as close as practical to the mathematically ideal result.

4.3: Implementation requirements

Implementations of Scheme must support numbers for the entire tower of subtypes given in section 4.1. Moreover, implementations must support exact integers and exact rationals of practically unlimited size and precision, and to implement certain procedures (listed in section TODO) so they always return exact results when given exact arguments. ( “Practically unlimited” means that the size and precision of these numbers should only be limited by the size of the available memory.)

Implementations may support only a limited range of inexact number objects of any type, subject to the requirements of this section. For example, an implementation may limit the range of the inexact reals (and therefore the range of inexact integers and rationals) to the dynamic range of the flonum format. Furthermore the gaps between the inexact integers and rationals are likely to be very large in such an implementation as the limits of this range are approached.Where does this leave mixed-exactness complex numbers? I read this as making them optional. Also how does "range" apply to complex numbers?

An implementation may use floating point and other approximate representation strategies for inexact numbers. This report recommends, but does not require, that the IEEE floating-point standards be followed by implementations that use floating-point representations, and that implementations using other representations should match or exceed the precision achievable using these floating-point standards TODO: cite IEEE 754.

Implementations must distinguish between 0.0 and -0.0, i.e., positive and negative inexact zero. These two numbers are not eqv?. The behavior of the transcendental functions is sensitive to the distinction in accordance with IEEE 754. The negation of negative zero is ordinary zero and vice versa. This implies that the sum of two or more negative zeros is negative, and the result of subtracting (positive) zero from a negative zero is likewise negative. However, numerical comparisons treat negative zero as equal to zero.

Implementations must also distinguish +inf.0, -inf.0, i.e. positive and negative infinity. Positive infinity is an inexact real (not rational) number that represents an indeterminate number greater than all representable rationals. Negative infinity is regarded as an inexact real (not rational) that represents an indeterminate number less than all representable rationals. The behavior of the procedures in this section is sensitive to infinity in accordance with IEEE 754.

Implementations must also supply a NaN value, which is an inexact real (not rational) so indeterminate that it might represent any real number, including positive or negative infinity, and might even be greater than positive infinity or less than negative infinity. NaN always compares false to any number, including a NaN. An arithmetic operation where one operand is NaN returns NaN, unless the implementation can prove that the result would be the same if the NaN were replaced by any rational number.

Implementations should support all quiet and signalling NaNs that are available in their inexact number formats, to propagate NaN values in the way that IEEE 754-2019 specifies, and to return the appropriate NaN values when a value cannot be represented. No procedures are supplied that allow the user to inspect a NaN, except for comparing them for equality using eqv?.

Implementations may supply more than one of the above numbers, for example if the implementation has multiple different floating point representations.

In particular, implementations that use floating-point representations must follow these rules: A floating-point result must be represented with at least as much precision as is used to express any of the inexact arguments to that operation. Potentially inexact operations such as sqrt, when applied to exact arguments, should produce exact answers whenever possible (for example the square root of an exact 4 ought to be an exact 2). However, this is not required.Should the following two sentences be removed? If, on the other hand, an exact number object is operated upon so as to produce an inexact result (as by sqrt), and if the result is represented in floating point, then the most precise floating-point format available must be used; but if the result is represented in some other way then the representation must have at least as much precision as the most precise floating-point format available.

It is the programmer’s responsibility to avoid using inexact number objects with magnitude or significand too large to be represented in the implementation.

4.4: Propagation of exactness

The procedures listed below must return the mathematically correct exact result provided all their arguments are exact:

• +
• -
• *
• max
• min
• abs
• numerator
• denominator
• gcd
• lcm
• floor
• ceiling
• truncate
• round-away
• round
• rationalize
• real-part
• imag-part
• make-rectangular

The procedures listed below must return the correct exact result provided all their arguments are exact, and no divisors are zero:

• /
• floor/
• floor-quotient
• floor-remainder
• truncate/
• truncate-quotient
• truncate-remainder
• quotient
• remainder
• modulo

Moreover, the procedure expt must return the correct exact result provided its first argument is an exact real number object and its second argument is an exact integer.

The general rule is that the generic operations return the correct exact result when all of their arguments are exact and the result is mathematically well-defined, but return an inexact result when any argument is inexact. Exceptions to this rule include sqrt, exp, log, sin, cos, tan, asin, acos, atan, expt, make-polar, magnitude, and angle, which may (but are not required to) return inexact results even when given exact arguments, as indicated in the specification of these procedures.

One general exception to the rule above is that an implementation may return an exact result despite inexact arguments if that exact result would be the correct result for all possible substitutions of exact arguments for the inexact ones. An example is (* 1.0 0) which may return either 0 (exact) or 0.0 (inexact).

4.5: Number syntax

When a rule ends with R, the rule is implicitly replicated for R equal to 2, 8, 10, and 16. Although not shown below, all alphabetic characters used in the grammar of numbers can appear in either upper or lower case.

Between any two digits of a number, a single underscore may appear.

⟨number⟩

::= ⟨num 2⟩

::= ⟨num 8⟩

::= ⟨num 10⟩

::= ⟨num 16⟩

⟨num R⟩

::= ⟨prefix R⟩⟨complex R⟩

⟨complex R⟩

::= ⟨real R⟩

::= ⟨real R⟩@⟨real R⟩

::= ⟨real R⟩+⟨ureal R⟩i

::= ⟨real R⟩-⟨ureal R⟩i

::= ⟨real R⟩+i

::= ⟨real R⟩-i

::= ⟨real R⟩⟨infnan⟩i

::= +⟨ureal R⟩i

::= -⟨ureal R⟩i

::= ⟨infnan⟩i

::= +i

::= -i

⟨real R⟩

::= ⟨sign⟩⟨ureal R⟩

::= ⟨infnan⟩

⟨ureal R⟩

::= ⟨uinteger R⟩

::= ⟨uinteger R⟩/⟨uinteger R⟩

::= ⟨decimal R⟩

⟨digits R⟩

::= ⟨digit R⟩⁺⟨more digits R⟩

⟨more digits R⟩

::= ⟨empty⟩

::= _⟨digits R⟩

⟨maybe digits R⟩

::= ⟨empty⟩

::= ⟨digits R⟩

⟨decimal 10⟩

::= ⟨uinteger 10⟩⟨suffix⟩

::= .⟨digits 10⟩⟨suffix⟩

::= ⟨digits 10⟩.⟨maybe digits 10⟩⟨suffix⟩

⟨uinteger R⟩

::= ⟨digits R⟩

⟨prefix R⟩

::= ⟨radix R⟩⟨exactness⟩

::= ⟨exactness⟩⟨radix R⟩

⟨infnan⟩

::= +inf.0

::= -inf.0

::= +nan.0

::= -nan.0

⟨suffix⟩

::= ⟨empty⟩

::= ⟨exponent marker⟩⟨sign⟩⟨digits 10⟩

⟨exponent marker⟩

::= e

⟨sign⟩

::= ⟨empty⟩

::= +

::= -

⟨exactness⟩

::= ⟨empty⟩

::= #i

::= #e

⟨radix 2⟩

::= #b

⟨radix 8⟩

::= #o

⟨radix 10⟩

::= ⟨empty⟩

::= #d

⟨radix 16⟩

::= #x

⟨digit 2⟩

::= 0

::= 1

⟨digit 8⟩

::= 0

::= 1

::= 2

::= 3

::= 4

::= 5

::= 6

::= 7

⟨digit 10⟩

::= ⟨any ASCII numeral⟩

⟨digit 16⟩

::= ⟨digit 10⟩

::= a

::= b

::= c

::= d

::= e

::= f

When the R⁶RS lexical mode is enabled, the following productions are modified:

⟨more digits R⟩

::= ⟨empty⟩

⟨exponent marker⟩

::= e

::= s

::= f

::= d

::= l

⟨ureal R⟩

::= ⟨uinteger R⟩

::= ⟨uinteger R⟩/⟨uinteger R⟩

::= ⟨decimal R⟩⟨mantissa width⟩

⟨mantissa width⟩

::= |⟨digits 10⟩

4.6: Number predicates

These numerical type predicates can be applied to any kind of argument. They return #t if the object is a number object of the named type, and #f otherwise. In general, if a type predicate is true of a number object then all higher type predicates are also true of that number object. Consequently, if a type predicate is false of a number object, then all lower type predicates are also false of that number object.

(number? 0)⇒ #t

(number? 0.0)⇒ #t

(number? 1/2)⇒ #t

(number? 1+2i)⇒ #t

(number? "1")⇒ #f

(number? '(1))⇒ #f

(complex? 3+4i)⇒ #t

(complex? 3)⇒ #t

(define (real? x)
  (and (complex? x)
       (zero? (imag-part x))))

(real? 3+4i)⇒ #f

(real? 3)⇒ #t

(real? -2.5+0i)⇒ #t

(real? -2.5+0.0i)⇒ #t

(real? -2.5-0.0i)⇒ #t

(real? #e1e10)⇒ #t

(real? +inf.0)⇒ #t

(real? +nan.0)⇒ #t

(define (strictly-real? obj)
  (and (real? obj)
       (exact? (imag-part obj))))

(strictly-real? 3+4i)⇒ #f

(strictly-real? 3)⇒ #t

(strictly-real? -2.5+0i)⇒ #t

(strictly-real? -2.5+0.0i)⇒ #f

(strictly-real? -2.5-0.0i)⇒ #f

(strictly-real? #e1e10)⇒ #t

(strictly-real? +inf.0)⇒ #t

(strictly-real? +nan.0)⇒ #t

(define (integer? obj)
  (and (rational? obj)
       (= 1 (denominator obj))))

(integer? 3+0i)⇒ #t

(integer? 3.0)⇒ #t

(integer? 8/4)⇒ #t

(integer? 3.1)⇒ #f

(integer? 3+1i)⇒ #f

(integer? 3+0.0i)⇒ #t

(integer? 3-0.0i)⇒ #t

(strictly-integer? 3+0i)⇒ #t

(strictly-integer? 3.0)⇒ #t

(strictly-integer? 8/4)⇒ #t

(strictly-integer? 3.1)⇒ #f

(strictly-integer? 3+1i)⇒ #f

(strictly-integer? 3+0.0i)⇒ #f

(strictly-integer? 3-0.0i)⇒ #f

4.7: Fixnums

Fixnums are an implementation-defined subset of the exact integers. Every implementation must define its fixnum range as a closed interval $[-2^{w-1},2^{w-1}-1]$, where $w$ is an integer greater than or equal to 24. Every mathematical integer within an implementation's fixnum range must correspond to an exact integer that is representable within the implementation. A fixnum is an exact integer whose value lies within this fixnum range. Exact integers outside of the fixnum range are generally called bignums.

Fixnum operations perform integer arithmetic on their fixnum arguments. If any argument is not a fixnum, or if the mathematical result is not representable as a fixnum, it is a domain error: this is known as the fixnum rule.

Fixnum procedures are listed next to generic arithmetic procedures that they are equivalent to. The description of such procedures applies to the fixnum procedures when the generic procedure on two exact integers would produce a number in the fixnum range.

4.8: Flonums

The flonums are a subset of the inexact real numbers. It is required that all flonums have the same range and precision. When a variable is bound to, or a procedure returns, a mathematical expression, it is understood that the value is the best flonum approximation to the mathematically correct value.This is unrealistic: for example, only Intel's proprietary library has correctly rounded bessel functions. We should change this to an explicit list of procedures that are rounded correctly.

All flonums are radix-2.

If the mathematically correct result of a flonum operation is not a real number, the result is a NaN that is a flonum.

The examples for flonum procedures are written as if all inexact real numbers are flonums for simplicity. For implementations where this is not the case, replace each inexact real constant with flonum applied to that constant, or with whatever implementation specific syntax needed to create a flonum.

Need to be more specific about the flonum behavior of functions with generic arithmetic equivalents, such as sin.

(fladjacent 0.0 -0.0)⇒ -0.0

(fladjacent -0.0 0.0)⇒ 0.0

(fladjacent #x1.0p+0 2.0)⇒ #x1.0000000000001p+0 ; binary64, uses hex float

(fladjacent fl-greatest +inf.0)⇒ +inf.0

(fl=? (fladjacent +inf.0 0.0) fl-greatest)⇒ #t

(flcopysign 1.0 2.0)⇒ 1.0

(flcopysign 1.0 0.0)⇒ 1.0

(flcopysign 1.0 -0.0)⇒ -1.0

(flcopysign +inf.0 -1.0)⇒ -inf.0

(flinteger-fraction +inf.0)⇒ +inf.0 +0.0

(flinteger-fraction -inf.0)⇒ -inf.0 -0.0

(flinteger-fraction 1.5)⇒ 1.0 0.5

(flexponent 1.0)⇒ 0.0

(flexponent 1e-300)⇒ -997.0

(flexponent 0.0)⇒ -inf.0

(flexponent -0.0)⇒ -inf.0

(flexponent +inf.0)⇒ +inf.0

(flexponent -inf.0)⇒ +inf.0

(flnormalized-fraction-exponent 4.25)⇒ 0.53125 3

(flsign-bit +inf.0)⇒ 0

(flsign-bit -inf.0)⇒ 1

(flsign-bit +0.0)⇒ 0

(flsign-bit -0.0)⇒ 1

4.9: Arithmetic predicates

(finite? 3)⇒ #t

(finite? +inf.0)⇒ #f

(finite? 3.0+inf.0i)⇒ #f

(infinite? 3)⇒ #f

(infinite? +inf.0)⇒ #t

(infinite? +nan.0)⇒ #f

(infinite? 3.0+inf.0i)⇒ #t

(nan? +nan.0)⇒ #t

(nan? 32)⇒ #f

(nan? +nan.0+5.0i)⇒ #t

(nan? 1+2i)⇒ #f

(nan? "+nan.0")⇒ #f

(define (zero? z)
  (= z 0))

(zero? 0)⇒ #t

(zero? 0.0)⇒ #t

(zero? -0.0)⇒ #t

(zero? 0.0+0.0i)⇒ #t

(zero? 0.0-0.0i)⇒ #t

(zero? +nan.0)⇒ #f

(positive? +inf.0)⇒ #t

(negative? -inf.0)⇒ #t

(positive? +nan.0)⇒ #f

(negative? -0.0)⇒ #f

4.10: Exactness procedures

(exact? 3.0)⇒ #f

(exact? #e3.0)⇒ #t

(inexact? 3.)⇒ #t

4.11: Order predicates

• (= z₁ z₂ z₃ …) procedure
• (fl=? fl₁ fl₂ fl₃ …) procedure
• (fx=? fx₁ fx₂ fx₃ …) procedure
• (< x₁ x₂ x₃ …) procedure
• (fl<? fl₁ fl₂ fl₃ …) procedure
• (fx<? fx₁ fx₂ fx₃ …) procedure
• (<= x₁ x₂ x₃ …) procedure
• (fl<=? fl₁ fl₂ fl₃ …) procedure
• (fx<=? fx₁ fx₂ fx₃ …) procedure
• (> x₁ x₂ x₃ …) procedure
• (fl>? fl₁ fl₂ fl₃ …) procedure
• (fx>? fx₁ fx₂ fx₃ …) procedure
• (>= x₁ x₂ x₃ …) procedure
• (fl>=? fl₁ fl₂ fl₃ …) procedure
• (fx>=? fx₁ fx₂ fx₃ …) procedure

(= +inf.0 +inf.0)⇒ #t

(= -inf.0 +inf.0)⇒ #f

(= -inf.0 -inf.0)⇒ #t

(let ((x +nan.0))
  (= x x))⇒ #f

4.12: Generic arithmetic

(max 3 4)⇒ 4

(max 3.9 4)⇒ 4.0

(max 1 +inf.0)⇒ +inf.0

(min 1 -inf.0)⇒ -inf.0

(+ 3 4)⇒ 7

(+ 3)⇒ 3

(+)⇒ 0

(+ +inf.0 +inf.0)⇒ +inf.0

(+ 100 +inf.0)⇒ +inf.0

(+ -inf.0 +inf.0)⇒ +nan.0

(* 4)⇒ 4

(*)⇒ 1

(* 5 +inf.0)⇒ +inf.0

(* -5 +inf.0)⇒ -inf.0

(* +inf.0 +inf.0)⇒ +inf.0

(* +inf.0 -inf.0)⇒ -inf.0

(* +inf.0 0.0)⇒ +nan.0

(* 0.0 -1)⇒ -0.0

(* -0.0 1)⇒ -0.0

(* -0.0 0.0)⇒ -0.0

(* -0.0 -0.0)⇒ 0.0

(- 0.0)⇒ -0.0

(- -0.0)⇒ 0.0

(- 3 4)⇒ -1

(- 3 4 5)⇒ -6

(- 0.0 -0.0)⇒ 0.0

(- -0.0 0.0)⇒ -0.0

(- 0.0 0.0)⇒ 0.0

(- -0.0 -0.0)⇒ 0.0

(- +inf.0)⇒ -inf.0

(- +nan.0)⇒ +nan.0

(/ 3 4 5)⇒ 3/20

(/ 3)⇒ 1/3

(/ 0.0)⇒ +inf.0

(/ 1.0 0)⇒ +inf.0

(/ -1 0.0)⇒ -inf.0

(/ +inf.0)⇒ 0.0

(/ 0 0)⇒ domain error

(/ 3 0)⇒ domain error

(/ 0 3.5)⇒ 0.0

(/ 0 0.0)⇒ +nan.0

(/ 0.0 0)⇒ +nan.0

(/ 0.0 0.0)⇒ +nan.0

(square 42)⇒ 1764

(square 2.0)⇒ 4.0

(abs -7)⇒ 7

(abs -inf.0)⇒ +inf.0

(abs -0.0)⇒ +0.0

(gcd 32 -36)⇒ 4

(gcd)⇒ 0

(lcm 32 -36)⇒ 288

(lcm 32.0 -36)⇒ 288.0

(lcm)⇒ 1

(sqrt 9)⇒ 3

(sqrt -1)⇒ +i

(exact-integer-sqrt 4)⇒ 2 0

(exact-integer-sqrt 5)⇒ 2 1

4.13: Rational procedures

(numerator (/ 6 4))⇒ 3

(denominator (/ 6 4))⇒ 2

(denominator
 (inexact (/ 6 4)))⇒ 2.0

4.14: Division procedures

A pair of operators for computing the integral quotients $q$ and remainders $r$ from the division of a numerator $n$ by a denominator $d$ should satisfy the relations

• $$n=dq+r\text{,}$$
• $$\left|r\right|<\left|d\right|\text{,}$$

• and $q$ is an integer.

Such a pair of operators will be called a division operation pair.

To describe the semantics of a division operator pair, it suffices to define the integer $q$, from which $r$ can be uniquely derived by the relation

provided that this choice of $q$ induced an $r$ satisfying $\left|r\right|<\left|d\right|$. For an extensive discussion of five of the six division operator pairs defined here, see TODO: Boute1992.

For each of the six division operator pairs — floor, ceiling, truncate, round, Euclidean and balanced — there is a family of three procedures: one, named ⟨operator⟩/, to compute the division and to return both quotient and remainder as multiple return values; one, named ⟨operator⟩-quotient, to return only the quotient; and one, named ⟨operator⟩-remainder, to return only the remainder. Each division operator pair except for the balanced/ pair is specified by defining the quotient $q$ in terms of the numerator $n$ and the denominator $d$.

It is a domain error if any of the arguments are not integers (exact or inexact). It is also a domain error to supply zero as a denominator to any of these procedures. If any argument is inexact, the result is inexact, unless the implementation can prove that the inexactness cannot affect the result, as in the case of dividing an exact zero by an inexact number.TODO: examples

4.15: Rounding procedures

(floor -4.3)⇒ -5.0

(floor 3.9)⇒ 3.0

(floor 3.5)⇒ 3.0

(ceiling -4.3)⇒ -4.0

(ceiling 3.1)⇒ 4.0

(ceiling 3.5)⇒ 4.0

(truncate -4.3)⇒ -4.0

(truncate 3.1)⇒ 3.0

(truncate 3.5)⇒ 3.0

(round -4.3)⇒ -4.0

(round 2.5)⇒ 2.0

(round 3.5)⇒ 4.0

(round-away -4.3)⇒ -4.0

(round-away 2.5)⇒ 3.0

(round-away 3.5)⇒ 4.0

4.16: Transcendental procedures

In general, the transcendental functions such as log and arcsine are multiply defined.

The value of $\log z$ for non-real $z$ is defined in terms of $\log$ as

where $\mathrm{angle}z$ is the angle of $z=a{e}^{i\theta }$ specified as

with $n$ chosen such that $-\pi \le \mathrm{angle}z\le \pi$.

With the one-argument version of log defined this way, the values of the two-argument version of $\log$, ${\sin }^{-1}$, ${\cos }^{-1}$, ${\tan }^{-1}$, and the two-argument version of ${\tan }^{-1}$ are according to the following formulæ

TODO: citations

The range of ${\tan }^{-1}(x,y)$ is as in the following table. Note that this table distinguishes the sign of zero. When a result is an unsigned zero, it is either positive zero or exact integer (unsigned) zero.

(exp -inf.0)⇒ 0.0

(exp +inf.0)⇒ +inf.0

(exp +3.141592653589793116i)⇒ -1.0 ; approximately

(expt 5 3)⇒ 125

(expt 5 -3)⇒ 1/125

(expt 5 0)⇒ 1

(expt 0 5)⇒ 0

(expt 0 5+.0000312i)⇒ 0

(expt 0 -5)⇒ unspecified

(expt 0 -5+.0000312i)⇒ unspecified

(expt 0 0)⇒ 1

(expt 0.0 0.0)⇒ 1.0

(log +inf.0)⇒ +inf.0

(log 0.0)⇒ -inf.0

(log 0)⇒ domain error

(log -inf.0)⇒ +inf.0+3.141592653589793i ; approximately

(log -inf.0-0.0i)⇒ +inf.0-3.141592653589793i ; approximately

(atan -inf.0)⇒  -1.5707963267948965 ; approximately

(atan +inf.0)⇒  1.5707963267948965 ; approximately

4.17: Complex number procedures

(conjugate 1+2i)⇒ 1-2i

(conjugate 1+inf.0i)⇒ 1-inf.0i

(conjugate 1+0.0i)⇒ 1-0.0i

(conjugate 1)⇒ 1

(magnitude 3+4i)⇒ 5 ; approximately

(magnitude (make-polar 1.1 2.2))⇒ 1.1 ; approximately

(angle -1.0+0.0i)⇒ 3.141592653589793116

(angle -1.0-0.0i)⇒ -3.141592653589793116

4.18: Bitwise operations

Bitwise operations treat exact integers as infinite two's complement bitstrings. They always return exact integers.

(bitwise-not #b1010)⇒ #b-1011

(bitwise-not -37)⇒ 36

(bitwise-and)⇒ -1

(bitwise-and #b1011 #b11010)⇒ #b1010

(bitwise-ior)⇒ 0

(bitwise-ior 3 10)⇒ 11

(bitwise-xor)⇒ 0

(bitwise-xor 3 10)⇒ 9

(arithmetic-shift 8 2)⇒ 32

(arithmetic-shift 4 0)⇒ 4

(arithmetic-shift 8 -1)⇒ 4

(arithmetic-shift
 -100000000000000000000000000000000
 -100)⇒ -79

(integer-length 0)⇒ 0

(integer-length 1)⇒ 1

(integer-length -1)⇒ 0

(integer-length 7)⇒ 3

(integer-length -7)⇒ 3

(integer-length 8)⇒ 4

(integer-length -8)⇒ 3

(bit-count 0)⇒ 0

(bit-count -1)⇒ 0

(bit-count 7)⇒ 3

;; Two's complement binary: …001101
(bit-count 13)⇒ 3

;; Two's complement binary: …1110011
(bit-count -13)⇒ 2

;; Two's complement binary: …0011110
(bit-count 30)⇒ 4

;; Two's complement binary: …1100010
(bit-count -30)⇒ 4

(bit-count (expt 2 100))⇒ 1

(bit-count (- (expt 2 100)))⇒ 100

(bit-count (- (1+ (expt 2 100))))⇒ 1

4.19: Numerical input and output

(let ((number z) (radix radix))
  (eqv? z
        (string->number (number->string z radix)
                        radix)))

(string->number "100")⇒ 100

(string->number "100" 16)⇒ 256

(string->number "1e2")⇒ 100.0

5.1: Boolean syntax

Case is not significant.

⟨boolean⟩

::= #t

::= #f

::= #true

::= #false