3.2 Numbers
A Scheme number is either exact or inexact:
An exact number is either
an arbitrarily large or small integer, such as 5, 99999999999999999, or 17;
a rational that is exactly the ratio of two arbitrarily small or large integers, such as 1/2, 99999999999999999/2, or 3/4; or
a complex number with exact real and imaginary parts (where the imaginary part is not zero), such as 1+2i or 1/2+3/4i.
An inexact number is either
an IEEE floatingpoint representation of a number, such as 2.0 or 3.14e+87, where the IEEE infinities and notanumber are written +inf.0, inf.0, and +nan.0 (or nan.0); or
a complex number with real and imaginary parts that are IEEE floatingpoint representations, such as 2.0+3.0i or inf.0+nan.0i; as a special case, an inexact complex number can have an exact zero real part with an inexact imaginary part.
Inexact numbers print with a decimal point or exponent specifier, and exact numbers print as integers and fractions. The same conventions apply for reading number constants, but #e or #i can prefix a number to force its parsing as an exact or inexact number. The prefixes #b, #o, and #x specify binary, octal, and hexadecimal interpretation of digits.
Reading Numbers in Reference: PLT Scheme documents the fine points of the syntax of numbers.
Examples: 
> 0.5 
0.5 
> #e0.5 
1/2 
> #x03BB 
955 
Computations that involve an inexact number produce inexact results, so that inexactness acts as a kind of taint on numbers. Beware, however, that Scheme offers no “inexact booleans”, so computations that branch on the comparison of inexact numbers can nevertheless produce exact results. The procedures exact>inexact and inexact>exact convert between the two types of numbers.
Examples: 
> (/ 1 2) 
1/2 
> (/ 1 2.0) 
0.5 
> (if (= 3.0 2.999) 1 2) 
2 
> (inexact>exact 0.1) 
3602879701896397/36028797018963968 
Inexact results are also produced by procedures such as sqrt, log, and sin when an exact result would require representing real numbers that are not rational. Scheme can represent only rational numbers and complex numbers with rational parts.
Examples: 
> (sin 0) ; rational... 
0 
> (sin 1/2) ; not rational... 
0.479425538604203 
In terms of performance, computations with small integers are typically the fastest, where “small” means that the number fits into one bit less than the machine’s wordsized representation for signed numbers. Computation with very large exact integers or with noninteger exact numbers can be much more expensive than computation with inexact numbers.
 
 

The number categories integer, rational, real (always rational), and complex are defined in the usual way, and are recognized by the procedures integer?, rational?, real?, and complex?, in addition to the generic number?. A few mathematical procedures accept only real numbers, but most implement standard extensions to complex numbers.
Examples: 
> (integer? 5) 
#t 
> (complex? 5) 
#t 
> (integer? 5.0) 
#t 
> (integer? 1+2i) 
#f 
> (complex? 1+2i) 
#t 
> (complex? 1.0+2.0i) 
#t 
> (abs 5) 
5 
> (abs 5+2i) 
abs: expects argument of type <real number>; given 5+2i 
> (sin 5+2i) 
3.6076607742131563+1.0288031496599335i 
The = procedure compares numbers for numerical equality. If it is given both inexact and exact numbers to compare, it essentially converts the inexact numbers to exact before comparing. The eqv? (and therefore equal?) procedure, in contrast, compares numbers considering both exactness and numerical equality.
Examples: 
> (= 1 1.0) 
#t 
> (eqv? 1 1.0) 
#f 
Beware of comparisons involving inexact numbers, which by their nature can have surprising behavior. Even apparently simple inexact numbers may not mean what you think they mean; for example, while a base2 IEEE floatingpoint number can represent 1/2 exactly, it can only approximate 1/10:
Examples: 
> (= 1/2 0.5) 
#t 
> (= 1/10 0.1) 
#f 
> (inexact>exact 0.1) 
3602879701896397/36028797018963968 
Numbers in Reference: PLT Scheme provides more on numbers and number procedures.