Edited, memorised or added to reading list

on 19-Sep-2015 (Sat)

Do you want BuboFlash to help you learning these things? Click here to log in or create user.

#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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

GNU Emacs Lisp Reference Manual: Integer Basics
; The integer 1. +1 ; Also the integer 1. -1 ; The integer -1. 9000000000000000000 ; The floating-point number 9e18. 0 ; The integer 0. -0 ; The integer 0. <span>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 To understand how various functions work on integers, especially the bitwise operators (see Bitwise Operations), it is often helpful to view the numbers in their binary form. In 30-bi




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




#elisp
Function: isnan x

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




#elisp
Function: floatp object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: integerp object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: numberp object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




#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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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.




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: float number

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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)




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




#elisp
Function: 1- number-or-marker

This function returns number-or-marker minus 1.

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: exp arg

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Variable: float-e

The mathematical constant e (2.71828…).

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Variable: float-pi

The mathematical constant pi (3.14159…).

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: stringp object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: string-or-null-p object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




#elisp
Function: char-or-string-p object

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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>




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Function: string &rest characters

This returns a string containing the characters characters .

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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




#elisp
Variable: split-string-default-separators

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

statusnot read reprioritisations
last reprioritisation on reading queue position [%]
started reading on finished reading on

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.
Answer
sets


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






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?
Answer
True


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915642

Tags
#learning #memo
Question
Simple is easy.

Give an imagery on how this works.
Answer
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.


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915649

Tags
#learning #memo
Question
2 rules to follow in minimum information principle.
Answer
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?
A: The Dead Sea shoreline

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

Q: Why is the Dead Sea called Dead?
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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915656

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

2. Make answers even shorter.


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915663

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

2. Learn before you memorize.

3. Do not learn if you do not understand.

4. Minimum Information Principle.


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915670

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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915689

Tags
#learning
Question
Chunk
Answer
Main Idea


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915696

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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915703

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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915710

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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915717

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


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill






Flashcard 150915724

Tags
#learning
Question
1. Once you [...] an idea, you don't need to remember all the details.
2. Give Example
Answer
1. chunk
2. Dressing up--It's amazing if you realize the amount of underlying activities in that one simple thought.


statusnot learnedmeasured difficulty37% [default]last interval [days]               
repetition number in this series0memorised on               scheduled repetition               
scheduled repetition interval               last repetition or drill