Thank you for your comment

Beau­tiful Racket / explainers

Numbers

Numbers in Racket are similar to those you’d find in other languages, with two caveats.

First, all numbers are complex numbers, meaning they have a real part and an imag­i­nary part. A number can be written with one or both parts. You write the imag­i­nary part of a complex number by appending an Xi suffix, where X is any real number. A number written without an imag­i­nary part is treated as if it had been written with +0i.

(complex? 3) ; true
(real-part 3) ; 3
(imag-part 3) ; 0
(imag-part 3+0i) ; 0
(= 3 3+0i) ; true
(real-part 4+9i) ; 4
(imag-part 3-8i) ; -8
(* +i +i) ; -1
1
2
3
4
5
6
7
8
(complex? 3) ; true
(real-part 3) ; 3
(imag-part 3) ; 0
(imag-part 3+0i) ; 0
(= 3 3+0i) ; true
(real-part 4+9i) ; 4
(imag-part 3-8i) ; -8
(* +i +i) ; -1
copy to clipboard

In prac­tice, this just means that you get complex numbers “for free”: they’re already in the default numeric envi­ron­ment. You don’t need to import another library. If you only use real numbers, every­thing will still work the way you expect it to.

Second, Racket distin­guishes exact and inexact numbers. An exact number is a number whose real and complex parts are both inte­gers or rational frac­tions. By default, Racket will use exact numbers when it can. This means that accu­rate arith­metic is possible:

(+ 1/3 1/5) ; in most languages 0.533..., but 8/15 in Racket
1
(+ 1/3 1/5) ; in most languages 0.533..., but 8/15 in Racket
copy to clipboard

An inexact number is anything else, including all floating-point numbers. To force an exact number like 3 to behave as an inexact number, write it as 3.0. Inexact numbers are also returned by trigono­metric & loga­rithmic func­tions. The result of an oper­a­tion between an inexact number and another number will also be inexact:

(exact? 3) ; true
(exact? 3.0) ; false
(exact? 3+4i) ; true
(exact? 3.0+4i) ; false
(exact? (sin 1)) ; false
(exact? (+ (sin 1) 3)) ; false
(exact? (* 3.0 3.0)) ; false
1
2
3
4
5
6
7
(exact? 3) ; true
(exact? 3.0) ; false
(exact? 3+4i) ; true
(exact? 3.0+4i) ; false
(exact? (sin 1)) ; false
(exact? (+ (sin 1) 3)) ; false
(exact? (* 3.0 3.0)) ; false
copy to clipboard

Exact numbers are slower, however, so if you don’t need full preci­sion, you might as well use inexact. You can convert between the two with inexact->exact and exact->inexact. You can also coerce an oper­a­tion to produce an inexact result by inserting an inexact term:

(exact? (+ 1 2)) ; true
(exact? (+ 1 2 0.0)) ; false
(exact? (/ 1 2)) ; true
(exact? (/ 1 2 1.0)) ; false
1
2
3
4
(exact? (+ 1 2)) ; true
(exact? (+ 1 2 0.0)) ; false
(exact? (/ 1 2)) ; true
(exact? (/ 1 2 1.0)) ; false
copy to clipboard

Numeric func­tions

Racket has the usual welter of math oper­a­tions and compar­isons. Unlike other languages, many of these func­tions can take any number of argu­ments (that is, they are vari­adic). So a compar­ison like < can be used with a list of numbers to deter­mine if the whole sequence is strictly increasing.

(* 1 2 3 4) ; 1 * 2 * 3 * 4 = 24
(/ 1 2 3 4) ; 1 / 2 / 3 / 4 = 1/24
(< 1 2 3 4) ; 1 < 2 < 3 < 4 = true
(apply < (range 100)) ; true
1
2
3
4
(* 1 2 3 4) ; 1 * 2 * 3 * 4 = 24
(/ 1 2 3 4) ; 1 / 2 / 3 / 4 = 1/24
(< 1 2 3 4) ; 1 < 2 < 3 < 4 = true
(apply < (range 100)) ; true
copy to clipboard

Hexa­dec­imal, octal, binary

Numbers can be notated in hexa­dec­imal with the #x prefix, in octal with the #o prefix, or binary with the #b prefix:

#x10 ; 16
#o20 ; 16
#b10000 ; 16
1
2
3
#x10 ; 16
#o20 ; 16
#b10000 ; 16
copy to clipboard

Number-to-string conver­sions

See number->string and string->number.

Further

← prev next →