2.6 Логические функции

1) Функция NOT [object]. Если <объект> есть атом NIL, функция возвращает Т, иначе - NIL. Т.к. атом NIL является одновременно пустым списком и значением "ложь", функции NULL и NOT всегда возвращают одинаковые значения. Однако для лучшей читабельности программ лучше использовать NULL при проверке пустого списка, а NOT - при проверке значений на "ложь".

(NOT NIL) --> T

(NOT '()) --> T

(NOT 'FOO) --> NIL

(NOT (EQ 'DOG 'CAT))  T

2) Функция AND [form1,form2, ...,formN] оценивает каждую форму по очереди до тех пор, пока одна из них не будет оценена как NIL или пока все формы не будут оценены. Если форма оценивается как NIL, AND возвращает NIL. В противном случае возвращается значение <формы N>. Отметим, что каждая последующая форма оценивается тогда и только тогда, когда все предшествующие формы получили оценку не NIL.

(AND (EQ 'DOG 'CAT) (< 2 3)) --> NIL

(AND (EQ 'DOG 'DOG) (< 2 3)) --> T

3) Функция OR [form1,form2, ...,form N] оценивает каждую форму по очереди до тех пор, пока одна из них не получит оценку не NIL или пока все формы не будут оценены. Если форма получила оценку не NIL, OR выдает это отличное от NIL значение формы; иначе выдается NIL.

(OR (EQ 'DOG 'CAT) (< 2 3)) --> T

(OR (EQ 'DOG 'CAT) (< 3 2)) --> NIL

(OR (EQ 'DOG 'DOG) (< 2 3)) --> T

2.7 Числовые функции

1) Функция MAX [n1,n2,…,n M] возвращает свой наибольший аргумент. Если MAX вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов".

(MAX 5 -7 4) --> 5

(MAX 2/3 0.6) --> 0.6666666

(MAX -4) --> -4

2) Функция MIN [n1,n2,...,n M] возвращает свой наименьший аргумент. Если MIN вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов".

(MIN 2/3 0.6) --> 0.6

(MIN -4) --> -4

3) Функция + [n1,n2,...,nM] возвращает сумму чисел с <n1> по <nM>. Если функция вызывается без аргументов, она возвращает 0, который является идентификатором данной операции.

(+ 2 3 4) --> 9

(+ -5 3) --> -2

(+ 1/6 0.7) --> 0.8666666

(+ 0.25) --> 0.25

4) Функция -[n1,n2,...,nM] возвращает разницу между <n1> и суммой чисел с <n2> по <nM>. (-n) возвращает минус <n>. Если функция вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов".

(-12 5) --> 7

(-12 5 -3) --> 10

(-17/9 1.5) --> 0.3888888

(-8) --> -8

5) Функция / [n1,n2,...,nM] возвращает результат деления <n1> на произведение чисел с <n2> по <nM>. Если функция вызывается с единственным аргументом, она возвращает число, обратное аргументу. Если функция вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов". Если какой-либо аргумент, кроме первого, равен нулю, возникает прерывание по ошибке "Деление на ноль".

(/ 12 8) --> 1.5

(/ 12 5 -3) --> -0.8

(/ -4.7 1.3) --> -3.6153846

(/ 5) --> 0.2

6) Функции ADD1 [n] возвращает инкремент n (+ n 1). Если ADD1 вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов".

(ADD1 3) --> 4

(ADD 2/3) --> 1.6666666

(ADD1 -3) --> -2

7) Функция SUB1 [n] возвращает декремент n (- n 1). Если SUB1 вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов".

(SUB1 3) --> 2

(SUB1 0.25) --> -0.75

(SUB1 -3) --> -4

8) Функция: GCD [n1,n2,...],nM] возвращает наибольший общий делитель чисел с <n1> по <nM>. (GCD n) возвращает абсолютную величину <n>. Если функция вызывается без аргументов, GCD возвращает 0 - идентификатор данной операции. GCD от двух чисел есть наибольшее неотрицательное целое число, которое одинаково делится на оба данных числа. GCD от двух дробных чисел есть GCD от числителей, деленный на LCM от знаменателей.

(GCD 12 -16 20) --> 4

(GCD 14/15 8/9)--> 0.0444444

(GCD 0 5) --> 5

(GCD 0 0) --> 0

(GCD) --> 0

(GCD -7) --> 7

9) Функция LCM [n1,n2,...,nM] возвращает наименьшее общее кратное для чисел с <n1> по <nM>. (LCM n) возвращает абсолютное значение <n>. Если LCM вызывается без аргументов, возникает прерывание по ошибке "Недостаточное количество аргументов". LCM от двух целых чисел есть наименьшее целое, которое кратно обоим данным числам. В общем случае, LCM от двух чисел <n> и <m>, целых или дробных, может определяться посредством GCD как (/ABS(*n m)) (GCD n m)).

