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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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 characterstatus | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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)`

.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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 integersstatus | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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
*not* be used for computing the width of a
string on display; use

`length`

should `string-width`

(see Size of Displayed Text) instead.status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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"

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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]+"`

.

status | not read | reprioritisations | ||
---|---|---|---|---|

last reprioritisation on | reading queue position [%] | |||

started reading on | finished reading on |

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>

Tags

#learning #memo

Question

Always avoid **[...]** when learning.

Answer

sets

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning #memo

Question

True or False?

Answer

True

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning #memo

Question

Simple is easy.

Give an imagery on how this works.

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.

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

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:

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

Well-formulated knowledge - Simple and specific |

Q: Where is the Dead Sea located? Q: What is the lowest point on the Earth's surface? Q: What is the average level on which the Dead Sea is located? Q: How long is the Dead Sea? Q: How much saltier is the Dead Sea as compared with the oceans? Q: What is the volume content of salt in the Dead Sea? Q: Why can the Dead Sea keep swimmers afloat? Q: Why is the Dead Sea called Dead? Q: Why only simple organisms can live in the Dead Sea? |

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning #memo

Question

Two tips for minimum information principle.

Answer

1. Make questions short.

2. Make answers even shorter.

2. Make answers even shorter.

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning #memo

Question

Top 4 important facts to remember when formulating knowledge: **BLeD** **Principle.**

Answer

1. **B**uild upon the Basics.

2.**Le**arn before you memorize.

3.**D**o not learn if you do not understand.

4. Minimum Information**Principle**.

2.

3.

4. Minimum Information

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning #memo

Question

Answer

Cloze deletion

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

Chunk

Answer

Main Idea

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

Unites bits of info together through meaning

Answer

Chunking

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

Learning a new concept is like ...(analogy)

Answer

solving jumbled puzzle pieces.

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

In focused mode, the **[...]** connects ideas to form connections.

Answer

Octopus of Attention

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

... makes Octopus of Attention blurry

Answer

Negative emotions (e.g. Stress, Anger, Jealousy, Afraid, etc.)

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |

Tags

#learning

Question

1. Once you **[...]** an idea, you don't need to remember all the details.

2. Give Example

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.

2. Dressing up--It's amazing if you realize the amount of underlying activities in that one simple thought.

status | not learned | measured difficulty | 37% [default] | last interval [days] | |||
---|---|---|---|---|---|---|---|

repetition number in this series | 0 | memorised on | scheduled repetition | ||||

scheduled repetition interval | last repetition or drill |