Next: Scientific, Previous: Complex, Up: Numbers [Contents][Index]

The C arithmetic functions below always takes two arguments, while the
Scheme functions can take an arbitrary number. When you need to
invoke them with just one argument, for example to compute the
equivalent of `(- x)`

, pass `SCM_UNDEFINED`

as the second
one: `scm_difference (x, SCM_UNDEFINED)`

.

- Scheme Procedure:
**+***z1 …* - C Function:
**scm_sum***(z1, z2)* Return the sum of all parameter values. Return 0 if called without any parameters.

- Scheme Procedure:
**-***z1 z2 …* - C Function:
**scm_difference***(z1, z2)* If called with one argument

`z1`, -`z1`is returned. Otherwise the sum of all but the first argument are subtracted from the first argument.

- Scheme Procedure:
******z1 …* - C Function:
**scm_product***(z1, z2)* Return the product of all arguments. If called without arguments, 1 is returned.

- Scheme Procedure:
**/***z1 z2 …* - C Function:
**scm_divide***(z1, z2)* Divide the first argument by the product of the remaining arguments. If called with one argument

`z1`, 1/`z1`is returned.

- Scheme Procedure:
**1+***z* - C Function:
**scm_oneplus***(z)* Return

.`z`+ 1

- Scheme Procedure:
**1-***z* - C function:
**scm_oneminus***(z)* Return

.`z`- 1

- Scheme Procedure:
**abs***x* - C Function:
**scm_abs***(x)* Return the absolute value of

`x`.`x`must be a number with zero imaginary part. To calculate the magnitude of a complex number, use`magnitude`

instead.

- Scheme Procedure:
**max***x1 x2 …* - C Function:
**scm_max***(x1, x2)* Return the maximum of all parameter values.

- Scheme Procedure:
**min***x1 x2 …* - C Function:
**scm_min***(x1, x2)* Return the minimum of all parameter values.

- Scheme Procedure:
**truncate***x* - C Function:
**scm_truncate_number***(x)* Round the inexact number

`x`towards zero.

- Scheme Procedure:
**round***x* - C Function:
**scm_round_number***(x)* Round the inexact number

`x`to the nearest integer. When exactly halfway between two integers, round to the even one.

- Scheme Procedure:
**floor***x* - C Function:
**scm_floor***(x)* Round the number

`x`towards minus infinity.

- Scheme Procedure:
**ceiling***x* - C Function:
**scm_ceiling***(x)* Round the number

`x`towards infinity.

- C Function:
*double***scm_c_truncate***(double x)* - C Function:
*double***scm_c_round***(double x)* Like

`scm_truncate_number`

or`scm_round_number`

, respectively, but these functions take and return`double`

values.

- Scheme Procedure:
**euclidean/**`x``y` - Scheme Procedure:
**euclidean-quotient**`x``y` - Scheme Procedure:
**euclidean-remainder**`x``y` - C Function:
*void***scm_euclidean_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_euclidean_quotient***(SCM*`x`, SCM`y`) - C Function:
*SCM***scm_euclidean_remainder***(SCM*`x`, SCM`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`euclidean-quotient`

returns the integer`q`and`euclidean-remainder`

returns the real number`r`such thatand`x`=`q`*`y`+`r`*0 <=*.`r`< |`y`|`euclidean/`

returns both`q`and`r`, and is more efficient than computing each separately. Note that when,`y`> 0`euclidean-quotient`

returns*floor(*, otherwise it returns`x`/`y`)*ceiling(*.`x`/`y`)Note that these operators are equivalent to the R6RS operators

`div`

,`mod`

, and`div-and-mod`

.(euclidean-quotient 123 10) ⇒ 12 (euclidean-remainder 123 10) ⇒ 3 (euclidean/ 123 10) ⇒ 12 and 3 (euclidean/ 123 -10) ⇒ -12 and 3 (euclidean/ -123 10) ⇒ -13 and 7 (euclidean/ -123 -10) ⇒ 13 and 7 (euclidean/ -123.2 -63.5) ⇒ 2.0 and 3.8 (euclidean/ 16/3 -10/7) ⇒ -3 and 22/21

- Scheme Procedure:
**floor/**`x``y` - Scheme Procedure:
**floor-quotient**`x``y` - Scheme Procedure:
**floor-remainder**`x``y` - C Function:
*void***scm_floor_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_floor_quotient***(*`x`,`y`) - C Function:
*SCM***scm_floor_remainder***(*`x`,`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`floor-quotient`

returns the integer`q`and`floor-remainder`

returns the real number`r`such thatand`q`= floor(`x`/`y`).`x`=`q`*`y`+`r``floor/`

returns both`q`and`r`, and is more efficient than computing each separately. Note that`r`, if non-zero, will have the same sign as`y`.When

`x`and`y`are integers,`floor-remainder`

is equivalent to the R5RS integer-only operator`modulo`

.(floor-quotient 123 10) ⇒ 12 (floor-remainder 123 10) ⇒ 3 (floor/ 123 10) ⇒ 12 and 3 (floor/ 123 -10) ⇒ -13 and -7 (floor/ -123 10) ⇒ -13 and 7 (floor/ -123 -10) ⇒ 12 and -3 (floor/ -123.2 -63.5) ⇒ 1.0 and -59.7 (floor/ 16/3 -10/7) ⇒ -4 and -8/21

- Scheme Procedure:
**ceiling/**`x``y` - Scheme Procedure:
**ceiling-quotient**`x``y` - Scheme Procedure:
**ceiling-remainder**`x``y` - C Function:
*void***scm_ceiling_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_ceiling_quotient***(*`x`,`y`) - C Function:
*SCM***scm_ceiling_remainder***(*`x`,`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`ceiling-quotient`

returns the integer`q`and`ceiling-remainder`

returns the real number`r`such thatand`q`= ceiling(`x`/`y`).`x`=`q`*`y`+`r``ceiling/`

returns both`q`and`r`, and is more efficient than computing each separately. Note that`r`, if non-zero, will have the opposite sign of`y`.(ceiling-quotient 123 10) ⇒ 13 (ceiling-remainder 123 10) ⇒ -7 (ceiling/ 123 10) ⇒ 13 and -7 (ceiling/ 123 -10) ⇒ -12 and 3 (ceiling/ -123 10) ⇒ -12 and -3 (ceiling/ -123 -10) ⇒ 13 and 7 (ceiling/ -123.2 -63.5) ⇒ 2.0 and 3.8 (ceiling/ 16/3 -10/7) ⇒ -3 and 22/21

- Scheme Procedure:
**truncate/**`x``y` - Scheme Procedure:
**truncate-quotient**`x``y` - Scheme Procedure:
**truncate-remainder**`x``y` - C Function:
*void***scm_truncate_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_truncate_quotient***(*`x`,`y`) - C Function:
*SCM***scm_truncate_remainder***(*`x`,`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`truncate-quotient`

returns the integer`q`and`truncate-remainder`

returns the real number`r`such that`q`isrounded toward zero, and`x`/`y`.`x`=`q`*`y`+`r``truncate/`

returns both`q`and`r`, and is more efficient than computing each separately. Note that`r`, if non-zero, will have the same sign as`x`.When

`x`and`y`are integers, these operators are equivalent to the R5RS integer-only operators`quotient`

and`remainder`

.(truncate-quotient 123 10) ⇒ 12 (truncate-remainder 123 10) ⇒ 3 (truncate/ 123 10) ⇒ 12 and 3 (truncate/ 123 -10) ⇒ -12 and 3 (truncate/ -123 10) ⇒ -12 and -3 (truncate/ -123 -10) ⇒ 12 and -3 (truncate/ -123.2 -63.5) ⇒ 1.0 and -59.7 (truncate/ 16/3 -10/7) ⇒ -3 and 22/21

- Scheme Procedure:
**centered/**`x``y` - Scheme Procedure:
**centered-quotient**`x``y` - Scheme Procedure:
**centered-remainder**`x``y` - C Function:
*void***scm_centered_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_centered_quotient***(SCM*`x`, SCM`y`) - C Function:
*SCM***scm_centered_remainder***(SCM*`x`, SCM`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`centered-quotient`

returns the integer`q`and`centered-remainder`

returns the real number`r`such thatand`x`=`q`*`y`+`r`*-|*.`y`/2| <=`r`< |`y`/2|`centered/`

returns both`q`and`r`, and is more efficient than computing each separately.Note that

`centered-quotient`

returnsrounded to the nearest integer. When`x`/`y`lies exactly half-way between two integers, the tie is broken according to the sign of`x`/`y``y`. If, ties are rounded toward positive infinity, otherwise they are rounded toward negative infinity. This is a consequence of the requirement that`y`> 0*-|*.`y`/2| <=`r`< |`y`/2|Note that these operators are equivalent to the R6RS operators

`div0`

,`mod0`

, and`div0-and-mod0`

.(centered-quotient 123 10) ⇒ 12 (centered-remainder 123 10) ⇒ 3 (centered/ 123 10) ⇒ 12 and 3 (centered/ 123 -10) ⇒ -12 and 3 (centered/ -123 10) ⇒ -12 and -3 (centered/ -123 -10) ⇒ 12 and -3 (centered/ 125 10) ⇒ 13 and -5 (centered/ 127 10) ⇒ 13 and -3 (centered/ 135 10) ⇒ 14 and -5 (centered/ -123.2 -63.5) ⇒ 2.0 and 3.8 (centered/ 16/3 -10/7) ⇒ -4 and -8/21

- Scheme Procedure:
**round/**`x``y` - Scheme Procedure:
**round-quotient**`x``y` - Scheme Procedure:
**round-remainder**`x``y` - C Function:
*void***scm_round_divide***(SCM*`x`, SCM`y`, SCM *`q`, SCM *`r`) - C Function:
*SCM***scm_round_quotient***(*`x`,`y`) - C Function:
*SCM***scm_round_remainder***(*`x`,`y`) These procedures accept two real numbers

`x`and`y`, where the divisor`y`must be non-zero.`round-quotient`

returns the integer`q`and`round-remainder`

returns the real number`r`such thatand`x`=`q`*`y`+`r``q`isrounded to the nearest integer, with ties going to the nearest even integer.`x`/`y``round/`

returns both`q`and`r`, and is more efficient than computing each separately.Note that

`round/`

and`centered/`

are almost equivalent, but their behavior differs whenlies exactly half-way between two integers. In this case,`x`/`y``round/`

chooses the nearest even integer, whereas`centered/`

chooses in such a way to satisfy the constraint*-|*, which is stronger than the corresponding constraint for`y`/2| <=`r`< |`y`/2|`round/`

,*-|*. In particular, when`y`/2| <=`r`<= |`y`/2|`x`and`y`are integers, the number of possible remainders returned by`centered/`

is*|*, whereas the number of possible remainders returned by`y`|`round/`

is*|*when`y`|+1`y`is even.(round-quotient 123 10) ⇒ 12 (round-remainder 123 10) ⇒ 3 (round/ 123 10) ⇒ 12 and 3 (round/ 123 -10) ⇒ -12 and 3 (round/ -123 10) ⇒ -12 and -3 (round/ -123 -10) ⇒ 12 and -3 (round/ 125 10) ⇒ 12 and 5 (round/ 127 10) ⇒ 13 and -3 (round/ 135 10) ⇒ 14 and -5 (round/ -123.2 -63.5) ⇒ 2.0 and 3.8 (round/ 16/3 -10/7) ⇒ -4 and -8/21

Next: Scientific, Previous: Complex, Up: Numbers [Contents][Index]