(LCM 12 -16 20) --> 240

(LCM 14/15 8/9) --> 18.6666666 ;

(LCM 0 5) --> 0

(LCM 0 0) --> 0

(LCM -7) --> 7

10) Функция ABS [n] возвращает абсолютное значение <n>

(ABS 4/6) --> 0.6666666

(ABS -3) --> 3

(ABS 0) --> 0

11) Функция SIGNUM [n] возвращает 1, -1 или 0 в зависимости от того, является ли <n> положительным, отрицательным или нулем.

(SIGNUM 7/2) --> 1

(SIGNUM 0) --> 0

(SIGNUM -0.2) --> -1

12) Функция FLOOR [n,m]. Если <n> - целое число, (FLOOR n) возвращает <n>. Если <n> - дробное, FLOOR возвращает наибольшее целое число, но меньше, чем <n>. Другими словами, (FLOOR n m) усекает <n> по нижней границе. Если <n> и <m> - числа, (FLOOR n m) усекает по нижней границе частное от деления <n> на <m>. (FLOOR n m) эквивалентно (FLOOR (/n m)). Если <n> (т.е. делитель) - ноль, возникает прерывание по ошибке "Деление на ноль".

(FLOOR 7.3) --> 7

(FLOOR -3.5) -->-4

(FLOOR 8 3) --> 2

(FLOOR -15/4 2) -->-2

13) Функция CEILING [n,m]. Если <n> - целое, (CEILING n) возвращает <n>. Если <n> - дробное, CEILING возвращает наименьшее целое число, но больше, чем <n>. Другими словами, CEILING усекает <n> по верхней границе. Если <n> и <m> - числа, (CEILING n m) усекает по верхней границе частное от деления <n> на <m>. (CEILING n m) эквивалентно (CEILING (/n m)). Если <m> (т.е. делитель) - ноль, возникает прерывание по ошибке "Деление на ноль".

(CEILING 7.3) --> 8

(CEILING -3.5) --> -3

(CEILING 8 3) --> 3

(CEILING -15/4 2) --> -1

14) Функция TRUNCATE [n,m] Если <n> - целое число, (TRUNCATE n) возвращает <n>. Если <n> - положительное дробное число, TRUNCATE возвращает наибольшее целое число, но меньше <n>. Если <n> - отрицательное дробное число, TRUNCATE возвращает наименьшее целое число, но больше <n>. Другими словами, TRUNCATE усекает <n>, приближая его к нулю. Если <n> и <m> - числа, (TRUNCATE n m) усекает к нулю частное от деления <n> на <m>. (TRUNCATE n m) ] (TRUNCATE (/ n m)). Если <n> (т.е. делитель) - ноль, возникает прерывание по ошибке "Деление на ноль".

(TRUNCATE 7.3) --> 7

(TRUNCATE -3.5) --> -3

(TRUNCATE 8 3) --> 2

(TRUNCATE -15/4 2) --> -1

15) Функция ROUND [n,m]. Если <n> - целое число, (ROUND n) возвращает <n>. Если <n> - дробное, ROUND возвращает целое число, ближайшее по значению к <n>. Если <n> стоит посередине между двумя целыми числами (т.е. 2*n - целое число), ROUND возвращает одно из них, делящееся без остатка нк другое. Если <n> и <m> - числа, (ROUND n m) округляет частное от деления <n> на <m>. Вызов (ROUND n m) эквивалентен (ROUND (/ n m)). Если <m> (т.е. делитель) - ноль, возникает прерывание по ошибке "Деление на ноль".

(ROUND 7.3) --> 7

(ROUND -3.5) --> -4

(ROUND 8 3) --> 3

(ROUND -15/4 2) --> -2

16) Функция MOD [n,m]. Если <n> и <m> - числа, (MOD n m) возвращает результат деления <n> на <m> по модулю. Если <m> (т.е делитель) равен нулю, возникает прерывание по ошибке "Деление на ноль". MOD определен так, что FLOOR и MOD сохраняют связь между частными и остатками: n=m*(FLOOR n m) + (MOD n m)

(MOD 7 3) --> 1

(MOD -7 3) --> 2

(MOD 7 -3) --> -2

(MOD -7 -3) --> -1

17) Функция REM [n,m]. Если <n> и <m> - числа, (REM n m) возвращает остаток от деления <n> на <m>. Если <m> (т.е делитель) равен нулю, возникает прерывание по ошибке "Деление на ноль". REM определен так, что TRUNCATE и REM сохраняют связь между частными и остатками: n = m*(TRUNCATE n m) + (REM n m).

