Go to the previous, next section.
procedure: number->string number [radix]
Radix must be an exact integer, either 2, 8, 10, or 16. If
omitted, radix defaults to 10. The procedure
number->string takes a number and a radix and returns as a string
an external representation of the given number in the given radix such
that
(let ((number number)
(radix radix))
(eqv? number
(string->number (number->string number radix)
radix)))
is true. It is an error if no possible result makes this expression true.
If number is inexact, the radix is 10, and the above expression can be satisfied by a result that contains a decimal point, then the result contains a decimal point and is expressed using the minimum number of digits (exclusive of exponent and trailing zeroes) needed to make the above expression true; otherwise the format of the result is unspecified.
The result returned by number->string never contains an explicit
radix prefix.
Note: The error case can occur only when number is not a complex number or is a complex number with an non-rational real or imaginary part.
Rationale: If number is an inexact number represented using flonums, and the radix is 10, then the above expression is normally satisfied by a result containing a decimal point. The unspecified case allows for infinities, NaNs, and non-flonum representations.
variable+: flonum-unparser-cutoff
This variable controls the action of number->string when
number is a flonum (and consequently controls all printing of
flonums); it can have the following values:
normal, which is the initial value of this variable,
causes flonums to be printed with full precision. number->string
uses as many digits as are necessary to display all of the information
in the flonum. This value may also be specified as a list (normal
n) where n is an exact integer; n is ignored.
(relative n), where n is an exact positive
integer, constrains number->string to represent the flonum using
at most n significant digits. number->string rounds the
result so that it is as accurate as possible. For example:
(number->string (* 4 (atan 1 1)))
=> "3.141592653589793"
(fluid-let ((flonum-unparser-cutoff '(relative 5)))
(number->string (* 4 (atan 1 1))))
=> "3.1416"
(fluid-let ((flonum-unparser-cutoff '(relative 5)))
(number->string (* 4000 (atan 1 1))))
=> "3141.6"
(absolute n), where n is an exact integer,
constrains number->string to represent the flonum by rounding it
at the nth digit to the right of the decimal point; if n is
negative, the number is rounded (- n) digits to the left of
the decimal point. For example:
(fluid-let ((flonum-unparser-cutoff '(absolute 5)))
(number->string (* 4 (atan 1 1))))
=> "3.14159"
(fluid-let ((flonum-unparser-cutoff '(absolute 5)))
(number->string (* 4000 (atan 1 1))))
=> "3141.59265"
(fluid-let ((flonum-unparser-cutoff '(absolute -4)))
(number->string (* 4e10 (atan 1 1))))
=> "31415930000."
(fluid-let ((flonum-unparser-cutoff '(absolute -5)))
(number->string (* 4e10 (atan 1 1))))
=> "31415900000."
If flonum-unparser-cutoff is bound to a value different from
those described here, number->string issues a warning and acts as
though it had been bound to normal.
procedure: string->number string [radix]
Returns a number of the maximally precise representation expressed by
the given string. Radix must be an exact integer, either 2,
8, 10, or 16. If supplied, radix is a default radix that may be
overridden by an explicit radix prefix in string (e.g.
"#o177"). If radix is not supplied, then the default radix
is 10. If string is not a syntactically valid notation for a
number, then string->number returns #f.
(string->number "100") => 100 (string->number "100" 16) => 256 (string->number "1e2") => 100.0 (string->number "15##") => 1500.0
Note that a numeric representation using a decimal point or an exponent
marker is not recognized unless radix is 10.
Go to the previous, next section.