on 19-Sep-2015 (Sat)

The syntax for integers in bases other than 10 uses ‘ # ’ followed by a letter that specifies the radix: ‘ b ’ for binary, ‘ o ’ for octal, ‘ x ’ for hex, or ‘ radix r ’ to specify radix radix . Case is not significant for the letter that specifies the radix. Thus, ‘ #b integer ’ reads integer in binary, and ‘ # radix r integer ’ reads integer in radix radix . Allowed values of radix run from 2 to 36. For example:

#b101100 ⇒ 44
#o54 ⇒ 44
#x2c ⇒ 44
#24r1k ⇒ 44

Variable: most-positive-fixnum

The value of this variable is the largest integer that Emacs Lisp can handle. Typical values are 2**29 - 1 on 32-bit and 2**61 - 1 on 64-bit platforms.

Variable: most-negative-fixnum

The value of this variable is the smallest integer that Emacs Lisp can handle. It is negative. Typical values are -2**29 on 32-bit and -2**61 on 64-bit platforms.

In Emacs Lisp, text characters are represented by integers. Any integer between zero and the value of (max-char), inclusive, is considered to be valid as a character

Function: isnan x

This predicate returns t if its floating-point argument is a NaN, nil otherwise.

Function: copysign x1 x2

This function copies the sign of x2 to the value of x1 , and returns the result. x1 and x2 must be floating point.

Function: logb x

This function returns the binary exponent of x . More precisely, the value is the logarithm base 2 of |x|, rounded down to an integer.

(logb 10) ⇒ 3
(logb 10.0e20) ⇒ 69

Function: floatp object

This predicate tests whether its argument is floating point and returns t if so, nil otherwise.

Function: integerp object

This predicate tests whether its argument is an integer, and returns t if so, nil otherwise.

Function: numberp object

This predicate tests whether its argument is a number (either integer or floating point), and returns t if so, nil otherwise.

Function: natnump object

This predicate (whose name comes from the phrase “natural number”) tests to see whether its argument is a nonnegative integer, and returns t if so, nil otherwise. 0 is considered non-negative.

wholenump is a synonym for natnump.

Function: zerop number

This predicate tests whether its argument is zero, and returns t if so, nil otherwise. The argument must be a number.

(zerop x) is equivalent to (= x 0).

It is sometimes convenient to use eq for comparing an unknown value with an integer, because eq does not report an error if the unknown value is not a number—it accepts arguments of any type. By contrast, = signals an error if the arguments are not numbers or markers. However, it is better programming practice to use = if you can, even for comparing integers

Sometimes it is useful to compare numbers with equal, which treats two numbers as equal if they have the same data type (both integers, or both floating point) and the same value. By contrast, = can treat an integer and a floating-point number as equal.

Function: float number

This returns number converted to floating point. If number is already floating point, float returns it unchanged.

Function: truncate number &optional divisor

This returns number , converted to an integer by rounding towards zero.

(truncate 1.2) ⇒ 1
(truncate 1.7) ⇒ 1
(truncate -1.2) ⇒ -1
(truncate -1.7) ⇒ -1

Function: floor number &optional divisor

This returns number , converted to an integer by rounding downward (towards negative infinity).

If divisor is specified, this uses the kind of division operation that corresponds to mod, rounding downward.

(floor 1.2) ⇒ 1
(floor 1.7) ⇒ 1
(floor -1.2) ⇒ -2
(floor -1.7) ⇒ -2
(floor 5.99 3) ⇒ 1

Function: ceiling number &optional divisor

This returns number , converted to an integer by rounding upward (towards positive infinity).

(ceiling 1.2) ⇒ 2
(ceiling 1.7) ⇒ 2
(ceiling -1.2) ⇒ -1
(ceiling -1.7) ⇒ -1

Function: round number &optional divisor

This returns number , converted to an integer by rounding towards the nearest integer. Rounding a value equidistant between two integers returns the even integer.

(round 1.2) ⇒ 1
(round 1.7) ⇒ 2
(round -1.2) ⇒ -1
(round -1.7) ⇒ -2

Function: 1- number-or-marker

This function returns number-or-marker minus 1.

The functions ffloor, fceiling, fround, and ftruncate take a floating-point argument and return a floating-point result whose value is a nearby integer. ffloor returns the nearest integer below; fceiling, the nearest integer above; ftruncate, the nearest integer in the direction towards zero; fround, the nearest integer.

Function: lsh integer1 count

