21 Bignums, Rationals, and Complex Numbers (BC)

► |  | Inside: Racket C API

I | Inside Racket CS
II | Inside Racket BC (3m and CGC)
III | Appendices
| Index

▼ | II | Inside Racket BC (3m and CGC)

8 | Overview (BC)
9 | Embedding into a Program (BC)
10 | Writing Racket Extensions (BC)
11 | Values and Types (BC)
12 | Memory Allocation (BC)
13 | Namespaces and Modules (BC)
14 | Procedures (BC)
15 | Evaluation (BC)
16 | Exceptions and Escape Continuations (BC)
17 | Threads (BC)
18 | Parameterizations (BC)
19 | Continuation Marks (BC)
20 | String Encodings (BC)
21 | Bignums, Rationals, and Complex Numbers (BC)
22 | Ports and the Filesystem (BC)
23 | Structures (BC)
24 | Security Guards (BC)
25 | Custodians (BC)
26 | Subprocesses (BC)
27 | Miscellaneous Utilities (BC)

Racket
top contents ← prev up next →

## 21 Bignums, Rationals, and Complex Numbers (BC)🔗ℹ

Racket supports integers of an arbitrary magnitude; when an integer cannot be represented as a fixnum (i.e., 30 or 62 bits plus a sign bit), then it is represented by the Racket type scheme_bignum_type. There is no overlap in integer values represented by fixnums and bignums.

Rationals are implemented by the type scheme_rational_type, composed of a numerator and a denominator. The numerator and denominator will be fixnums or bignums (possibly mixed).

Complex numbers are implemented by the type scheme_complex_type, composed of a real and imaginary part. The real and imaginary parts will either be both flonums, both exact numbers (fixnums, bignums, and rationals can be mixed in any way), or the real part will be exact 0 and the imaginary part will be a single-precision (when enabled) or double-pecision flonum.

int |  | scheme_is_exact | ( | Scheme_Object* n)

Returns 1 if n is an exact number, 0 otherwise (n need not be a number).

int |  | scheme_is_inexact | ( | Scheme_Object* n)

Returns 1 if n is an inexact number, 0 otherwise (n need not be a number).

Scheme_Object* |  | scheme_make_bignum | ( | intptr_t v)

Creates a bignum representing the integer v. This can create a bignum that otherwise fits into a fixnum. This must only be used to create temporary values for use with the bignum functions. Final results can be normalized with scheme_bignum_normalize. Only normalized numbers can be used with procedures that are not specific to bignums.

Scheme_Object* |  | scheme_make_bignum_from_unsigned | ( | uintptr_t v)

Like scheme_make_bignum, but works on unsigned integers.

double |  | scheme_bignum_to_double | ( | Scheme_Object* n)

Converts a bignum to a floating-point number, with reasonable but unspecified accuracy.

float |  | scheme_bignum_to_float | ( | Scheme_Object* n)

If Racket is not compiled with single-precision floats, this procedure is actually a macro alias for scheme_bignum_to_double.

Scheme_Object* |  | scheme_bignum_from_double | ( | double d)

Creates a bignum that is close in magnitude to the floating-point number d. The conversion accuracy is reasonable but unspecified.

Scheme_Object* |  | scheme_bignum_from_float | ( | float f)

If Racket is not compiled with single-precision floats, this procedure is actually a macro alias for scheme_bignum_from_double.

char* |  | scheme_bignum_to_string | ( | Scheme_Object* n,
|  |  |  | int radix)

Writes a bignum into a newly allocated byte string.

Scheme_Object* |  | scheme_read_bignum | ( | mzchar* str,
|  |  |  | int offset,
|  |  |  | int radix)

Reads a bignum from a mzchar string, starting from position offset in str. If the string does not represent an integer, then NULL will be returned. If the string represents a number that fits in a fixnum, then a scheme_integer_type object will be returned.

Scheme_Object* |  | scheme_read_bignum_bytes | ( | char* str,
|  |  |  | int offset,
|  |  |  | int radix)

Like scheme_read_bignum, but from a UTF-8-encoding byte string.

Scheme_Object* |  | scheme_bignum_normalize | ( | Scheme_Object* n)

If n fits in a fixnum, then a scheme_integer_type object will be returned. Otherwise, n is returned.

Scheme_Object* |  | scheme_make_rational | ( | Scheme_Object* n,
|  |  |  | Scheme_Object* d)

Creates a rational from a numerator and denominator. The n and d parameters must be fixnums or bignums (possibly mixed). The resulting will be normalized (thus, a bignum or fixnum might be returned).

double |  | scheme_rational_to_double | ( | Scheme_Object* n)

Converts the rational n to a double.

float |  | scheme_rational_to_float | ( | Scheme_Object* n)

If Racket is not compiled with single-precision floats, this procedure is actually a macro alias for scheme_rational_to_double.

Scheme_Object* |  | scheme_rational_numerator | ( | Scheme_Object* n)

Returns the numerator of the rational n.

Scheme_Object* |  | scheme_rational_denominator | ( | Scheme_Object* n)

Returns the denominator of the rational n.

Scheme_Object* |  | scheme_rational_from_double | ( | double d)

Converts the given double into a maximally-precise rational.

Scheme_Object* |  | scheme_rational_from_float | ( | float d)

If Racket is not compiled with single-precision floats, this procedure is actually a macro alias for scheme_rational_from_double.

Scheme_Object* |  | scheme_make_complex | ( | Scheme_Object* r,
|  |  |  | Scheme_Object* i)

Creates a complex number from real and imaginary parts. The r and i arguments must be fixnums, bignums, flonums, or rationals (possibly mixed). The resulting number will be normalized (thus, a real number might be returned).

Scheme_Object* |  | scheme_complex_real_part | ( | Scheme_Object* n)

Returns the real part of the complex number n.

Scheme_Object* |  | scheme_complex_imaginary_part | ( | Scheme_Object* n)

Returns the imaginary part of the complex number n.
top contents ← prev up next →