# (lispkit math util)

Library

`(lispkit math util)`

implements mathematical utility functions.**(sgn**

*x***)**

Implements the sign/signum function. Returns -1 if

*x*is negative, 0 (or a signed zero, when inexact) if*x*is zero, and 1 if*x*is a positive number.`sgn`

fails if *x*is not a real number.**(numbers**

*lo hi***)**

**(numbers**

*lo hi f***)**

**(numbers**

*lo hi guard f***)**

Returns a list of numbers by iterating from integer

*lo*to integer*hi*(both inclusive) and applying function*f*to each integer in the range for which*guard*returns true. The default guard always returns true. The default for*f*is`identity`

.**(sum**

*xs***)**

Returns the sum of all numbers of list

*xs*. This procedure fails if there is an element in*xs*which is not a number.**(product**

*xs***)**

Returns the product of all numbers of list

*xs*. This procedure fails if there is an element in*xs*which is not a number.**(minimum**

*xs***)**

Returns the minimum of all numbers of list

*xs*. This procedure fails if there is an element in*xs*which is not a number.**(maximum**

*xs***)**

Returns the maximum of all numbers of list

*xs*. This procedure fails if there is an element in*xs*which is not a number.**(conjugate**

*x***)**

Conjugates number

*x*. For real numbers*x*,`conjugate`

returns *x*, otherwise*x*is being returned with the opposite sign for the imaginary part.**(degrees->radians**

*x***)**

Converts degrees into radians.

**(radians->degrees**

*x***)**

Converts radians into degrees.

**(prime?**

*n***)**

Returns

`#t`

if integer *n*is a prime number,`#f`

otherwise.**(make-nan**

*neg quiet payload***)**

Returns a NaN whose sign bit is equal to

*neg*(`#t`

for negative, `#f`

for positive), whose quiet bit is equal to *quiet*(`#t`

for quiet, `#f`

for signaling), and whose payload is the positive exact integer *payload*. It is an error if*payload*is larger than a NaN can hold.**(nan-negative?**

*x***)**

Returns

`#t`

if the sign bit of *x*is 1 and`#f`

otherwise.**(nan-quiet?**

*x***)**

Returns

`#t`

if *x*is a quiet NaN.**(nan-payload**

*x***)**

Returns the payload bits of floating-point number

*x*as a positive exact integer.**(nan=?**

*x y***)**

Returns

`#t`

if *x*and*y*have the same sign, quiet bit, and payload; and`#f`

otherwise.Last modified 11mo ago