lsh, which is an abbreviation for logical shift, shifts the bits in integer1 to the left count places, or to the right if count is negative, bringing zeros into the vacated bits. If count is negative, lsh shifts zeros into the leftmost (most-significant) bit, producing a positive result even if integer1 is negative.

Function: ash integer1 count

ash (arithmetic shift) shifts the bits in integer1 to the left count places, or to the right if count is negative.

ash gives the same results as lsh except when integer1 and count are both negative. In that case, ash puts ones in the empty bit positions on the left, while lsh puts zeros in those bit positions.

Function: logand &rest ints-or-markers

This function returns the “logical and” of the arguments: the n th bit is set in the result if, and only if, the n th bit is set in all the arguments.

Function: logior &rest ints-or-markers

This function returns the “inclusive or” of its arguments: the n th bit is set in the result if, and only if, the n th bit is set in at least one of the arguments. If there are no arguments, the result is zero, which is an identity element for this operation. If logior is passed just one argument, it returns that argument.

Function: logxor &rest ints-or-markers

This function returns the “exclusive or” of its arguments: the n th bit is set in the result if, and only if, the n th bit is set in an odd number of the arguments. If there are no arguments, the result is 0, which is an identity element for this operation. If logxor is passed just one argument, it returns that argument.

Function: lognot integer

This function returns the logical complement of its argument: the n th bit is one in the result if, and only if, the n th bit is zero in integer , and vice-versa.

Function: exp arg

This is the exponential function; it returns e to the power arg .

Function: log arg &optional base

This function returns the logarithm of arg , with base base . If you don’t specify base , the natural base e is used. If arg or base is negative, log returns a NaN

Function: expt x y

This function returns x raised to power y . If both arguments are integers and y is positive, the result is an integer; in this case, overflow causes truncation, so watch out. If x is a finite negative number and y is a finite non-integer, expt returns a NaN.

Variable: float-e

The mathematical constant e (2.71828…).

Variable: float-pi

The mathematical constant pi (3.14159…).

Sometimes you want the random number sequence to be repeatable. For example, when debugging a program whose behavior depends on the random number sequence, it is helpful to get the same behavior in each program run. To make the sequence repeat, execute (random ""). This sets the seed to a constant value for your particular Emacs executable (though it may differ for other Emacs builds). You can use other strings to choose various seed values.

Function: random &optional limit

This function returns a pseudo-random integer. Repeated calls return a series of pseudo-random integers.

If limit is a positive integer, the value is chosen to be nonnegative and less than limit . Otherwise, the value might be any integer representable in Lisp, i.e., an integer between most-negative-fixnum and most-positive-fixnum (see Integer Basics).

If limit is t, it means to choose a new seed as if Emacs were restarting.

If limit is a string, it means to choose a new seed based on the string’s contents.

However, note that length should not be used for computing the width of a string on display; use string-width (see Size of Displayed Text) instead.

There are two text representations for non- ASCII characters in Emacs strings (and in buffers): unibyte and multibyte.

Like a buffer, a string can contain text properties for the characters in it, as well as the characters themselves. See Text Properties. All the Lisp primitives that copy text from strings to buffers or other strings also copy the properties of the characters being copied.

Function: stringp object

This function returns t if object is a string, nil otherwise.

Function: string-or-null-p object

This function returns t if object is a string or nil. It returns nil otherwise.

Function: char-or-string-p object

This function returns t if object is a string or a character (i.e., an integer), nil otherwise.

Function: make-string count character

This function returns a string made up of count repetitions of character . If count is negative, an error is signaled.

Function: string &rest characters

This returns a string containing the characters characters .

(string ?a ?b ?c) ⇒ "abc"

Function: substring string start &optional end

This function returns a new string which consists of those characters from string in the range from (and including) the character at the index start up to (but excluding) the character at the index end . The first character is at index zero.

(substring "abcdefg" 0 3) ⇒ "abc"

In the above example, the index for ‘ a ’ is 0, the index for ‘ b ’ is 1, and the index for ‘ c ’ is 2. The index 3—which is the fourth character in the string—marks the character position up to which the substring is copied. Thus, ‘ abc ’ is copied from the string "abcdefg".

A negative number counts from the end of the string, so that -1 signifies the index of the last character of the string. For example:

(substring "abcdefg" -3 -1) ⇒ "ef"

In this example, the index for ‘ e ’ is -3, the index for ‘ f ’ is -2, and the index for ‘ g ’ is -1. Therefore, ‘ e ’ and ‘ f ’ are included, and ‘ g ’ is excluded.

