Previous: Операторы отношения, Up: Операторы [Contents][Index]
Оператор некоммутативного возведение в степень.
^^ - оператор некоммутативного возведение в степень, соответствующий некоммутативному умножению .,
ровно так же как обычный оператор возведение в степень ^ соответствует коммутативному умножению *.
Некоммутативное возведение в степень отображается как ^^ в 1D (одномерном) выводе,
и в виде показателя степени как верхний индекс в угловых скобка < > в 2D (двумерном) выводе.
Примеры:
(%i1) a . a . b . b . b + a * a * a * b * b;
3 2 <2> <3>
(%o1) a b + a . b
(%i2) string (a . a . b . b . b + a * a * a * b * b);
(%o2) a^3*b^2+a^^2 . b^^3
Оператор факториала.
Для всех комплексных чисел x (включая целые, рациональные, и вещественные числа),
за исключением отрицательных целых, x! задается как gamma(x+1).
Для целого x, x! упрощается до произведения целых чисел от
1 до x включительно.
0! упрощается до 1.
Для чисел с плавающей точкой x, x! упрощается до значения gamma (x+1).
Для x равных n/2, где n - нечетное целое,
x! упрощается до рационального множителя, умноженного на sqrt (%pi)
(т. к. gamma (1/2) равно sqrt (%pi)).
Если x - что то еще, то x! не упрощается.
Переменные factlim, minfactorial и factcomb управляют упрощением выражений,
содержащих факториалы.
Функции gamma, bffac и cbffac
являются разновидностями гамма функции.
makegamma заменяет gamma для факториалов и связанных функций.
См. также binomial.
Факториал целого, полуцелого или аргумента с плавающей точкой, упрощается
если операнд не больше чем factlim.
(%i1) factlim : 10;
(%o1) 10
(%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
105 sqrt(%pi)
(%o2) [1, -------------, 81.44668037931199, 40320, 20!]
16
Факториал комплексного числа, известной константы, или выражение общего вида не упрощается. Но в этом случае возможно упростить факториал после вычисления операнда.
(%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
(%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
(%i2) ev (%, numer, %enumer);
(%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
1.227580202486819]
Факториал символа, не имеющего значения, не упрощается.
(%i1) kill (foo); (%o1) done (%i2) foo!; (%o2) foo!
Факториалы упрощаются, а не вычисляются.
Таким образом, x! можно заменять даже в экранированном (quoted) выражении.
(%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
105 sqrt(%pi)
(%o1) [1, -------------, 81.44668037931199, 40320,
16
2432902008176640000]
Оператор двойного факториала.
Для целого, числа с плавающей точкой или рационального числа n,
n!! вычисляется как произведение n (n-2) (n-4) (n-6) ... (n - 2 (k-1))
где k равно entier (n/2),
то есть, наибольшее целое меньше или равное n/2.
Заметим, что это определение не совпадает с другими опубликованными определениями
для нецелых аргументов.
Для четного (или нечетного) целого n, n!! вычисляется как произведение
всех последовательных четных (или нечетных) целых от 2 (или 1) до n включительно.
Для аргумента n, который не является целым, числом с плавающей точкой, или рациональным числом,
n!! дает невычисляемую форму genfact (n, n/2, 2).
Обозначает отрицание синтаксического равенства =.
Заметим, что из-за правил для вычисления предикатных выражений
(в частности из-за того, что not expr вызывает вычисление expr),
not a = b эквивалентно is(a # b),
вместо a # b.
Примеры:
(%i1) a = b; (%o1) a = b (%i2) is (a = b); (%o2) false (%i3) a # b; (%o3) a # b (%i4) not a = b; (%o4) true (%i5) is (a # b); (%o5) true (%i6) is (not a = b); (%o6) true
Оператор "точка" предназначен для матричного (некоммутативного) умножения.
Когда "." используется таким образом, пробелы должны присутствовать с обеих сторон,
то есть A . B. Это позволяет различать оператор от десятичной точки в числе с плавающей точкой.
См. также
dot,
dot0nscsimp,
dot0simp,
dot1simp,
dotassoc,
dotconstrules,
dotdistrib,
dotexptsimp,
dotident,
и
dotscrules.
Оператор присваивания.
Если левая сторона есть простая переменная (не переменная с индексом),
то : вычисляет правую сторону присваивания
и присваивает значение с левой частью.
Если левая строна есть индексированный элемент списка, матрица, объявленного Maxima массива или Lisp массива, то значение правой части присваивается этому элементу. Индекс должен выделять существующий элемент. Подобные конструкции нельзя расширить на несуществующие элементы.
Если левая сторона есть индексированный элемент необъявленного массива, то значение правой части присваивается этому элементу, если таковой уже существует, или вновь созданному объекту, если он еще не существует.
Если левая строна присваивания есть список простых переменных и/или переменных с индексом, то правая часть должна вычисляться в список, и элементы этого списка присваиваются элементам левой части параллельно.
См. также kill и remvalue,
которые отменяют присваивание.
Примеры:
Присваивание простой переменной.
(%i1) a; (%o1) a (%i2) a : 123; (%o2) 123 (%i3) a; (%o3) 123
Присваивание элементу списка.
(%i1) b : [1, 2, 3]; (%o1) [1, 2, 3] (%i2) b[3] : 456; (%o2) 456 (%i3) b; (%o3) [1, 2, 456]
Присваивание создает необъявленный массив.
(%i1) c[99] : 789; (%o1) 789 (%i2) c[99]; (%o2) 789 (%i3) c; (%o3) c (%i4) arrayinfo (c); (%o4) [hashed, 1, [99]] (%i5) listarray (c); (%o5) [789]
Множественные присваивания.
(%i1) [a, b, c] : [45, 67, 89]; (%o1) [45, 67, 89] (%i2) a; (%o2) 45 (%i3) b; (%o3) 67 (%i4) c; (%o4) 89
Множественные присваивания выполняются параллельно.
В этом примере переменные a и b обмениваются значениями.
(%i1) [a, b] : [33, 55]; (%o1) [33, 55] (%i2) [a, b] : [b, a]; (%o2) [55, 33] (%i3) a; (%o3) 55 (%i4) b; (%o4) 33
Оператор присваивания.
Оператор :: аналогичен оператору присваивания :
за исключением того, что :: вычисляет свою левую часть наряду с вычислением правой части.
Примеры:
(%i1) x : 'foo; (%o1) foo (%i2) x :: 123; (%o2) 123 (%i3) foo; (%o3) 123 (%i4) x : '[a, b, c]; (%o4) [a, b, c] (%i5) x :: [11, 22, 33]; (%o5) [11, 22, 33] (%i6) a; (%o6) 11 (%i7) b; (%o7) 22 (%i8) c; (%o8) 33
Оператор определения макро функции.
::= задает функцию (называемую "макрос" по историческим причинам)
которое экранирует (quote) свои аргументы,
и выражение, которое она возвращает (называемое "макро расширение"),
вычисляется в том контексте, из которого этот макрос был вызван.
В других отношениях макро функция такая же как и обыкновенная функция.
Функция macroexpand возвращает макро расширение (без ее вычисления).
macroexpand (foo (x)) следующее за ''% эквивалентно foo (x),
где foo есть макро функция.
Оператор ::= помещает имя новой макро функции в глобальный список macros.
Функции kill, remove и remfunction удаляет определения макро функций
и удаляет имена из macros.
Функции fundef или dispfun, соответственно,
возвращает определение макро функции или присваивает его метке.
Макро функции обычно содержат buildq и splice
выражения для конструирования выражения,
которое затем вычисляется.
Примеры.
Макро функция экранирует свои аргументы,
так что сообщение (1) показывает выражение y - z, а не значение y - z.
Макро расширение (экранированное выражение '(print ("(2) x равно ", x))
вычисляется в том контексте, из которого этот макрос был вызван,
печатая сообщение (2).
(%i1) x: %pi;
(%o1) %pi
(%i2) y: 1234;
(%o2) 1234
(%i3) z: 1729 * w;
(%o3) 1729 w
(%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)));
(%o4) printq1(x) ::= block(print("(1) x is equal to", x),
'(print("(2) x is equal to", x)))
(%i5) printq1 (y - z);
(1) x is equal to y - z
(2) x is equal to %pi
(%o5) %pi
Обыкновенная функция вычисляет свои аргументы, так что сообщение (1) показывает значение y - z.
Возвращаемое значение не вычисляется, так что сообщение (2) не печатается
до момента явного вычисления ''%.
(%i1) x: %pi;
(%o1) %pi
(%i2) y: 1234;
(%o2) 1234
(%i3) z: 1729 * w;
(%o3) 1729 w
(%i4) printe1 (x) := block (print ("(1) x is equal to", x),
'(print ("(2) x is equal to", x)));
(%o4) printe1(x) := block(print("(1) x is equal to", x),
'(print("(2) x is equal to", x)))
(%i5) printe1 (y - z);
(1) x is equal to 1234 - 1729 w
(%o5) print((2) x is equal to, x)
(%i6) ''%;
(2) x is equal to %pi
(%o6) %pi
Функция macroexpand возвращает макро расширение.
Выражение macroexpand (foo (x)), идущее перед ''% эквивалентно foo (x),
когда foo есть макро функция.
(%i1) x: %pi;
(%o1) %pi
(%i2) y: 1234;
(%o2) 1234
(%i3) z: 1729 * w;
(%o3) 1729 w
(%i4) g (x) ::= buildq ([x], print ("x is equal to", x));
(%o4) g(x) ::= buildq([x], print("x is equal to", x))
(%i5) macroexpand (g (y - z));
(%o5) print(x is equal to, y - z)
(%i6) ''%;
x is equal to 1234 - 1729 w
(%o6) 1234 - 1729 w
(%i7) g (y - z);
x is equal to 1234 - 1729 w
(%o7) 1234 - 1729 w
Оператор определения функции.
f(x_1, ..., x_n) := expr
определяет функцию с именем f, аргументами x_1, ..., x_n и телом функции expr.
Оператор := никогда не вычисляет тело функции (если только вычисление не задано явно оператором
кавычка-кавычка '').
Функция заданная таким образом может быть обыкновенной Maxima функцией (с аргументами, заключенными в скобки)
или функцией массивом (с аргументами, заключенными в квадратные скобки).
Когда последний или единственный аргумент функции x_n есть список из одного элемента,
функция, заданная := принимает переменное число аргументов.
Фактические аргументы присваиваются один-в-один формальным аргументам x_1, ..., x_(n - 1),
и любые дальнейшие фактические аргументы, если присутствуют, присваиваются к x_n как список.
Все определения функций появляются в том же пространстве имен;
задав функцию f внутри другой функции g, определение
не ограничивает зону видимости f в g.
Если некоторый формальный аргумент x_k есть экранированный (quoted) символ,
функция, заданная с помощью :=, не вычисляет соответствующий фактический аргумент.
В противном случае, все фактические аргументы вычисляются.
См. также define и ::=.
Примеры:
:= никогда не вычисляет тело функции (если только явно не задано вычисление).
(%i1) expr : cos(y) - sin(x); (%o1) cos(y) - sin(x) (%i2) F1 (x, y) := expr; (%o2) F1(x, y) := expr (%i3) F1 (a, b); (%o3) cos(y) - sin(x) (%i4) F2 (x, y) := ''expr; (%o4) F2(x, y) := cos(y) - sin(x) (%i5) F2 (a, b); (%o5) cos(b) - sin(a)
Функция, заданная :=, может быть обыкновенной Maxima функцией или функцией массивом.
(%i1) G1 (x, y) := x.y - y.x;
(%o1) G1(x, y) := x . y - y . x
(%i2) G2 [x, y] := x.y - y.x;
(%o2) G2 := x . y - y . x
x, y
Когда последний или единственный аргумент функции x_n есть список из одного элемента,
функция, заданная :=, принимает переменное число аргументов.
(%i1) H ([L]) := apply ("+", L);
(%o1) H([L]) := apply("+", L)
(%i2) H (a, b, c);
(%o2) c + b + a
Оператор равенства.
Выражение a = b, само по себе, представляет собой
невычисляемое уравнение, которое может или может не выполняться.
Невычисляемые уравнения могут появляться как аргументы в solve и algsys,
или в некоторых других функциях.
Функция is вычисляет = до логического значения.
is(a = b) вычисляет a = b в true, когда a и b
тождественны. То есть, a и b есть атомы, которые идентичны,
или они не атомы и их операторы идентичны и их аргументы идентичны.
В противном случае, is(a = b) вычисляется в false;
он никогда не вычисляется в unknown.
Когда is(a = b) есть true, говорят что a и b синтаксически равны,
в противоположность эквивалентным выражениям, для которых is(equal(a, b)) есть true.
Выражения могут быть равны, но синтаксически не равны.
Отрицание = представляется как #.
Как и в случае с =, выражение a # b, само по себе, не вычисляется.
is(a # b) вычисляется a # b до
true или false.
Кроме is,
некоторые другие операторы вычисляют = и # до true или false,
а именно if, and, or и not.
Заметим, что из-за правил для вычисления предикатных выражений
(в частности из-за того, что not expr вызывает вычисление expr),
not a = b эквивалентно is(a # b),
а не a # b.
rhs и lhs возвращают правую и левую часть
уравнения или неравенства соответственно.
См. также equal или notequal.
Примеры:
Выражение a = b, само по себе, представляет
невычисляемое уравнение, которое может или может не выполняться.
(%i1) eq_1 : a * x - 5 * y = 17;
(%o1) a x - 5 y = 17
(%i2) eq_2 : b * x + 3 * y = 29;
(%o2) 3 y + b x = 29
(%i3) solve ([eq_1, eq_2], [x, y]);
196 29 a - 17 b
(%o3) [[x = ---------, y = -----------]]
5 b + 3 a 5 b + 3 a
(%i4) subst (%, [eq_1, eq_2]);
196 a 5 (29 a - 17 b)
(%o4) [--------- - --------------- = 17,
5 b + 3 a 5 b + 3 a
196 b 3 (29 a - 17 b)
--------- + --------------- = 29]
5 b + 3 a 5 b + 3 a
(%i5) ratsimp (%);
(%o5) [17 = 17, 29 = 29]
is(a = b) вычисляет a = b в true,
когда a и b тождественны (синтаксически равны).
Выражения могут быть равны, но синтаксически не равны.
(%i1) a : (x + 1) * (x - 1);
(%o1) (x - 1) (x + 1)
(%i2) b : x^2 - 1;
2
(%o2) x - 1
(%i3) [is (a = b), is (a # b)];
(%o3) [false, true]
(%i4) [is (equal (a, b)), is (notequal (a, b))];
(%o4) [true, false]
Некоторые операторы вычисляют = и # до true или false.
(%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
BAR;
(%o1) FOO
(%i2) eq_3 : 2 * x = 3 * x;
(%o2) 2 x = 3 x
(%i3) eq_4 : exp (2) = %e^2;
2 2
(%o3) %e = %e
(%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
(%o4) [false, true, true]
Из-за того, что not expr вызывает вычисление expr,
not a = b эквивалентно is(a # b).
(%i1) [2 * x # 3 * x, not (2 * x = 3 * x)]; (%o1) [2 x # 3 x, true] (%i2) is (2 * x # 3 * x); (%o2) true
Оператор логического умножения.
Оператор and есть n-арный инфиксный оператор.
Его операнды есть логические выражения и его результат есть логическое значение.
Оператор and вызывает вычисление (как и is) одного или более операндов,
и может вызвать вычисление всех операндов.
Операнды вычисляются в том же порядка, к котором они встречаются.
Оператор and вычисляет только столько своих операндов, сколько необходимо для того,
чтобы определить результат.
Если хотя бы один операнд есть false,
результат есть false, и более ни один из операндов не вычисляется.
Глобальный флаг prederror управляет поведением and,
когда вычисляемый операнд не может быть определен как true или false.
Оператор and печатает сообщение об ошибке, когда prederror есть true.
Иначе, операнды, которые не могут быть вычислены как true или false, принимаются,
и результат есть логическое выражение.
Оператор and не является коммутативным:
a and b может быть не равно b and a из-за трактовки неопределенных операндов.
Оператор логического сложения.
or есть n-арный инфиксный оператор.
Его операнды есть логические выражения и его результат есть логическое значение.
or вызывает вычисление (как и is) одного или более операндов,
и может вызвать вычисление всех операндов.
Операнды вычисляются в том же порядка, к котором они встречаются.
or вычисляет только столько своих операндов, сколько необходимо для того, чтобы определить результат.
Если хотя бы один операнд есть true,
результат есть true, и более ни один из операндов не вычисляется.
Глобальный флаг prederror управляет поведением or,
когда вычисляемый операнд не может быть определен как true или false.
Оператор or печатает сообщение об ошибке, когда prederror есть true.
Иначе, операнды, которые не могут быть вычислены как true или false, принимаются,
и результат есть логическое выражение.
Оператор or не является коммутативным:
a or b может быть не равно b or a из-за трактовки неопределенных операндов.
Оператор логического отрицания.
Оператор not есть префиксный оператор.
Его операнд есть логическое выражение и его результат есть логическое значение.
Оператор not вызывает вычисление (как и is) своего операнда.
Глобальный флаг prederror управляет поведением not,
когда его операнд не может быть определен как значения true или false.
Оператор not печатает сообщение об ошибке, когда prederror есть true.
Иначе, операнды, которые не могут быть вычислены как true или false, принимаются,
и результат есть логическое выражение.
Возвращает абсолютное значение expr (модуль выражения). Если expr - комплексное, возвращается комплексный модуль expr.
Если declare(f,additive) было выполнено, то:
(1) Если f одномерно, пока упрощение не столкнулось с f примененному к сумме,
f будет распространено вдоль этой суммы. То есть, f(y+x) будет
упрощено как f(y)+f(x).
(2) Если f есть функция двух или более аргументов, аддитивность задается как
аддитивность по первому аргументу f, как в случае sum или
integrate, то есть f(h(x)+g(x),x) будет упрощено как f(h(x),x)+f(g(x),x).
Это упрощение не произойдет, когда f применена к выражению вида sum(x[i],i,lower-limit,upper-limit).
Работает с командами part (например, part, inpart, substpart,
substinpart, dpart и lpart). Например:
(%i1) expr : e + d + c + b + a; (%o1) e + d + c + b + a (%i2) part (expr, [2, 5]); (%o2) d + a
хотя
(%i1) expr : e + d + c + b + a; (%o1) e + d + c + b + a (%i2) part (expr, allbut (2, 5)); (%o2) e + c + b
allbut также распознается kill.
(%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55]; (%o1) [11, 22, 33, 44, 55] (%i2) kill (allbut (cc, dd)); (%o0) done (%i1) [aa, bb, cc, dd]; (%o1) [aa, bb, 33, 44]
kill(allbut(a_1, a_2, ...)) имеет тот же эффект, что kill(all)
за исключением того, что это не очищает символы a_1, a_2, ... .
Если declare(h,antisymmetric) выполнена, этот говорит
упрощателю, что h - антисимметричная. Например, h(x,z,y) упростится до
- h(x, y, z). То есть, это дает (-1)^n умноженное на symmetric
или commutative результат, где n есть число перестановок двух
аргументов необходимых для того, чтобы перевести к конечной форме.
Возвращает комплексное абсолютное значение (комплексный модуль) expr.
Когда x есть вещественное число - возвращает наименьшее целое, которое больше чем или равно x.
Если x - константное выражение (10 * %pi, например),
ceiling вычисляет x используя большие числа с плавающей точкой и
применяет ceiling к конечному большому числу с плавающей точкой.
Из-за того, что ceiling использует вычисления
с числами с плавающей точкой, возможно, хотя маловероятно,
что ceiling может вернуть ошибочное значение для константных
входных данных. Чтобы защититься от ошибок, вычисление с числами с плавающей точкой
выполняется с использованием трех значений для fpprec.
Для неконстантных входных данных, ceiling пытается вернуть упрощенное
значение. Вот примеры упрощений, о которых ceiling
знает:
(%i1) ceiling (ceiling (x)); (%o1) ceiling(x) (%i2) ceiling (floor (x)); (%o2) floor(x) (%i3) declare (n, integer)$ (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))]; (%o4) [n, abs(n), max(n, 6)] (%i5) assume (x > 0, x < 1)$ (%i6) ceiling (x); (%o6) 1 (%i7) tex (ceiling (a)); $$\left \lceil a \right \rceil$$ (%o7) false
Функция ceiling автоматически не распространяется (map) для списков или матриц.
Наконец, для всех входных данных, которые объявлены комплексными,
ceiling возвращает невычисляемую форму.
Если диапазон функции есть подмножество целых, она может быть
объявлена как integervalued. Обе функции ceiling и floor
могут использовать эту информацию. Например:
(%i1) declare (f, integervalued)$ (%i2) floor (f(x)); (%o2) f(x) (%i3) ceiling (f(x) - 1); (%o3) f(x) - 1
Возвращает 0, когда предикат p вычисляется как false; возвращает
1, когда предикат вычисляется как true. Когда предикат
вычисляется до чего-то другого, чем true или false (unknown),
возвращает невычисляемую форму.
Примеры:
(%i1) charfun (x < 1);
(%o1) charfun(x < 1)
(%i2) subst (x = -1, %);
(%o2) 1
(%i3) e : charfun ('"and" (-1 < x, x < 1))$
(%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
(%o4) [0, 1, 0]
Если declare(h,commutative) выполнено, это говорит
упрощателю, что h есть коммутативная функция. То есть h(x,z,y)
упроститься до h(x, y, z). Это тоже самое, что и symmetric.
Возвращает оператор отношения op
(<, <=, >, >=, = или #) так что
is (x op y) вычисляется до true;
когда x или y зависит от %i и
x # y, возвращает notcomparable;
когда нет такого оператора или
Maxima не может определить оператор, возвращает unknown.
Примеры:
(%i1) compare (1, 2); (%o1) < (%i2) compare (1, x); (%o2) unknown (%i3) compare (%i, %i); (%o3) = (%i4) compare (%i, %i + 1); (%o4) notcomparable (%i5) compare (1/x, 0); (%o5) # (%i6) compare (x, abs(x)); (%o6) <=
Функция compare не пытается определить, действительно ли области определения ее аргументов непусты.
Таким образом
(%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1); (%o1) <
Действительная область определения acos (x^2 + 1) пуста.
Возвращает наибольшее целое меньше или равное чем x, где x - численное.
Функция fix (как и в fixnum) есть синоним,
так что fix(x) в точности тоже самое.
Представляет эквивалентность, то есть, равное значение.
Само по себе, equal не вычисляется или упрощается.
Функция is пытается вычислить equal до логического значения.
Функция is(equal(a, b))
возвращает true (или false), если
и только если, a и b равны (или не равны) для всех возможных
значений своих переменных, как определено вычислением ratsimp(a - b).
Если ratsimp возвращает 0, два выражения рассматриваются эквивалентными.
Два выражения могут быть эквивалентными даже если они не являются синтаксически равными (то есть, идентичными).
Когда is не может упростить equal до true или false,
результат управляется глобальным флагом prederror.
Когда prederror есть true,
is выдает сообщение об ошибке.
Иначе, is возвращает unknown.
В добавление к is,
некоторые другие операторы вычисляют equal и notequal до true или false,
а именно if, and, or и not.
Отрицанием equal является notequal.
Примеры:
Само по себе, equal не вычисляет и не упрощает.
(%i1) equal (x^2 - 1, (x + 1) * (x - 1));
2
(%o1) equal(x - 1, (x - 1) (x + 1))
(%i2) equal (x, x + 1);
(%o2) equal(x, x + 1)
(%i3) equal (x, y);
(%o3) equal(x, y)
Функция is пытается вычислить equal до логического значения.
is(equal(a, b)) возвращает true когда ratsimp(a - b) возвращает 0.
Два выражения могут быть эквивалентными даже если они синтаксически не равны (то есть, не идентичны).
(%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1)); (%o1) 0 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1))); (%o2) true (%i3) is (x^2 - 1 = (x + 1) * (x - 1)); (%o3) false (%i4) ratsimp (x - (x + 1)); (%o4) - 1 (%i5) is (equal (x, x + 1)); (%o5) false (%i6) is (x = x + 1); (%o6) false (%i7) ratsimp (x - y); (%o7) x - y (%i8) is (equal (x, y)); (%o8) unknown (%i9) is (x = y); (%o9) false
Когда is не может упростить equal до true или false,
результат управляется глобальным флагом prederror.
(%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
2 2
(%o1) [x + 2 x + 1, x - 2 x - 1]
(%i2) ratsimp (aa - bb);
(%o2) 4 x + 2
(%i3) prederror : true;
(%o3) true
(%i4) is (equal (aa, bb));
Maxima was unable to evaluate the predicate:
2 2
equal(x + 2 x + 1, x - 2 x - 1)
-- an error. Quitting. To debug this try debugmode(true);
(%i5) prederror : false;
(%o5) false
(%i6) is (equal (aa, bb));
(%o6) unknown
Некоторые операторы вычисляют equal или notequal до true или false.
(%i1) if equal (y, y - 1) then FOO else BAR;
(%o1) BAR
(%i2) eq_1 : equal (x, x + 1);
(%o2) equal(x, x + 1)
(%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
2 2
(%o3) equal(y + 2 y + 1, (y + 1) )
(%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
(%o4) [false, true, true]
Из-за того, что not expr вызывает вычисление expr,
not equal(a, b) эквивалентно is(notequal(a, b)).
(%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)]; (%o1) [notequal(2 z, 2 z - 1), true] (%i2) is (notequal (2*z, 2*z - 1)); (%o2) true
Когда x есть вещественное число - возвращает наибольшее целое, которое меньше или равно x.
Если x есть константное выражение (10 * %pi, например),
floor вычисляет x используя большие числа с плавающей точкой и
применяет floor к результирующему значению.
Из-за того, что floor использует вычисления с числами с плавающей точкой, возможно, хотя маловероятно,
что floor может вернуть ошибочное значение для константных
входных данных. Чтобы застраховаться от ошибок, вычисление с числами с плавающей точкой выполняется,
используя три значения для fpprec.
Для неконстантных входных данных, floor пытается вернуть упрощенное
значение. Вот примеры упрощений, о которых floor
знает:
(%i1) floor (ceiling (x)); (%o1) ceiling(x) (%i2) floor (floor (x)); (%o2) floor(x) (%i3) declare (n, integer)$ (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))]; (%o4) [n, abs(n), min(n, 6)] (%i5) assume (x > 0, x < 1)$ (%i6) floor (x); (%o6) 0 (%i7) tex (floor (a)); $$\left \lfloor a \right \rfloor$$ (%o7) false
Функция floor автоматически не распространяется (map) для списков или матриц.
Наконец, для всех входных данных, которые заданы как комплексные, floor возвращает невычисляемую форму.
Если диапазон функции есть подмножество целых, она может быть
объявлена как integervalued. Обе функции ceiling и floor
могут использовать эту информацию. Например:
(%i1) declare (f, integervalued)$ (%i2) floor (f(x)); (%o2) f(x) (%i3) ceiling (f(x) - 1); (%o3) f(x) - 1
Представляет собой отрицание equal(a, b).
Примеры:
(%i1) equal (a, b); (%o1) equal(a, b) (%i2) maybe (equal (a, b)); (%o2) unknown (%i3) notequal (a, b); (%o3) notequal(a, b) (%i4) not equal (a, b); (%o4) notequal(a, b) (%i5) maybe (notequal (a, b)); (%o5) unknown (%i6) assume (a > b); (%o6) [a > b] (%i7) equal (a, b); (%o7) equal(a, b) (%i8) maybe (equal (a, b)); (%o8) false (%i9) notequal (a, b); (%o9) notequal(a, b) (%i10) maybe (notequal (a, b)); (%o10) true
Как аргумент в вызове к ev (expr),
eval вызывает дополнительное вычисление expr.
См. ev.
Возвращает true если expr есть четное целое.
false возвращается во всех других случаях.
Синоним для entier (x).
Аналогично map, но fullmap продолжает процедуру распространения
для всех подвыражений до тех пор, пока основные операторы более не остаются теми же самыми.
Функция fullmap используется Maxima
упрощателем для некоторых матричных манипуляций. Таким образом, Maxima иногда генерирует
сообщение об ошибке, касающееся fullmap хотя fullmap явно не вызывалась пользователем.
Примеры:
(%i1) a + b * c; (%o1) b c + a (%i2) fullmap (g, %); (%o2) g(b) g(c) + g(a) (%i3) map (g, %th(2)); (%o3) g(b c) + g(a)
Аналогично fullmap, но fullmapl только распространяется на
списки и матрицы.
Пример:
(%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
(%o1) [[a + 3, 4], [4, 3.5]]
Пытается определить, является ли предикат expr
доказуемым из фактов в базе данных assume.
Если этот предикат является доказуемым как true или false,
is возвращает true или false, соответственно.
Иначе, возвращаемое значение управляется глобальным флагом prederror.
Когда prederror есть true,
is выдает сообщение об ошибке.
Иначе, is возвращает unknown.
Выражение ev(expr, pred)
(который можно переписать как expr, pred в интерактивной строке)
эквивалентно is(expr).
См. также assume, facts и maybe.
Примеры:
is вызывает вычисление предикатов.
(%i1) %pi > %e; (%o1) %pi > %e (%i2) is (%pi > %e); (%o2) true
is пытается вывести предикаты из базы данных assume.
(%i1) assume (a > b); (%o1) [a > b] (%i2) assume (b > c); (%o2) [b > c] (%i3) is (a < b); (%o3) false (%i4) is (a > c); (%o4) true (%i5) is (equal (a, c)); (%o5) false
Если is не может доказать или опровергнуть предикат из базы данных assume,
глобальный флаг prederror управляет поведением is.
(%i1) assume (a > b); (%o1) [a > b] (%i2) prederror: true$ (%i3) is (a > 0); Maxima was unable to evaluate the predicate: a > 0 -- an error. Quitting. To debug this try debugmode(true); (%i4) prederror: false$ (%i5) is (a > 0); (%o5) unknown
Пытается определить, является ли предикат expr
доказуемым исходя из фактов в базе данных assume.
Если этот предикат доказуем как true или false,
maybe возвращает true или false, соответственно.
Иначе, maybe возвращает unknown.
maybe функционально эквивалентен is с prederror: false,
но результат вычислен без реального присвоение значения prederror.
См. также assume, facts и is.
Примеры:
(%i1) maybe (x > 0); (%o1) unknown (%i2) assume (x > 1); (%o2) [x > 1] (%i3) maybe (x > 0); (%o3) true
Возвращает "целый квадратный корень" абсолютного значения x, которое есть целое.
Когда L есть список или множество, возвращает apply ('max, args (L)). Когда L не является
списком или множеством, выдает ошибку.
Когда L есть список или множество, возвращает apply ('min, args (L)). Когда L не является
списком или множеством, выдает ошибку.
Возвращает упрощенное значение максимума выражений от x_1 до x_n.
Когда get (trylevel, maxmin) есть 2 или больше, max использует упрощение
max (e, -e) --> |e|. Когда get (trylevel, maxmin) есть 3 или больше, max старается
исключить выражения, заключенные по значению между двумя другими аргументами. Например,
max (x, 2*x, 3*x) --> max (x, 3*x). Для установки значения trylevel в 2, используется
put (trylevel, 2, maxmin).
Возвращает упрощенное значение минимума выражений от x_1 до x_n.
Когда get (trylevel, maxmin) есть 2 или больше, min использует упрощение
min (e, -e) --> -|e|. Когда get (trylevel, maxmin) есть 3 или больше, min старается
исключить выражения, заключенные по значению между двумя другими аргументами. Например,
min (x, 2*x, 3*x) --> min (x, 3*x). Для установки значения trylevel в 2, используется
put (trylevel, 2, maxmin).
Конвертирует многочлен p в модулярное представление,
с учетом текущего модуля, которое является значением переменной
modulus.
polymod (p, m) определяет модуль m, который будет использоваться
вместо текущего значения modulus.
См. modulus.
Если x и y есть вещественные числа и y не отрицательно,
возвращает x - y * floor(x / y).
Далее для всех вещественных x имеем mod (x, 0) = x. Подробное обсуждение
определения mod (x, 0) = x есть в разделе 3.4 "Concrete Mathematics,"
авторов Graham, Knuth и Patashnik. Функция mod (x, 1)
есть пилообразная функция с периодом 1, mod (1, 1) = 0 и
mod (0, 1) = 0.
Чтобы найти главный аргумент (число в интервале (-%pi, %pi]) для комплексного числа,
используется функция x |-> %pi - mod (%pi - x, 2*%pi), где
x есть аргумент.
Когда x и y есть константные выражения (например 10 * %pi), mod
использует то же вычисления с числами с плавающей точкой повышенной точности, что и, floor и ceiling.
Опять же, возможно, хотя маловероятно, что mod может вернуть ошибочное значение в таких случаях.
Для не численных аргументов x или y, mod знает несколько правил упрощения:
(%i1) mod (x, 0); (%o1) x (%i2) mod (a*x, a*y); (%o2) a mod(x, y) (%i3) mod (0, x); (%o3) 0
есть true если expr есть нечетное целое.
false возвращается во всех других случаях.
В качестве аргумента в вызове ev (expr),
pred вызывает вычисление предикатов (выражений, которые вычисляются в true
или false) .
См. ev.
Объект случайного состояния представляет собой состояние генератора случайных чисел. Оно содержит 627 32-битных слова.
make_random_state (n) возвращает новое случайное состояние объекта
созданного из затравочного целого числа, равного n по модулю 2^32.
n может быть отрицательным.
make_random_state (s) возвращает копию случайного состояния s.
make_random_state (true) возвращает новое случайное состояние объекта,
используя текущее значение часов компьютера в качестве затравочного числа.
make_random_state (false) возвращает копию текущего состояния
генератора случайных чисел.
Копирует s в состояние генератора случайных чисел.
set_random_state всегда возвращает done.
Возвращает псевдослучайное число. Если x есть целое, random (x) возвращает
целое в пределах от 0 до x - 1 включительно. Если x есть число с плавающей точкой,
random (x) возвращает неотрицательное число с плавающей точкой меньше чем x.
Функция random выдает сообщение об ошибке, если x не есть целое, или не число с плавающей точкой,
или если x неположительное.
Функции make_random_state и set_random_state
сохраняют состояние генератора случайных чисел.
Генератор случайных чисел Maxima - это реализация Mersenne twister MT 19937.
Примеры:
(%i1) s1: make_random_state (654321)$ (%i2) set_random_state (s1); (%o2) done (%i3) random (1000); (%o3) 768 (%i4) random (9573684); (%o4) 7657880 (%i5) random (2^75); (%o5) 11804491615036831636390 (%i6) s2: make_random_state (false)$ (%i7) random (1.0); (%o7) .2310127244107132 (%i8) random (10.0); (%o8) 4.394553645870825 (%i9) random (100.0); (%o9) 32.28666704056853 (%i10) set_random_state (s2); (%o10) done (%i11) random (1.0); (%o11) .2310127244107132 (%i12) random (10.0); (%o12) 4.394553645870825 (%i13) random (100.0); (%o13) 32.28666704056853
Конвертирует все числа с плавающей точкой двойной точности и повышенной точности в выражении
expr в рациональные эквивалентны. Если вы не знакомы с
бинарным представлением чисел с плавающей точкой, вы может
быть удивлены тем, что rationalize (0.1) не равно 1/10. Это поведение
имеет место не только в Maxima – число 1/10 имеет периодическое, не заканчивающееся,
двоичное представление.
(%i1) rationalize (0.5);
1
(%o1) -
2
(%i2) rationalize (0.1);
1
(%o2) --
10
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0);
209715
(%o4) -------
2097152
(%i5) fpprec : 20$
(%i6) rationalize (0.1b0);
236118324143482260685
(%o6) ----------------------
2361183241434822606848
(%i7) rationalize (sin (0.1*x + 5.6));
x 28
(%o7) sin(-- + --)
10 5
Пример использования:
(%i1) unitfrac(r) := block([uf : [], q],
if not(ratnump(r)) then
error("The input to 'unitfrac' must be a rational number"),
while r # 0 do (
uf : cons(q : 1/ceiling(1/r), uf),
r : r - q),
reverse(uf));
(%o1) unitfrac(r) := block([uf : [], q],
if not ratnump(r) then
error("The input to 'unitfrac' must be a rational number"),
1
while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
1
ceiling(-)
r
reverse(uf))
(%i2) unitfrac (9/10);
1 1 1
(%o2) [-, -, --]
2 3 15
(%i3) apply ("+", %);
9
(%o3) --
10
(%i4) unitfrac (-9/10);
1
(%o4) [- 1, --]
10
(%i5) apply ("+", %);
9
(%o5) - --
10
(%i6) unitfrac (36/37);
1 1 1 1 1
(%o6) [-, -, -, --, ----]
2 3 8 69 6808
(%i7) apply ("+", %);
36
(%o7) --
37
Если x является вещественным числом, то возвращает ближайшее к x
целое. Числа, кратные 1/2, округляются до ближайшего четного целого.
Вычисление x аналогично функциям floor и ceiling.
Пытается определить знак expr
на основе фактов в текущей базе данных. Она возвращает один из
следующих ответов: pos (положительное), neg (отрицательное), zero (нулевое), pz
(положительное или ноль), nz (отрицательное или ноль), pn (положительное или отрицательное),
или pnz (положительное, отрицательное или ноль, т.е. ничего не известно).
Для численного значения x, возвращает 0, если x есть 0, иначе возвращает -1 или +1, когда x меньше чем или больше чем 0, соответственно.
Если x не есть численное значение, то возвращается эквивалентная, но упрощенная форма.
Например, signum(-x) дает -signum(x).
Сортирует список L согласно предикату P двух аргументов,
так чтобы P (L[k], L[k + 1]) было равно true
для любых двух последовательных элементов.
Предикат может быть задан как имя функции или бинарный инфиксный оператор,
или как лямбда-выражение.
Если он задан как имя оператора,
это имя берется в "двойные кавычки".
Отсортированный список возвращается как новый объект;
аргумент L не изменяется.
При возврате значения,
sort делает копию верхнего уровня (shallow copy) элементов L.
Если предикат P не задает полное упорядочивание элементов L,
то sort может пробежать до конца без ошибки,
но результат будет неопределенный.
sort выдает сообщение, если предикат вычисляется до чего-то отличного
от true или false.
sort (L) эквивалентно sort (L, orderlessp).
То есть, порядок сортировки по умолчанию будет восходящим,
как определено для orderlessp.
Все Maxima атомы и выражения сравнимы по orderlessp,
хотя есть отдельные примеры выражений, для которых orderlessp не транзитивна
(это ошибка).
Примеры:
(%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
19 - 3 * x]);
5
(%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
2
(%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
ordergreatp);
5
(%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
2
(%i3) sort ([%pi, 3, 4, %e, %gamma]);
(%o3) [3, 4, %e, %gamma, %pi]
(%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
(%o4) [%gamma, %e, 3, %pi, 4]
(%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
(%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
(%i6) sort (my_list);
(%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
(%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
reverse (b))));
(%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
Квадратный корень x. Внутренне представляется как
x^(1/2). См. также rootscontract.
radexpand, если true, вызовет то, что n-ные корни множителей произведения,
которые есть степени n, будут вынесены за пределы радикала. Например,
sqrt(16*x^2) станет 4*x, только если radexpand есть true.
Значение по умолчанию: true
Когда sqrtdispflag есть false,
то sqrt выводится как степень с показателем 1/2.
Производит множественные параллельные подстановки в выражение.
Переменная sublis_apply_lambda управляет упрощением после
sublis.
Пример:
(%i1) sublis ([a=b, b=a], sin(a) + cos(b)); (%o1) sin(b) + cos(a)
Возвращает список элементов list, для которого
предикат p возвращает true.
Пример:
(%i1) L: [1, 2, 3, 4, 5, 6]; (%o1) [1, 2, 3, 4, 5, 6] (%i2) sublist (L, evenp); (%o2) [2, 4, 6]
Значение по умолчанию: true
Управляет, будет ли подстановки для lambda применены в упрощении,
после того как используется sublis или
нужно ли выполнить ev, чтобы эти элементы применились.
true означает - выполнить применение.
Делает подстановку a для b в c.
b должен быть атомом или полным подвыражением в c. Например, x+y+z есть полное
подвыражение 2*(x+y+z)/w, а x+y нет. Когда b не имеет
эти характеристики, можно иногда использовать substpart или ratsubst
(см. ниже). Альтернативно, если b задано в форме e/f, то можно
использовать subst (a*f, e, c), в то время как, если b задано в форме e^(1/f), то можно
использовать subst (a^f, e, c). subst также различает x^y в x^-y,
так что subst (a, sqrt(x), 1/sqrt(x)) дает 1/a. Аргументы a и b могут также быть
операторами выражения, заключенными в двойные кавычки ", или могут быть именами функций.
Если есть желание подставить независимую переменную в
производных формах, то следует использовать функцию at (см. ниже).
subst - это псевдоним для substitute.
Выражения subst (eq_1, expr) или subst ([eq_1, ..., eq_k], expr)
- есть другие допустимые формы.
eq_i - уравнения, указывающие какие подстановки нужно сделать.
Для каждого уравнения, правая сторона будет подставлена вместо левой в выражении expr.
Если exptsubst равно true, то позволяются подстановки,
на подобии y для %e^x в %e^(a*x).
Когда opsubst есть false,
subst не пытается подставить в оператор выражения.
Например, (opsubst: false, subst (x^2, r, r+r[0])) будет работать.
Примеры:
(%i1) subst (a, x+y, x + (x+y)^2 + y);
2
(%o1) y + x + a
(%i2) subst (-%i, %i, a + b*%i);
(%o2) a - %i b
Чтобы узнать о других примерах, выполните example (subst).
Аналогично substpart, но substinpart работает с
внутренним представление expr.
Примеры:
(%i1) x . 'diff (f(x), x, 2);
2
d
(%o1) x . (--- (f(x)))
2
dx
(%i2) substinpart (d^2, %, 2);
2
(%o2) x . d
(%i3) substinpart (f1, f[1](x + 1), 0);
(%o3) f1(x + 1)
Если последний аргумент функции part есть список индексов, то будут выбраны
несколько подвыражений, каждый из которых будет соответствовать
индексу в списке. Таким образом
(%i1) part (x + y + z, [1, 3]); (%o1) z + x
Переменная piece содержит значение последнего выражения, выбранного при использовании функции part.
Оно устанавливается во время выполнения функции и,
таким образом, может быть передано в саму функцию как показано ниже.
Если partswitch равно true, то end возвращается когда
выбранная часть выражения не существует, иначе
выдается сообщение об ошибке.
(%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
3 2 2 3
(%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1
(%i2) part (expr, 2, [1, 3]);
2
(%o2) 54 y
(%i3) sqrt (piece/54);
(%o3) abs(y)
(%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
3
(%o4) (3 y + 2 x) + y + x + 1
(%i5) expr: 1/x + y/x - 1/z;
1 y 1
(%o5) - - + - + -
z x x
(%i6) substpart (xthru (piece), expr, [2, 3]);
y + 1 1
(%o6) ----- - -
x z
Также, установка опции inflag в true и вызов part или substpart есть
тоже самое, что и вызов inpart или substinpart.
Делает подстановку x в подвыражение,
выбираемое последними аргументами, как в part. Возвращает
новое значение expr. x может быть некоторым оператором для подстановки вместо
оператора в expr. В некоторых случаях x нужно заключать в двойной кавычки "
(Например, substpart ("+", a*b, 0) дает b + a).
(%i1) 1/(x^2 + 2);
1
(%o1) ------
2
x + 2
(%i2) substpart (3/2, %, 2, 1, 2);
1
(%o2) --------
3/2
x + 2
(%i3) a*x + f(b, y);
(%o3) a x + f(b, y)
(%i4) substpart ("+", %, 1, 0);
(%o4) x + f(b, y) + a
Также, установка опции inflag в true и вызов part или substpart, есть
тоже самое, что и вызов inpart или substinpart.
Возвращает true, если expr есть переменная с индексом,
например a[i].
Возвращает true, если expr есть символ, иначе false.
На самом деле, symbolp(x) эквивалентно предикату atom(x) and not numberp(x).
См. также Идентификаторы.
Блокирует связывания, созданные последним вызовом упорядочивающих
команд ordergreat и orderless. ordergreat и orderless не могут
использоваться больше одного раза каждый, без вызова unorder.
См. также ordergreat и orderless.
Примеры:
(%i1) unorder();
(%o1) []
(%i2) b*x + a^2;
2
(%o2) b x + a
(%i3) ordergreat (a);
(%o3) done
(%i4) b*x + a^2;
%th(1) - %th(3);
2
(%o4) a + b x
(%i5) unorder();
2 2
(%o5) a - a
Возвращает векторный потенциал заданного
вектора кручения, в текущей системе координат.
potentialzeroloc имеет аналогичную роль для potential, но порядок
левосторонних частей уравнений должен быть циклической перестановкой
координатных переменных.
Объединяет все члены expr (которое должно быть суммой) для общего знаменателя
без раскрытия произведений и степеней сумм,
что делает ratsimp. Функция xthru сокращает общие множители в числителе и
знаменателе рациональных выражений, но только если эти множители явные.
Иногда лучше использовать xthru перед выражением, упрощенным с помощью ratsimp,
для того чтобы вызывать сокращение явных множителей наибольшего общего делителя
числителя и знаменателя, таким образом, упрощая выражение перед ratsimp.
(%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
20
1 (x + 2) - 2 y x
(%o1) --------- + --------------- - ---------
19 20 20
(y + x) (y + x) (y + x)
(%i2) xthru (%);
20
(x + 2) - y
(%o2) -------------
20
(y + x)
Проверяет эквивалентно ли выражение expr в переменной
v нулю, возвращает true, false или
dontknow.
zeroequiv имеет следующие ограничения:
Например zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x) возвращает
true и zeroequiv (%e^x + x, x) возвращает false.
С другой стороны zeroequiv (log(a*b) - log(a) - log(b), a) возвращает
dontknow из-за присутствия дополнительного параметра b.
Previous: Операторы отношения, Up: Операторы [Contents][Index]