# on 19-Sep-2015 (Sat)

#### Annotation 150915214

 #elisp 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

GNU Emacs Lisp Reference Manual: Integer Basics

#### Annotation 150915220

 #elisp Variable: most-positive-fixnumThe 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.

GNU Emacs Lisp Reference Manual: Integer Basics
kers.) Since the actual arguments to such functions may be either numbers or markers, we often give these arguments the name number-or-marker . When the argument value is a marker, its position value is used and its buffer is ignored. <span>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

#### Annotation 150915226

 #elisp Variable: most-negative-fixnumThe 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.

GNU Emacs Lisp Reference Manual: Integer Basics
ition value is used and its buffer is ignored. 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. <span>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. See Character C

#### Annotation 150915232

 #elisp 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

GNU Emacs Lisp Reference Manual: Integer Basics
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. <span>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. See Character Codes. Next: Float Basics, Up: Numbers [Contents][Index] <span><body><html>

#### Annotation 150915246

 #elisp Function: isnan xThis predicate returns t if its floating-point argument is a NaN, nil otherwise.

GNU Emacs Lisp Reference Manual: Float Basics
sp. Here are read syntaxes for these special floating-point values: infinity ‘ 1.0e+INF ’ and ‘ -1.0e+INF ’ not-a-number ‘ 0.0e+NaN ’ and ‘ -0.0e+NaN ’ The following functions are specialized for handling floating-point numbers: <span>Function: isnan x This predicate returns t if its floating-point argument is a NaN, nil otherwise. Function: frexp x This function returns a cons cell ( s . e ) , where s and e are respectively the significand and exponent of the floating-point number x . If x is finite

#### Annotation 150915252

 #elisp Function: copysign x1 x2This function copies the sign of x2 to the value of x1 , and returns the result. x1 and x2 must be floating point.

GNU Emacs Lisp Reference Manual: Float Basics
the same as x . If x is a NaN, then s is also a NaN. If x is zero, then e is 0. Function: ldexp sig &optional exp This function returns a floating-point number corresponding to the significand sig and exponent exp . <span>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

#### Annotation 150915258

 #elisp Function: logb xThis 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

GNU Emacs Lisp Reference Manual: Float Basics
s a floating-point number corresponding to the significand sig and exponent exp . 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. <span>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 Next: Predicates on Numbers, Previous: Integer Basics, Up: Numbers [Contents][Index] <span><body><html>

#### Annotation 150915280

 #elisp Function: floatp objectThis predicate tests whether its argument is floating point and returns t if so, nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates on Numbers
loatp can take any type of Lisp object as argument (they would not be of much use otherwise), but the zerop predicate requires a number as its argument. See also integer-or-marker-p and number-or-marker-p , in Predicates on Markers. <span>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 i

#### Annotation 150915286

 #elisp Function: integerp objectThis predicate tests whether its argument is an integer, and returns t if so, nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates on Numbers
a number as its argument. See also integer-or-marker-p and number-or-marker-p , in Predicates on Markers. Function: floatp object This predicate tests whether its argument is floating point and returns t if so, nil otherwise. <span>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 objec

#### Annotation 150915292

 #elisp Function: numberp objectThis predicate tests whether its argument is a number (either integer or floating point), and returns t if so, nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates on Numbers
p 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. <span>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 o

#### Annotation 150915298

 #elisp 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.

GNU Emacs Lisp Reference Manual: Predicates on Numbers
s 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. <span>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

#### Annotation 150915304

 #elisp Function: zerop numberThis 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).

GNU Emacs Lisp Reference Manual: Predicates on Numbers
is 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 . <span>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) . <span><body><html>

#### Annotation 150915318

 #elisp 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

GNU Emacs Lisp Reference Manual: Comparison of Numbers
en you test whether two values are the same object. By contrast, = compares only the numeric values of the objects. In Emacs Lisp, each integer is a unique Lisp object. Therefore, eq is equivalent to = where integers are concerned. <span>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.

#### Annotation 150915324

 #elisp 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.

GNU Emacs Lisp Reference Manual: Comparison of Numbers
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. <span>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. See Equality Predicates. There is another wrinkle: because floating-point arithmetic is not exact, it is often a bad idea to check for equality of floating-point values. Usually it i