When nil is used for end , it stands for the length of the string. Thus,

(substring "abcdefg" -3 nil) ⇒ "efg"

Omitting the argument end is equivalent to specifying nil. It follows that (substring string 0) returns a copy of all of string .

(substring "abcdefg" 0) ⇒ "abcdefg"

But we recommend copy-sequence for this purpose (see Sequence Functions).

If the characters copied from string have text properties, the properties are copied into the new string also. See Text Properties.

substring also accepts a vector for the first argument. For example:

(substring [a b (c) "d"] 1 3) ⇒ [b (c)]

A wrong-type-argument error is signaled if start is not an integer or if end is neither an integer nor nil. An args-out-of-range error is signaled if start indicates a character following end , or if either integer is out of range for string .

Contrast this function with buffer-substring (see Buffer Contents), which returns a string containing a portion of the text in the current buffer. The beginning of a string is at index 0, but the beginning of a buffer is at index 1.

Function: substring-no-properties string &optional start end

This works like substring but discards all text properties from the value. Also, start may be omitted or nil, which is equivalent to 0. Thus, (substring-no-properties string ) returns a copy of string , with all text properties removed.

Function: concat &rest sequences

This function returns a new string consisting of the characters in the arguments passed to it (along with their text properties, if any). The arguments may be strings, lists of numbers, or vectors of numbers; they are not themselves changed. If concat receives no arguments, it returns an empty string.

(concat "abc" "-def") ⇒ "abc-def"
(concat "abc" (list 120 121) [122]) ⇒ "abcxyz"
;; nil is an empty sequence. (concat "abc" nil "-def") ⇒ "abc-def"
(concat "The " "quick brown " "fox.") ⇒ "The quick brown fox."
(concat) ⇒ ""

This function always constructs a new string that is not eq to any existing string, except when the result is the empty string (to save space, Emacs makes only one empty multibyte string).

Function: split-string string &optional separators omit-nulls trim

This function splits string into substrings based on the regular expression separators (see Regular Expressions). Each match for separators defines a splitting point; the substrings between splitting points are made into a list, which is returned.

If omit-nulls is nil (or omitted), the result contains null strings whenever there are two consecutive matches for separators , or a match is adjacent to the beginning or end of string . If omit-nulls is t, these null strings are omitted from the result.

If separators is nil (or omitted), the default is the value of split-string-default-separators.

As a special case, when separators is nil (or omitted), null strings are always omitted from the result. Thus:

(split-string " two words ") ⇒ ("two" "words")

The result is not ("" "two" "words" ""), which would rarely be useful. If you need such a result, use an explicit value for separators :

(split-string " two words " split-string-default-separators) ⇒ ("" "two" "words" "")

More examples:

(split-string "Soup is good food" "o") ⇒ ("S" "up is g" "" "d f" "" "d")
(split-string "Soup is good food" "o" t) ⇒ ("S" "up is g" "d f" "d")
(split-string "Soup is good food" "o+") ⇒ ("S" "up is g" "d f" "d")

Empty matches do count, except that split-string will not look for a final empty match when it already reached the end of the string using a non-empty match or when string is empty:

(split-string "aooob" "o*") ⇒ ("" "a" "" "b" "")
(split-string "ooaboo" "o*") ⇒ ("" "" "a" "b" "")
(split-string "" "") ⇒ ("")

However, when separators can match the empty string, omit-nulls is usually t, so that the subtleties in the three previous examples are rarely relevant:

(split-string "Soup is good food" "o*" t) ⇒ ("S" "u" "p" " " "i" "s" " " "g" "d" " " "f" "d")
(split-string "Nice doggy!" "" t) ⇒ ("N" "i" "c" "e" " " "d" "o" "g" "g" "y" "!")
(split-string "" "" t) ⇒ nil

Somewhat odd, but predictable, behavior can occur for certain “non-greedy” values of separators that can prefer empty matches over non-empty matches. Again, such values rarely occur in practice:

(split-string "ooo" "o*" t) ⇒ nil
(split-string "ooo" "\\|o+" t) ⇒ ("o" "o" "o")

If the optional argument trim is non-nil, it should be a regular expression to match text to trim from the beginning and end of each substring. If trimming makes the substring empty, it is treated as null.

Variable: split-string-default-separators

The default value of separators for split-string. Its usual value is "[ \f\t\n\r\v]+".