This section defines a few simple Common Lisp operations on numbers which were left out of Emacs Lisp.
These functions return
t if the specified condition is
true of the numerical argument, or
floatp. On other systems, this always returns
These functions perform various arithmetic operations on numbers.
absonly for Emacs 18 versions which don't provide it as a primitive.)
exptonly for Emacs 18 versions which don't provide it as a primitive.)
floorfunction. It is called
floor*to avoid name conflicts with the simpler
floorfunction built-in to Emacs 19.
With one argument,
floor* returns a list of two numbers:
The argument rounded down (toward minus infinity) to an integer,
and the "remainder" which would have to be added back to the
first return value to yield the argument again. If the argument
is an integer x, the result is always the list
If the argument is an Emacs 19 floating-point number, the first
result is a Lisp integer and the second is a Lisp float between
0 (inclusive) and 1 (exclusive).
With two arguments,
floor* divides number by
divisor, and returns the floor of the quotient and the
corresponding remainder as a list of two numbers. If
(floor* x y) returns
q*y + r = x, with r
between 0 (inclusive) and r (exclusive). Also, note
(floor* x) is exactly equivalent to
(floor* x 1).
This function is entirely compatible with Common Lisp's
function, except that it returns the two results in a list since
Emacs Lisp does not support multiple-valued functions.
ceilingfunction, which is analogous to
floorexcept that it rounds the argument or quotient of the arguments up toward plus infinity. The remainder will be between 0 and minus r.
truncatefunction, which is analogous to
floorexcept that it rounds the argument or quotient of the arguments toward zero. Thus it is equivalent to
floor*if the argument or quotient is positive, or to
ceiling*otherwise. The remainder has the same sign as number.
roundfunction, which is analogous to
floorexcept that it rounds the argument or quotient of the arguments to the nearest integer. In the case of a tie (the argument or quotient is exactly halfway between two integers), it rounds to the even integer.
These definitions are compatible with those in the Quiroz `cl.el' package, except that this package appends `*' to certain function names to avoid conflicts with existing Emacs 19 functions, and that the mechanism for returning multiple values is different.
This package also provides an implementation of the Common Lisp random number generator. It uses its own additive-congruential algorithm, which is much more likely to give statistically clean random numbers than the simple generators supplied by many operating systems.
random-stateobject which holds the state of the random number generator. The function modifies this state object as a side effect. If state is omitted, it defaults to the variable
*random-state*, which contains a pre-initialized
random-stateobject, used for calls to
random*that do not specify an alternative state object. Since any number of programs in the Emacs process may be accessing
*random-state*in interleaved fashion, the sequence generated from this variable will be irreproducible for all intents and purposes.
random-stateobject. If state is omitted or
nil, it returns a new copy of
*random-state*. This is a copy in the sense that future sequences of calls to
(random* n s)(where s is the new random-state object) will return identical sequences of random numbers.
If state is a
random-state object, this function
returns a copy of that object. If state is
function returns a new
random-state object seeded from the
date and time. As an extension to Common Lisp, state may also
be an integer in which case the new object is seeded from that
integer; each different integer seed will result in a completely
different sequence of random numbers.
It is legal to print a
random-state object to a buffer or
file and later read it back with
read. If a program wishes
to use a sequence of pseudo-random numbers which can be reproduced
later for debugging, it can call
(make-random-state t) to
get a new sequence, then print this sequence to a file. When the
program is later rerun, it can read the original run's random-state
from the file.
tif object is a
This package defines several useful constants having to with numbers.
The following parameters have to do with floating-point numbers. This package determines their values by exercising the computer's floating-point arithmetic in various ways. Because this operation might be slow, the code for initializing them is kept in a separate function that must be called before the parameters can be used.
most-positive-floathave been initialized. Until it is called, these parameters will be
nil. If this version of Emacs does not support floats (e.g., most versions of Emacs 18), the parameters will remain
nil. If the parameters have already been initialized, the function returns immediately.
The algorithm makes assumptions that will be valid for most modern machines, but will fail if the machine's arithmetic is extremely unusual, e.g., decimal.
Since true Common Lisp supports up to four different floating-point
precisions, it has families of constants like
most-positive-long-float, and so on. Emacs has only one
floating-point precision, so this package omits the precision word
from the constants' names.
4.94e-324if denormals are supported or
2.22e-308. For machines that do not support the concept of denormalization and gradual underflow, this constant will always equal
Go to the first, previous, next, last section, table of contents.