Info Catalog elisp: Numeric Conversions elisp: Numbers elisp: Rounding Operations

elisp: Arithmetic Operations

 
 3.6 Arithmetic Operations
 =========================
 
 Emacs Lisp provides the traditional four arithmetic operations
 (addition, subtraction, multiplication, and division), as well as
 remainder and modulus functions, and functions to add or subtract 1.
 Except for ‘%’, each of these functions accepts both integer and
 floating-point arguments, and returns a floating-point number if any
 argument is floating point.
 
    Emacs Lisp arithmetic functions do not check for integer overflow.
 Thus ‘(1+ 536870911)’ may evaluate to −536870912, depending on your
 hardware.
 
  -- Function: 1+ number-or-marker
      This function returns NUMBER-OR-MARKER plus 1.  For example,
 
           (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
 
  -- Function: 1- number-or-marker
      This function returns NUMBER-OR-MARKER minus 1.
 
  -- Function: + &rest numbers-or-markers
      This function adds its arguments together.  When given no
      arguments, ‘+’ returns 0.
 
           (+)
                ⇒ 0
           (+ 1)
                ⇒ 1
           (+ 1 2 3 4)
                ⇒ 10
 
  -- Function: - &optional number-or-marker &rest more-numbers-or-markers
      The ‘-’ 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 MORE-NUMBERS-OR-MARKERS from NUMBER-OR-MARKER, cumulatively.
      If there are no arguments, the result is 0.
 
           (- 10 1 2 3 4)
                ⇒ 0
           (- 10)
                ⇒ -10
           (-)
                ⇒ 0
 
  -- Function: * &rest numbers-or-markers
      This function multiplies its arguments together, and returns the
      product.  When given no arguments, ‘*’ returns 1.
 
           (*)
                ⇒ 1
           (* 1)
                ⇒ 1
           (* 1 2 3 4)
                ⇒ 24
 
  -- Function: / number &rest divisors
      With one or more DIVISORS, this function divides NUMBER by each
      divisor in DIVISORS in turn, and returns the quotient.  With no
      DIVISORS, this function returns 1/NUMBER, i.e., the multiplicative
      inverse of NUMBER.  Each argument may be a number or a marker.
 
      If all the arguments are integers, the result is an integer,
      obtained by rounding the quotient towards zero after each division.
 
           (/ 6 2)
                ⇒ 3
           (/ 5 2)
                ⇒ 2
           (/ 5.0 2)
                ⇒ 2.5
           (/ 5 2.0)
                ⇒ 2.5
           (/ 5.0 2.0)
                ⇒ 2.5
           (/ 4.0)
                ⇒ 0.25
           (/ 4)
                ⇒ 0
           (/ 25 3 2)
                ⇒ 4
           (/ -17 6)
                ⇒ -2
 
      If you divide an integer by the integer 0, Emacs signals an
      ‘arith-error’ error (Errors).  Floating-point division of a
      nonzero number by zero yields either positive or negative infinity
      (Float Basics).
 
  -- Function: % dividend divisor
      This function returns the integer remainder after division of
      DIVIDEND by DIVISOR.  The arguments must be integers or markers.
 
      For any two integers DIVIDEND and DIVISOR,
 
           (+ (% DIVIDEND DIVISOR)
              (* (/ DIVIDEND DIVISOR) DIVISOR))
 
      always equals DIVIDEND if DIVISOR is nonzero.
 
           (% 9 4)
                ⇒ 1
           (% -9 4)
                ⇒ -1
           (% 9 -4)
                ⇒ 1
           (% -9 -4)
                ⇒ -1
 
  -- Function: mod dividend divisor
      This function returns the value of DIVIDEND modulo DIVISOR; in
      other words, the remainder after division of DIVIDEND by DIVISOR,
      but with the same sign as DIVISOR.  The arguments must be numbers
      or markers.
 
      Unlike ‘%’, ‘mod’ permits floating-point arguments; it rounds the
      quotient downward (towards minus infinity) to an integer, and uses
      that quotient to compute the remainder.
 
      If DIVISOR is zero, ‘mod’ signals an ‘arith-error’ error if both
      arguments are integers, and returns a NaN otherwise.
 
           (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 and to an ‘arith-error’ if DIVIDEND is
      an integer and DIVISOR is 0.  For ‘floor’, see Numeric
      Conversions.
 

Info Catalog elisp: Numeric Conversions elisp: Numbers elisp: Rounding Operations