#### Annotation 150915338

 #elisp Function: float numberThis returns number converted to floating point. If number is already floating point, float returns it unchanged.

GNU Emacs Lisp Reference Manual: Numeric Conversions
eference Manual: Numeric Conversions Next: Arithmetic Operations, Previous: Comparison of Numbers, Up: Numbers [Contents][Index] 3.5 Numeric Conversions To convert an integer to floating point, use the function float . <span>Function: float number This returns number converted to floating point. If number is already floating point, float returns it unchanged. There are four functions to convert floating-point numbers to integers; they differ in how they round. All accept an argument number and an optional argument divisor . Both argument

#### Annotation 150915344

 #elisp Function: truncate number &optional divisorThis 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

GNU Emacs Lisp Reference Manual: Numeric Conversions
it unchanged if it already is an integer. If divisor is non- nil , they divide number by divisor and convert the result to an integer. If divisor is zero (whether integer or floating point), Emacs signals an arith-error error. <span>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 th

#### Annotation 150915350

 #elisp Function: floor number &optional divisorThis 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

GNU Emacs Lisp Reference Manual: Numeric Conversions
rror. 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 <span>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)

#### Annotation 150915356

 #elisp Function: ceiling number &optional divisorThis 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

GNU Emacs Lisp Reference Manual: Numeric Conversions
). 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 <span>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

#### Annotation 150915362

 #elisp Function: round number &optional divisorThis 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

GNU Emacs Lisp Reference Manual: Numeric Conversions
: 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 <span>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 Next: Arithmetic Operations, Previous: Comparison of Numbers, Up: Numbers [Contents][Index] <span><body><html>

#### Annotation 150915376

 #elisp Function: 1- number-or-markerThis function returns number-or-marker minus 1.

GNU Emacs Lisp Reference Manual: Arithmetic Operations
gous 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 <span>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

#### Annotation 150915390

 #elisp 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.

GNU Emacs Lisp Reference Manual: Rounding Operations
GNU Emacs Lisp Reference Manual: Rounding Operations Next: Bitwise Operations, Previous: Arithmetic Operations, Up: Numbers [Contents][Index] 3.7 Rounding Operations 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: ffloor float This function rounds float to the next lower integral value, and returns that value as a floating-point number. Function: fceiling float This function ro

#### Annotation 150915404

 #elisp 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
on acts on the individual bits of such a sequence. For example, shifting moves the whole sequence left or right one or more places, reproducing the same pattern “moved over”. The bitwise operations in Emacs Lisp apply only to integers. <span>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. Contrast this with ash , below. Here are two examples of lsh , shifting a pattern of bits one place to the left. We show only the low-order eight bits of the binary pattern; the re

#### Annotation 150915410

 #elisp 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
) ; left shift ⇒ -2 In binary, the argument looks like this: ;; Decimal 536,870,911 0111...111111 (30 bits total) which becomes the following when left shifted: ;; Decimal -2 1111...111110 (30 bits total) <span>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. Thus, with ash , shifting the pattern of bits one place to the right looks like this: (ash -6 -1) ⇒ -3 ;; Decimal -6 becomes decimal -3. 1111...111010 (30 bits total) ⇒ 1111..

#### Annotation 150915416

 #elisp Function: logand &rest ints-or-markersThis 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
; = 0000...000001 (ash 5 -2) ⇒ 1 (lsh -5 -2) ; -5 = 1111...111011 ⇒ 268435454 ; = 0011...111110 (ash -5 -2) ; -5 = 1111...111011 ⇒ -2 ; = 1111...111110 <span>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. (“Set” means that the value of the bit is 1 rather than 0.) For example, using 4-bit binary numbers, the “logical and” of 13 and 12 is 12: 1101 combined with 1100 produces 1100. In bo

#### Annotation 150915422

 #elisp Function: logior &rest ints-or-markersThis 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
= 0000...001100 (logand 14 13 4) ; 14 = 0000...001110 ; 13 = 0000...001101 ; 4 = 0000...000100 ⇒ 4 ; 4 = 0000...000100 (logand) ⇒ -1 ; -1 = 1111...111111 <span>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. ; 30-bit binary values (logior 12 5) ; 12 = 0000...001100 ; 5 = 0000...000101 ⇒ 13 ; 13 = 0000...001101 (logior 12 5 7) ; 12 = 0

