www.delorie.com/gnu/docs/elispmanual21/elisp_63.html  search 
Buy the book!  
[ < ]  [ > ]  [ << ]  [ Up ]  [ >> ]  [Top]  [Contents]  [Index]  [ ? ] 
Emacs Lisp provides the traditional four arithmetic operations: addition, subtraction, multiplication, and division. Remainder and modulus functions supplement the division functions. The functions to add or subtract 1 are provided because they are traditional in Lisp and commonly used.
All of these functions except %
return a floating point value
if any argument is floating.
It is important to note that in Emacs Lisp, arithmetic functions
do not check for overflow. Thus (1+ 134217727)
may evaluate to
134217728, depending on your hardware.
(setq foo 4) => 4 (1+ foo) => 5 
This function is not analogous to the C operator ++
it does not
increment a variable. It just computes a sum. Thus, if we continue,
foo => 4 
If you want to increment the variable, you must use setq
,
like this:
(setq foo (1+ foo)) => 5 
+
returns 0.
(+) => 0 (+ 1) => 1 (+ 1 2 3 4) => 10 

function serves two purposes: negation and subtraction.
When 
has a single argument, the value is the negative of the
argument. When there are multiple arguments, 
subtracts each of
the morenumbersormarkers from numberormarker,
cumulatively. If there are no arguments, the result is 0.
( 10 1 2 3 4) => 0 ( 10) => 10 () => 0 
*
returns 1.
(*) => 1 (* 1) => 1 (* 1 2 3 4) => 24 
If all the arguments are integers, then the result is an integer too.
This means the result has to be rounded. On most machines, the result
is rounded towards zero after each division, but some machines may round
differently with negative arguments. This is because the Lisp function
/
is implemented using the C division operator, which also
permits machinedependent rounding. As a practical matter, all known
machines round in the standard fashion.
If you divide an integer by 0, an aritherror
error is signaled.
(See section 10.5.3 Errors.) Floating point division by zero returns either
infinity or a NaN if your machine supports IEEE floating point;
otherwise, it signals an aritherror
error.
(/ 6 2) => 3 (/ 5 2) => 2 (/ 5.0 2) => 2.5 (/ 5 2.0) => 2.5 (/ 5.0 2.0) => 2.5 (/ 25 3 2) => 4 (/ 17 6) => 2 
The result of (/ 17 6)
could in principle be 3 on some
machines.
For negative arguments, the remainder is in principle machinedependent since the quotient is; but in practice, all known machines behave alike.
An aritherror
results if divisor is 0.
(% 9 4) => 1 (% 9 4) => 1 (% 9 4) => 1 (% 9 4) => 1 
For any two integers dividend and divisor,
(+ (% dividend divisor) (* (/ dividend divisor) divisor)) 
always equals dividend.
Unlike %
, mod
returns a welldefined result for negative
arguments. It also permits floating point arguments; it rounds the
quotient downward (towards minus infinity) to an integer, and uses that
quotient to compute the remainder.
An aritherror
results if divisor is 0.
(mod 9 4) => 1 (mod 9 4) => 3 (mod 9 4) => 3 (mod 9 4) => 1 (mod 5.5 2.5) => .5 
For any two numbers dividend and divisor,
(+ (mod dividend divisor) (* (floor dividend divisor) divisor)) 
always equals dividend, subject to rounding error if either
argument is floating point. For floor
, see 3.5 Numeric Conversions.
[ < ]  [ > ]  [ << ]  [ Up ]  [ >> ]  [Top]  [Contents]  [Index]  [ ? ] 
webmaster donations bookstore  delorie software privacy 
Copyright © 2003 by The Free Software Foundation  Updated Jun 2003 