(REM 7 3) --> 1

(REM -7 3) --> -1

(REM 7 -3) --> 1

(REM -7 -3) --> -1

18) Функция DIVIDE [n,m]. Если <n> - число, (DIVIDE n m) возвращает пару (cons), у которой car-элемент есть (TRUNCATE n), а cdr-элемент - (REM n). Если <n> и <m> - числа, (DIVIDE n m) возвращает пару (cons), у которой car-элемент есть (TRUNCATE n m), а cdr-элемент - (REM n m). Если <m> (т.е. делитель) равен нулю, возникает прерывание по ошибке "Деление на ноль". В том случае, когда требуются усеченные частное и остаток одновременно, выгоднее использовать функцию DIVIDE, чем вычислять их отдельно.

(DIVIDE 7 3) --> (2 . 1)

(DIVIDE -7 3) --> (-2 . -1)

(DIVIDE 7 -3) --> (-2 . 1)

(DIVIDE -7 -3) --> (2 . -1)

19) Функция LOGAND [n1,n2,...,nM] возвращает результат выполнения побитового логического "И" над целыми числами <n1>,...,<nM>. Если LOGAND вызывается без аргументов, функция выдает "-1" - идентификатор данной операции.

(LOGAND 11 6) --> 2

20) Функция LOGIOR [n1,n2,..,nM] возвращает результат выполнения побитового логического "ИЛИ" над целыми числами <n1>, <n2>, ..., <nM>. Если LOGIOR вызывается без аргументов, функция выдает 0 - идентификатор данной функции.

(LOGIOR 11 6) --> 15

21) Функция LOGXOR [n1,n2,...,nM] возвращает результат выполнения побитового логического исключающего "ИЛИ" (XOR) над целыми числами <n1>, ..., <nM>. Если LOGXOR вызывается без аргументов, функция возвращает 0 - идентификатор данной функции.

(LOGXOR 11 6) --> 13

22) Функция LOGNOT [n] возвращает результат выполнения побитового логического "НЕ" над <n>.

(LOGNOT 9) --> 65526

23) Функция SHIFT [n,m]. Если <m> - положительное, (SHIFT n m) возвращает результат сдвига <n> влево на <m> битов. Если <m> - отрицательное, <n> сдвигается вправо на -<m> битов.

(SHIFT 5 2) --> 20

(SHIFT 5 -2) --> 1

24) Функция BITLENGTH [n] возвращает количество битов, требуемое для размещения <n>.

(BITLENGTH 4) --> 3

(BITLENGTH 7) --> 3

(BITLENGTH 8) --> 4

25) Функция PRECISION [n]. Если <n> - положительное целое, (PRECISION n) принимает <n> за значение точности и возвращает предыдущее значение точности. Если <n> равен нулю, (PRECISION n) принимает значение точности за бесконечность и возвращает предыдущее значение. Если <n> отсутствует или не является ни нулем, ни положительным целым, PRECISION n) возвращает текущее значение точности без его изменения.

Если значение точности принято равным положительному целому <n>, то новое дробное число, сгенерированное числовыми функциями, автоматически округляется, если для размещения меньшей из величин его числителя и знаменателя требуется больше, чем <n> слов памяти (слово памяти состоит из 16 бит). Такое дробное число заменяется аппроксимацией, причем такой, которая требует для размещения наименьшей из величин числителя и знаменателя не более <n> слов.

Точность плавающего слеша, равная 1, соответствует единичной точности плавающей точки; точность плавающего слеша, равная 2, соответствует двойной точности плавающей точки, и т.д. Точность плавающего слеша, равная <n>, также обеспечивает почти 10*n десятичных знаков точности. Первоначальное значение точности предполагается равным 1.

(PRECISION 0) --> 1

(PRECISION 5) --> 0

(PRECISION) --> 5

(PRECISION 1) --> 5

26) Функция UNDERFLOW [n]. Часто в процессе вычислений с аппроксимацией требуются такие числа, которые по абсолютной величине меньше, чем некоторое число с плавающей точкой, стремящееся к нулю (ситуация "underflow"). Если <n> - положительное целое, (UNDERFLOW n) полагает значение, на котором возникает ситуация "underflow", равным 65536^-n и возвращает предыдущее значение "underflow". Если <n> - ноль, (UNDERFLOW n) предотвращает возникновение "underflow" и возвращает предыдущее значение. Если <n> отсутствует или не является ни 0, ни положительным целым, (UNDERFLOW n) возвращает текущее значение "underflow" без его изменения. Первоначально "underflow" принимается равным 7.

(UNDERFLOW 0) --> 7

(UNDERFLOW 5) --> 0

(UNDERFLOW) --> 5

(UNDERFLOW 7) --> 5