#### Annotation 150915428

 #elisp Function: logxor &rest ints-or-markersThis 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
; 5 = 0000...000101 ⇒ 13 ; 13 = 0000...001101 (logior 12 5 7) ; 12 = 0000...001100 ; 5 = 0000...000101 ; 7 = 0000...000111 ⇒ 15 ; 15 = 0000...001111 <span>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. ; 30-bit binary values (logxor 12 5) ; 12 = 0000...001100 ; 5 = 0000...000101 ⇒ 9 ; 9 = 0000...001001 (logxor 12 5 7) ; 12 = 0

#### Annotation 150915434

 #elisp Function: lognot integerThis 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.

GNU Emacs Lisp Reference Manual: Bitwise Operations
; 5 = 0000...000101 ⇒ 9 ; 9 = 0000...001001 (logxor 12 5 7) ; 12 = 0000...001100 ; 5 = 0000...000101 ; 7 = 0000...000111 ⇒ 14 ; 14 = 0000...001110 <span>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. (lognot 5) ⇒ -6 ;; 5 = 0000...000101 (30 bits total) ;; becomes ;; -6 = 1111...111010 (30 bits total) Next: Math Functions, Previous: Rounding Operations, Up: Numbers

#### Annotation 150915448

 #elisp Function: exp argThis is the exponential function; it returns e to the power arg .

GNU Emacs Lisp Reference Manual: Math Functions
value of (atan y ) is a number between -pi/2 and pi/2 (exclusive) whose tangent is y . If the optional second argument x is given, the value of (atan y x) is the angle in radians between the vector [ x , y ] and the X axis. <span>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 ne

#### Annotation 150915454

 #elisp Function: log arg &optional baseThis 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

GNU Emacs Lisp Reference Manual: Math Functions
If the optional second argument x is given, the value of (atan y x) is the angle in radians between the vector [ x , y ] and the X axis. Function: exp arg This is the exponential function; it returns e to the power arg . <span>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 tru

#### Annotation 150915460

 #elisp Function: expt x yThis 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.

GNU Emacs Lisp Reference Manual: Math Functions
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. <span>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. Function: sqrt arg This returns the square root of arg . If arg is finite and less than zero, sqrt returns a NaN. In addition, Emacs defines the following common mathematical

#### Annotation 150915466

 #elisp Variable: float-eThe mathematical constant e (2.71828…).

GNU Emacs Lisp Reference Manual: Math Functions
te non-integer, expt returns a NaN. Function: sqrt arg This returns the square root of arg . If arg is finite and less than zero, sqrt returns a NaN. In addition, Emacs defines the following common mathematical constants: <span>Variable: float-e The mathematical constant e (2.71828…). Variable: float-pi The mathematical constant pi (3.14159…). Next: Random Numbers, Previous: Bitwise Operations, Up: Numbers [Contents][Index] <span><body></html

#### Annotation 150915472

 #elisp Variable: float-piThe mathematical constant pi (3.14159…).

GNU Emacs Lisp Reference Manual: Math Functions
This returns the square root of arg . If arg is finite and less than zero, sqrt returns a NaN. In addition, Emacs defines the following common mathematical constants: Variable: float-e The mathematical constant e (2.71828…). <span>Variable: float-pi The mathematical constant pi (3.14159…). Next: Random Numbers, Previous: Bitwise Operations, Up: Numbers [Contents][Index] <span><body><html>

#### Annotation 150915486

 #elisp 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.

GNU Emacs Lisp Reference Manual: Random Numbers
the random function always generates the same sequence of numbers. By default, Emacs initializes the random seed at startup, in such a way that the sequence of values of random (with overwhelming likelihood) differs in each Emacs run. <span>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

#### Annotation 150915492

 #elisp Function: random &optional limitThis 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.

GNU Emacs Lisp Reference Manual: Random Numbers
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. <span>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. Previous: Math Functions, Up: Numbers [Contents][Index] <span><body><html>

