Next: Fixnum and Flonum Operations, Previous: Numerical operations, Up: Numbers

— procedure: **number->string**` number `[`radix`]

Radixmust be an exact integer, either 2, 8, 10, or 16. If omitted,radixdefaults 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 ((numbernumber) (radixradix)) (eqv? number (string->number (number->string number radix) radix)))is true. It is an error if no possible result makes this expression true.

If

numberis 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

numberis not a complex number or is a complex number with an non-rational real or imaginary part.Rationale: If

numberis 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-parser-fast?**

This variable controls the behavior of

`string->number`

when parsing inexact numbers. Specifically, it allows the user to trade off accuracy against speed.When set to its default value,

`#f`

, the parser provides maximal accuracy, as required by the Scheme standard. If set to`#t`

, the parser uses faster algorithms that will sometimes introduce small errors in the result. The errors affect a few of the least-significant bits of the result, and consequently can be tolerated by many applications.

— variable: **flonum-unparser-cutoff**

This variable controls the action of

`number->string`

whennumberis a flonum (and consequently controls all printing of flonums). The value of this variable is normally a list of three items:

rounding-type- One of the following symbols:
`normal`

,`relative`

, or`absolute`

. The symbol`normal`

means that the number should be printed with full precision. The symbol`relative`

means that the number should be rounded to a specific number of digits. The symbol`absolute`

means that the number should be rounded so that there are a specific number of digits to the right of the decimal point.precision- An exact integer. If
rounding-typeis`normal`

,precisionis ignored. Ifrounding-typeis`relative`

,precisionmust be positive, and it specifies the number of digits to which the printed representation will be rounded. Ifrounding-typeis`absolute`

, the printed representation will be roundedprecisiondigits to the right of the decimal point; ifprecisionis negative, the representation is rounded`(-`

precision`)`

digits to the left of the decimal point.format-type- One of the symbols:
`normal`

,`scientific`

, or`engineering`

. This specifies the format in which the number will be printed.

`scientific`

specifies that the number will be printed using scientific notation:x`.`

xxx`e`

yyy. In other words, the number is printed as a mantissa between zero inclusive and ten exclusive, and an exponent.`engineering`

is like`scientific`

, except that the exponent is always a power of three, and the mantissa is constrained to be between zero inclusive and 1000 exclusive. If`normal`

is specified, the number will be printed in positional notation if it is “small enough”, otherwise it is printed in scientific notation. A number is “small enough” when the number of digits that would be printed using positional notation does not exceed the number of digits of precision in the underlying floating-point number representation; ieee double-precision floating-point numbers have 17 digits of precision.This three-element list may be abbreviated in two ways. First, the symbol

`normal`

may be used, which is equivalent to the list`(normal 0 normal)`

. Second, the third element of the list,format-type, may be omitted, in which case it defaults to`normal`

.The default value for

`flonum-unparser-cutoff`

is`normal`

. If it is bound to a value different from those described here,`number->string`

issues a warning and acts as though the value had been`normal`

.

Some examples of `flonum-unparser-cutoff`

:

(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" (fluid-let ((flonum-unparser-cutoff '(relative 5 scientific))) (number->string (* 4000 (atan 1 1)))) => "3.1416e3" (fluid-let ((flonum-unparser-cutoff '(relative 5 scientific))) (number->string (* 40000 (atan 1 1)))) => "3.1416e4" (fluid-let ((flonum-unparser-cutoff '(relative 5 engineering))) (number->string (* 40000 (atan 1 1)))) => "31.416e3" (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 -4 scientific))) (number->string (* 4e10 (atan 1 1)))) => "3.141593e10" (fluid-let ((flonum-unparser-cutoff '(absolute -4 engineering))) (number->string (* 4e10 (atan 1 1)))) => "31.41593e9" (fluid-let ((flonum-unparser-cutoff '(absolute -5))) (number->string (* 4e10 (atan 1 1)))) => "31415900000."

— procedure: **string->number**` string `[`radix`]

Returns a number of the maximally precise representation expressed by the given

string.Radixmust be an exact integer, either 2, 8, 10, or 16. If supplied,radixis a default radix that may be overridden by an explicit radix prefix instring(e.g.`"#o177"`

). Ifradixis not supplied, then the default radix is 10. Ifstringis 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.0Note that a numeric representation using a decimal point or an exponent marker is not recognized unless

radixis`10`

.