info bigloo

6.1.6 Numbers

Bigloo has only three kinds of numbers: fixnum, long fixnum and flonum. Operations on complexes and rationals are not implemented but for compatibility purposes, the functions complex? and rational? exist. (In fact, complex? is the same as number? and rational? is the same as real? in Bigloo.) The accepted prefixes are #b, #o, #d, #x, #e, #ex, #l, #lx, #z, and #zx. For each generic arithmetic procedure, Bigloo provides two specialized procedures, one for fixnums and one for flonums. The names of these two specialized procedures is the name of the original one suffixed by fx (fixnum), fl (flonum), elong (exact C long), llong (exact C long long), and bx (big integer). A fixnum has the size of a C long minus 2 bits. A flonum has the size of a C double. An elong has the size of a C long. An llong has the size of a C long long. A big integer has an unbounded size.

procedure: number? obj
procedure: real? obj
procedure: integer? obj
bigloo procedure: complex? x
bigloo procedure: rational? x

bigloo procedure: fixnum? obj
bigloo procedure: flonum? obj: These two procedures are type checkers on types integer and real.

bigloo procedure: elong? obj
bigloo procedure: llong? obj: The elong? procedures is a type checker for "hardware" integers, that is integers that have the very same size has the host platform permits (e.g., 32 bits or 64 bits integers). The llong? procedure is a type checker for "hardware" long long integers. Exact integers literal are introduced with the special #e and #ex prefixes. Exact long integers literal are introduced with the special #l and #lx prefixes.

bigloo procedure: bignum? obj: This type checker tests if its argument is a big integer.

bigloo procedure: make-elong int
bigloo procedure: make-llong int: Create an exact fixnum integer from the fixnum value int.

bigloo procedure: minvalfx
bigloo procedure: maxvalfx
bigloo procedure: minvalelong
bigloo procedure: maxvalelong
bigloo procedure: minvalllong
bigloo procedure: maxvalllong: Returns the minimal value (respectively the maximal value) for fix integers.

procedure: exact? z
procedure: inexact? z

library procedure: zero? z
library procedure: positive? z
library procedure: negative? z
library procedure: odd? n
library procedure: even? n
library procedure: zerofx? z
library procedure: positivefx? z
library procedure: negativefx? z
library procedure: oddfx? n
library procedure: evenfx? n
library procedure: zerofl? z
library procedure: positivefl? z
library procedure: negativefl? z
library procedure: oddfl? n
library procedure: evenfl? n
library procedure: zeroelong? z
library procedure: positiveelong? z
library procedure: negativeelong? z
library procedure: oddelong? n
library procedure: evenelong? n
library procedure: zerollong? z
library procedure: positivellong? z
library procedure: negativellong? z
library procedure: oddllong? n
library procedure: evenllong? n
library procedure: zerobx? z
library procedure: positivebx? z
library procedure: negativebx? z
library procedure: oddbx? n
library procedure: evenbx? n

library procedure: min x1 x2 …
library procedure: max x1 x2 …
bigloo procedure: minfx x1 x2 …
bigloo procedure: maxfx x1 x2 …
bigloo procedure: minfl x1 x2 …
bigloo procedure: maxfl x1 x2 …
bigloo procedure: minbx x1 x2 …
bigloo procedure: maxbx x1 x2 …

procedure: = z1 z2 z3 …
bigloo procedure: =fx i1 i2
bigloo procedure: =fl r1 r2
bigloo procedure: =elong r1 r2
bigloo procedure: =llong r1 r2
bigloo procedure: =bx r1 r2
procedure: < z1 z2 z3 …
bigloo procedure: <fx i1 i2
bigloo procedure: <fl r1 r2
bigloo procedure: <elong r1 r2
bigloo procedure: <lllong r1 r2
bigloo procedure: <bx r1 r2
procedure: > z1 z2 z3 …
bigloo procedure: >fx i1 i2
bigloo procedure: >fl r1 r2
bigloo procedure: >elong r1 r2
bigloo procedure: >lllong r1 r2
bigloo procedure: >bx r1 r2
procedure: <= z1 z2 z3 …
bigloo procedure: <=fx i1 i2
bigloo procedure: <=fl r1 r2
bigloo procedure: <=elong r1 r2
bigloo procedure: <=llong r1 r2
bigloo procedure: <=bx r1 r2
procedure: >= z1 z2 z3 …
bigloo procedure: >=fx i1 i2
bigloo procedure: >=fl r1 r2
bigloo procedure: >=elong r1 r2
bigloo procedure: >=llong r1 r2
bigloo procedure: >=bx r1 r2

procedure: + z …
bigloo procedure: +fx i1 i2
bigloo procedure: +fl r1 r2
bigloo procedure: +elong r1 r2
bigloo procedure: +llong r1 r2
bigloo procedure: +bx r1 r2
procedure: * z …
bigloo procedure: *fx i1 i2
bigloo procedure: *fl r1 r2
bigloo procedure: *elong r1 r2
bigloo procedure: *llong r1 r2
bigloo procedure: *bx r1 r2
procedure: - z
procedure: - z1 z2 …
bigloo procedure: -fx i1 i2
bigloo procedure: -fl r1 r2
bigloo procedure: -elong r1 r2
bigloo procedure: -llong r1 r2
bigloo procedure: -bx r1 r2
bigloo procedure: negfx i
bigloo procedure: negfl r
bigloo procedure: negelong r
bigloo procedure: negllong r
bigloo procedure: negbx r: These two functions implement the unary function -.