#### Annotation 150915512

 #elisp 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.

GNU Emacs Lisp Reference Manual: String Basics
u can operate on them with the general array and sequence functions documented in Sequences Arrays Vectors. For example, you can access or change individual characters in a string using the functions aref and aset (see Array Functions). <span>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. For most Lisp programming, you don’t need to be concerned with the

#### Annotation 150915518

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

GNU Emacs Lisp Reference Manual: String Basics
al characters in a string using the functions aref and aset (see Array Functions). 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. <span>There are two text representations for non- ASCII characters in Emacs strings (and in buffers): unibyte and multibyte. For most Lisp programming, you don’t need to be concerned with these two representations. See Text Representations, for details. Sometimes key sequences are represented as unibyte st

#### Annotation 150915524

 #elisp 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.

GNU Emacs Lisp Reference Manual: String Basics
ings with string-match (see Regexp Search). The functions match-string (see Simple Match Data) and replace-match (see Replacing Match) are useful for decomposing and modifying strings after matching regular expressions against them. <span>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. See Text, for information about functions that display strings or copy them into buffers. See Character Type, and String Type, for information about the syntax of characters and strings

#### Annotation 150915538

 #elisp Function: stringp objectThis function returns t if object is a string, nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates for Strings
xt: Creating Strings, Previous: String Basics, Up: Strings and Characters [Contents][Index] 4.2 Predicates for Strings For more information about general sequence and array predicates, see Sequences Arrays Vectors, and Arrays. <span>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

#### Annotation 150915544

 #elisp Function: string-or-null-p objectThis function returns t if object is a string or nil. It returns nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates for Strings
4.2 Predicates for Strings For more information about general sequence and array predicates, see Sequences Arrays Vectors, and Arrays. Function: stringp object This function returns t if object is a string, nil otherwise. <span>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. <span><body><html>

#### Annotation 150915550

 #elisp Function: char-or-string-p objectThis function returns t if object is a string or a character (i.e., an integer), nil otherwise.

GNU Emacs Lisp Reference Manual: Predicates for Strings
and Arrays. 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. <span>Function: char-or-string-p object This function returns t if object is a string or a character (i.e., an integer), nil otherwise. <span><body><html>

#### Annotation 150915564

 #elisp Function: make-string count characterThis function returns a string made up of count repetitions of character . If count is negative, an error is signaled.

GNU Emacs Lisp Reference Manual: Creating Strings
Strings, Previous: Predicates for Strings, Up: Strings and Characters [Contents][Index] 4.3 Creating Strings The following functions create strings, either from scratch, or by putting strings together, or by taking them apart. <span>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. (make-string 5 ?x) ⇒ "xxxxx" (make-string 0 ?x) ⇒ "" Other functions to compare with this one include make-vector (see Vectors) and make-list (see B

#### Annotation 150915570

 #elisp Function: string &rest charactersThis returns a string containing the characters characters . (string ?a ?b ?c) ⇒ "abc"

GNU Emacs Lisp Reference Manual: Creating Strings
negative, an error is signaled. (make-string 5 ?x) ⇒ "xxxxx" (make-string 0 ?x) ⇒ "" Other functions to compare with this one include make-vector (see Vectors) and make-list (see Building Lists). <span>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 a

#### Annotation 150915576

 #elisp Function: substring string start &optional endThis 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.

GNU Emacs Lisp Reference Manual: Creating Strings
h this one include make-vector (see Vectors) and make-list (see Building Lists). Function: string &rest characters This returns a string containing the characters characters . (string ?a ?b ?c) ⇒ "abc" <span>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 , wh

#### Annotation 150915582

 #elisp Function: substring-no-properties string &optional start endThis 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.

GNU Emacs Lisp Reference Manual: Creating Strings
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. <span>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 a

#### Annotation 150915588

 #elisp 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).

GNU Emacs Lisp Reference Manual: Creating Strings
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. <span>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). For information about other concatenation functions, see the description of mapconcat in Mapping Functions, vconcat in Vector Functions, and append in Building Lists. For concaten

#### Annotation 150915594

 #elisp Function: split-string string &optional separators omit-nulls trimThis 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.