procedure: / z1 z2
procedure: / z1 z2 …
bigloo procedure: /fx i1 i2
bigloo procedure: /fl r1 r2
bigloo procedure: /elong r1 r2
bigloo procedure: /llong r1 r2
bigloo procedure: /bx r1 r2

library procedure: abs z
bigloo procedure: absfl z
procedure: quotient z1 z2
procedure: quotientelong z1 z2
procedure: quotientllong z1 z2
procedure: remainder z1 z2
procedure: remainderelong z1 z2
procedure: remainderllong z1 z2
procedure: remainderfl z1 z2
procedure: modulo z1 z2
procedure: gcd z …
procedure: lcm z …
procedure: floor z
procedure: floorfl z
procedure: ceiling z
procedure: ceilingfl z
procedure: truncate z
procedure: truncatefl z
procedure: round z
procedure: roundfl z

bigloo procedure: random z

bigloo procedure: randomfl

bigloo procedure: randombx z

bigloo procedure: seed-random! z

the random function returns a pseudo-random integer between 0 and z.

If no seed value is provided, the random function is automatically seeded with a value of 1.

The function randomfl returns a double in the range [0..1].

procedure: exp z
procedure: expfl z
procedure: log z
procedure: logfl z
procedure: sin z
procedure: sinfl z
procedure: cos z
procedure: cosfl z
procedure: tan z
procedure: tanfl z
procedure: asin z
procedure: asinfl z
procedure: acos z
procedure: acosfl z
procedure: atan z1 z2
procedure: atanfl z1 z2
procedure: sqrt z
procedure: sqrtfl z
procedure: expt z1 x2
procedure: exptfl z1 x2

procedure: exact->inexact z

procedure: inexact->exact z

procedure: number->string z

bigloo procedure: integer->string i [radix 10]

bigloo procedure: integer->string/padding i padding [radix 10]

bigloo procedure: elong->string i [radix 10]

bigloo procedure: llong->string i [radix 10]

bigloo procedure: bignum->string i [radix 10]

bigloo procedure: real->string z

bigloo procedure: unsigned->string i [radix 16]

The function integer->string/padding converts its arguments into a string with a left padding filled of characters 0.

(integer->string/padding 3 5)       ⇒ "00003"

The function unsigned->string only accepts the following radixes: 2, 8, and 16. It converts its argument into an unsigned representation.

(unsigned->string 123 16)           ⇒ "7b"
(unsigned->string -123 16)          ⇒ "ffffff85"

bigloo procedure: bignum->octet-string bignum

Returns a binary big-endian representation of the given bignum bignum.

  (string-hex-extern (bignum->octet-string #zx1234567)) ⇒ "01234567"

bigloo procedure: double->ieee-string z
bigloo procedure: float->ieee-string z: Returns a big-endian representation of the given number.

procedure: string->number string [radix 10]

bigloo procedure: string->real string

bigloo procedure: string->elong string radix

bigloo procedure: string->llong string radix

bigloo procedure: string->bignum string radix

Bigloo implements a restricted version of string->number. If string denotes a floating point number then, the only radix 10 may be send to string->number. That is:

(string->number "1243" 16)          ⇒ 4675
(string->number "1243.0" 16)        -|
# *** ERROR:bigloo:string->number
# Only radix `10' is legal for floating point number -- 16
(string->elong "234456353")         ⇒ #e234456353

In addition, string->number does not support radix encoded inside string. That is:

(string->number "#x1243")          ⇒ #f

bigloo procedure: octet-string->bignum string

Counterpart to bignum->octet-string. Takes the bignum representation in big-endian format string and returns the corresponding bignum.

(octet-string->bignum (bignum->octet-string #z1234)) ⇒ #z1234

bigloo procedure: ieee-string->double string
bigloo procedure: ieee-string->float string: Convert the big-endian representations to their numeric values.

bigloo procedure: fixnum->flonum i

bigloo procedure: flonum->fixnum r

bigloo procedure: elong->fixnum i

bigloo procedure: fixnum->elong r

bigloo procedure: llong->fixnum i

bigloo procedure: fixnum->llong r

bigloo procedure: elong->flonum i

bigloo procedure: flonum->elong r

bigloo procedure: llong->flonum i

bigloo procedure: flonum->llong r

For efficiency, string->real and string->integer do not test whether the string can be read as a number. Therefore the result might be wrong if the string cannot be read as a number.

These last procedures implement the natural translation from and to fixnum, flonum, elong, and llong.

bigloo procedure: double->llong-bits z
bigloo-procedure: float->int-bits z: Returns the double-bits as a llong.

bigloo procedure: llong-bits->double llong
bigloo procedure: int-bits->float int: Converts the given llong bits to a double.

See (R5RS)r5rs.info, for more details.

This document was generated on March 31, 2014 using texi2html 5.0.