GNU Emacs Lisp Reference Manual: Creating Strings
scription of mapconcat in Mapping Functions, vconcat in Vector Functions, and append in Building Lists. For concatenating individual command-line arguments into a string to be used as a shell command, see combine-and-quote-strings. <span>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. If you need to split a string into a list of individual command-line arguments suitable for call-process or start-process , see split-string-and-unquote. Variable: split-string-d

#### Annotation 150915600

 #elisp Variable: split-string-default-separatorsThe default value of separators for split-string. Its usual value is "[ \f\t\n\r\v]+".

GNU Emacs Lisp Reference Manual: Creating Strings
each substring. If trimming makes the substring empty, it is treated as null. If you need to split a string into a list of individual command-line arguments suitable for call-process or start-process , see split-string-and-unquote. <span>Variable: split-string-default-separators The default value of separators for split-string . Its usual value is "[ \f\t\n\r\v]+" . Next: Modifying Strings, Previous: Predicates for Strings, Up: Strings and Characters [Contents][Index] <span><body><html>

#### Flashcard 150915627

Tags
#learning #memo
Question
Always avoid [...] when learning.
sets

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915634

Tags
#learning #memo
Question
You should always try to make sure your brain works in exactly the same way at each repetition. In the case of sets, listing members in varying order at each repetition has a disastrous effect on memory.

True or False?
True

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915642

Tags
#learning #memo
Question
Simple is easy.

Give an imagery on how this works.
Imagine a labyrinth. When making a repetition of a piece of material, your brain is running through a labyrinth. While running through the labyrinth, the brain leaves a track on the walls. If it can run in only one unique way, the path is continuous and easy to follow. If there are many combinations, each run may leave a different trace that will interfere with other traces making it difficult to find the exit.

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915649

Tags
#learning #memo
Question
2 rules to follow in minimum information principle.
1. Simple is easy.

2. Split a complex item into sub-items. (i.e. To memorize an answer with many details, give each detail a question.)

Example:
Ill-formulated knowledge - Complex and wordy

Q: What are the characteristics of the Dead Sea?
A: Salt lake located on the border between Israel and Jordan. Its shoreline is the lowest point on the Earth's surface, averaging 396 m below sea level. It is 74 km long. It is seven times as salty (30% by volume) as the ocean. Its density keeps swimmers afloat. Only simple organisms can live in its saline waters

Well-formulated knowledge - Simple and specific

Q: Where is the Dead Sea located?
A: on the border between Israel and Jordan

Q: What is the lowest point on the Earth's surface?

Q: What is the average level on which the Dead Sea is located?
A: 400 meters (below sea level)

Q: How long is the Dead Sea?
A: 70 km

Q: How much saltier is the Dead Sea as compared with the oceans?
A: 7 times

Q: What is the volume content of salt in the Dead Sea?
A: 30%

Q: Why can the Dead Sea keep swimmers afloat?
A: due to high salt content

A: because only simple organisms can live in it

Q: Why only simple organisms can live in the Dead Sea?
A: because of high salt content

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915656

Tags
#learning #memo
Question
Two tips for minimum information principle.
1. Make questions short.

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915663

Tags
#learning #memo
Question
Top 4 important facts to remember when formulating knowledge: BLeD Principle.
1. Build upon the Basics.

2. Learn before you memorize.

3. Do not learn if you do not understand.

4. Minimum Information Principle.

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915670

Tags
#learning #memo
Question
[...] makes the core of the fast reading and learning technique called incremental reading.
Cloze deletion

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915689

Tags
#learning
Question
Chunk
Main Idea

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915696

Tags
#learning
Question
Unites bits of info together through meaning
Chunking

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915703

Tags
#learning
Question
Learning a new concept is like ...(analogy)
solving jumbled puzzle pieces.

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915710

Tags
#learning
Question
In focused mode, the [...] connects ideas to form connections.
Octopus of Attention

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915717

Tags
#learning
Question
... makes Octopus of Attention blurry
Negative emotions (e.g. Stress, Anger, Jealousy, Afraid, etc.)

status measured difficulty not learned 37% [default] 0

#### Flashcard 150915724

Tags
#learning
Question
1. Once you [...] an idea, you don't need to remember all the details.
2. Give Example