distrib для теорвера
оптимизация
simplexcobyla maxima знает три константы: %phi %pi %e - числа φ, π и e соответственно
арифметические операции :
- + * /
** или ^ sqrt()
(%i2) 3 + 4 ; (%o2) 7 (%i3) _ + 6 ; (%o3) 13
fpprintprec : значащие цифры во флоатах (%i4) fpprintprec : 3 ; (%o4) 3 (%i5) sin ([1.0 , 2.0 , 3.0]) ; (%o5) [0.841, 0.909, 0.141] (%i6)
числовые функции:
fpprintprec : 3 ;
3
float (log (10)) ;
2.3
float (exp (%)) ;
10.0
%pi ^ 2.3 ;
13.9
float (sqrt (5)) ;
2.24
float (cos (2*%pi)) ;
1.0
float (sin (2*%pi)) ;
0.0
float (sinh (2)) ;
3.63
float (cosh (2)) ;
3.76
mod (4,5) ;
4
mod (4,3) ;
1
abs (-7.4) ;
7.4
floor (12.8) ;
12
round (12.8) ;
13
ceiling (12.8) ;
13
комплексные числа записываются в виде a + b * %i. для комплексных чисел есть функции :
realpart imagpartcabscarg polarform rectform conjugate со знака % начинаются все встроенные служебные имена. внутренними именами %phi, %e и %pi обозначены математические постоянные; а через %c с номером обозначаются константы, используемые при интегрировании
команда завершается точкой с запятой ;
вывод результата вычисления можно заглушить, завершив команду символом $ вместо ;
каждая ячейка имеет свою метку - заключенное в скобки имя ячейки. ячейки ввода именуются как %i с номером ( i от input - ввод), ячейки вывода - как %o с соответствующим номером ( o от output - вывод)
мы можем обращаться к любой из предыдущих ячеек по ее имени, подставляя его в любые выражения
последняя ячейка вывода обозначается % без номера, а последняя ячейка ввода - как _ и тоже без номера
знак апострофа ' , введенный перед любым символом или выражением - предотвращает его вычисление
встроенный help : есть специальная функция - describe (name) , которая выдает информацию из документации по конкретным ключевым словам
существует сокращенная версия вызова этой функции: ? name
мы присваиваем значения переменным и в виде значения может выступать любое математическое выражение. делается это с помощью двоеточия :
(%i4) eq : x^3 - x ;
3
(%o4) x - x
если надо вычислить значение выведенного выражения с переменными, то это можно сделать указав либо имя выражения либо номер ячейки, а потом через запятую со знаками равенства - значения переменных
(%i1) f : x*x + 2*x ;
2
(%o1) x + 2 x
(%i2) %o1,x = 4 ;
(%o2) 24
(%i3) g : x * x + 3 * y ;
2
(%o3) 3 y + x
(%i4) %o3,x = 4, y = 1 ;
(%o4) 19
(%i1) A1 : make_array (fixnum, 10);
(%o1) {Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729;
(%o2) 1729
(%i3) A1;
(%o3) {Array: #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10);
(%o4) {Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828;
(%o5) 2.718281828
(%i6) A2;
(%o6) {Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)
read_hashed_array treats the first item on each line as a hash key, and associates the remainder of the line (as a list) with that key. for example, the line
'567 12 17 32 55' is equivalent to
A[567] : [12, 17, 32, 55] $
lines need not have the same numbers of elementsseparator_flag are comma, pipe, semicolon, and spaceseparator_flag is not specified, the file is assumed space-delimitedсписки в максиме - гетерогенные
notation : [item1 , item2 , ... ]
(%i1) mylist_01 : [ 1 , 2 , 3 , 4 , 5] ; (%o1) [1, 2, 3, 4, 5] (%i2) mylist_02 : [ "aaa" , 6.7 ]; (%o2) [aaa, 6.7]
функции для списков :
кроме переменных есть еще и структуры, аргументы которых (поля) идентифицируются именем поля, а сама структура идентифицируется именем структуры
оператор @ обращается по имени к полю и получает значение
оператор new (name) создает новую структуру :
(%i3) defstruct (foo (a, b, c)) ; (%o3) [foo(a, b, c)] (%i4) m : new (foo) ; (%o4) foo(a, b, c) (%i5) defstruct (bar (v, w, x = 123, y = %pi)); (%o5) [bar(v, w, x = 123, y = %pi)] (%i6) structures; (%o6) [foo(a, b, c), bar(v, w, x = 123, y = %pi)] (%i7) kill (foo); (%o7) done (%i8) structures; (%o8) [bar(v, w, x = 123, y = %pi)] (%i9) m@a : 12 (%o9) 12 (%i9) m@a; (%o10) 12
посмотреть все уже присвоенные переменные можно командой values , а все уже определенные функции - командой functions . просмотреть все уже определенные структуры можно командой structures
имя name можно очистить от присвоенного ему выражения и освободить занимаемую этим выражением память. для этого нужно набрать kill (name) . можно очистить разом всю память и освободить все имена, введя kill (all) . можно очистить все переменные командой kill (values) . можно очистить все функции командой kill (functions)
функции чтения файлов с выражениями maxima существует три:
demo(имя-файла)
предназначена для загрузки демо-файлов, задуманных для демонстрационных примеров. она загружает демо-файл и выполняет его в пошаговом режиме, ожидая нажатия Enter после выполнения каждой строки. их расширение - .dem
batch(имя-файла)
загружает maxima-файл и выполняет содержащиеся в нем выражения так, как если бы они вводились прямо в текущей сессии, то есть с отображением результата каждого выражения и назначением меток %iN, %oN
batchload(имя-файла)
подгружает пакетный файл "молча": все назначенные в нем функции и переменные становятся доступны, но результаты не видны, и весь хранимый ввод-вывод, включая значения символов % и _ и результаты, возвращаемые функцией %th(), остается тем же, что и до вызова
комментарии в скриптовых файлах Максимы начинаются с /* и завершаются */ при этом они могут быть многострочными
функция stringout() позволяет выгружать в файл любые выражения и функции maxima в точно таком виде, в каком их загружают функции
demo(), batch() и batchload()
. с ее помощью можно писать выражения, которые вы хотите иметь во внешнем модуле, находясь непосредственно в интерфейсе maxima
stringout() может принимать несколько вариантов аргументов, первым из которых всегда выступает имя файла для записи, а остальные отвечают за то, что же именно будет туда записано
в варианте stringout ("имя-файла", [начало, конец]) записаны будут ячейки ввода с номерами от "начала" до "конца" включительно
с помощью ключевого слова input можно выгрузить в файл все ячейки ввода разом:
stringout ("имя-файла", input)
кроме input , есть еще два ключевых слова: functions и values . первое позволяет записать определения всех функций, второе - присвоение всем символам выражений их текущих значений
функцию stringout() можно вызвать с непосредственным перечислением в аргументах конкретных выражений. в этом случае будут сохраняться не ячейки, содержащие заданные выражения, а именно сами выражения
с именами функций дело обстоит хуже: если просто написать имя функции, то вместо функции будет подставлен одноименный символ (или его значение, если оно задано). но из ситуации есть выход. функция fundef , которая принимает имя любой пользовательской функции и возвращает ее определение в точности в таком же виде, в каком оно было введено в командной строке maxima, с точностью до пробелов
оператор задания функции обозначается через :=
(%i10) func1 (x) := x + 2 ; (%o10) func1(x) := x + 2 (%i11) func1 (12) ; (%o11) 14
язык Максимы - функциональный: вы можете передавать функции, как параметры и возвращать функции как значения. пример - файл "fp.mac":
/* function, which first param is another function */ h (k,a,b,c) := k (a,b,c) $ f (x,y,z) := x + y + z $ /* fun 01 */ g (x,y,z) := x * y * z $ /* fun 02 */ /* function, which first param is expression */ p (k,a,b) := ev (k, x=a,y=b) $ r : x + y $ /* expr 01 */ s : x * y $ /* expr 02 */
(%i51) batchload ("fp.mac");
(%o51) /home/nomad/math/code/maxima/fp.mac
(%i52) p(s,10,20);
(%o52) 200
(%i53) p(r,10,20);
(%o53) 30
(%i54) h(f,2,3,4) ;
(%o54) 9
(%i55) h(g,2,3,4) ;
(%o55) 24функции могут быть длинными :
/* cs - cylinderToSpherical
params : r - dist, a - azimuth, h - height
cs : (r, a, h) -> (p, f, g)
output : p - dist, f - lat, g - long */
cs () := (
p : sqrt (r * r + h * h) ,
f : atan (r / h) ,
g : t ,
j : jacobian ([p, f, g], [r, t, h]) ,
dist : read ("distance : ") ,
azim : read ("azimuth : ") ,
heig : read ("height : ") ,
v : ev (determinant (j) , r = dist , t = azim , h = heig) ,
if is (0 = v) then (print ("singular") , quit (1)) ,
fpprintprec : 4 ,
ret : float (ev (p, r = dist, h = heig)) ,
lat : float (ev (f, r = dist, h = heig)) ,
lng : float (ev (g, t = azim)) ,
display (ret) ,
display (lat) ,
display (lng)
) $ условия >, <, >=, <= записываются и расшифровываются традиционно, так же как и логические операторы and, or, not , а вот о равенствах-неравенствах нужно сказать пару слов
равенство в maxima есть двух видов: синтаксическое и логическое. знаком = обозначается как раз первое, а второе вычисляется с помощью функции equal() . дополнительно используется предикат по имени is , которые проверяет на истинность свой аргумент
ну и неравенств, соответственно, тоже существует два
синтаксическое неравенство обозначается достаточно непривычно - через # ; видимо, этот символ разработчики сочли наиболее визуально схожим со знаком ≠. ну а логическое неравенство обозначено через notequal()
an expression a = b, by itself, represents an unevaluated equation, which might or might not hold. unevaluated equations may appear as arguments to solve and algsys or some other functions
the function is evaluates = to a Boolean value. is(a = b) evaluates a = b to true when a and b are identical. that is, a and b are atoms which are identical, or they are not atoms and their operators are identical and their arguments are identical. otherwise, is(a = b) evaluates to false; it never evaluates to unknown
when is(a = b) is true, a and b are said to be syntactically equal, in contrast to equivalent expressions, for which is(equal(a, b)) is true
expressions can be equivalent and not syntactically equal
if-then-else является не синтаксической конструкцией, а оператором: if условие then выражение1 else выражение2. при выполнении "условия" из двух "выражений" вычисляется только первое и возвращается как результат оператора; в противном случае выполняется только второе и оно же является значением всего выражения if-then-else . часть конструкции else выражение2 - опциональна. если ее нет, а условие все-таки не выполнилось, результат оператора if будет равен false
в условном операторе можно использовать любые предикаты, то есть функции, возвращающие логические значения true/false
/* chess-board cells : x^0, ..., x^7 by y^0, ..., y^7 general polynome , full chess board : (x^0 + ... + x^7) * (y^0 + ... + y^7) grebner basis : (1 + x) , (1 + y) board with cut cell : general polynome - polynome defined by that cell if reminder of [some polynome / grebner_basis_mult] is zero then tiling is possible otherwise tiling is impossible */ f : (1+x+x^2+x^3+x^4+x^5+x^6+x^7) * (1+y+y^2+y^3+y^4+y^5+y^6+y^7) $ g1 : 1 + x $ /* basis element 1 */ g2 : 1 + y $ /* basis element 2 */ g : g1 * g2 $ /* c : 1 + x + y + x*y $ */ is_tiling (c) := is ( 0 = remainder (f - c , g) ) ;
разновидности:
for переменная:начало step шаг thru конец do выражение
for переменная:начало step шаг while условие do выражение
for переменная:начало step шаг unless условие do выражение первая прокручивает цикл, изменяя переменную с заданным шагом от начала до конца
вторая - от начала и пока выполняется условие
третий - от начала и пока условие не выполняется
'шаг' может быть опущен (по умолчанию он равен единице)
опустить позволяется любую часть, кроме do. к примеру, опустив кроме step еще и for, мы получаем традиционные циклы while и unless, а проделав то же самое с первым вариантом, получим цикл без счетчика вида
thru число do выражение
который просто повторится заданное число раз. можно, наоборот, опустить условие окончания и получить цикл с индексной переменной, но бесконечный. а оставив только do, получим самый простой вариант бесконечного цикла. из таких бесконечных циклов можно выйти с помощью оператора return(выражение) (точнее, конечно, конструкции из двух операторов вида if условие then return(выражение)), который прервет выполнение цикла и вместо done вернет заданное выражение. естественно, оператор return() можно применять во всех видах циклов, а не только в бесконечных
кроме всех уже рассмотренных вариаций, цикл может принимать еще две ипостаси
во-первых, вместо step может использоваться конструкция
next выражение
после next может стоять любое вычислимое выражение относительно индекса цикла, и применяться эта конструкция может во всех трех вариантах цикла (thru/while/unless)
а "во-вторых" - это еще один отдельный вариант цикла:
for переменная in список do выражение
либо расширенная форма:
for переменная in список условие do выражение
(%i26) allroots (x^2-3); (%o26) [x = 1.732050807568877, x = - 1.732050807568877] (%i27) for x in %o26 do print (x); x = 1.732050807568877 x = - 1.732050807568877 (%o27) done
цикл будет прокручен с переменной, изменяющейся по всем элементам списка; можно задать еще и дополнительное условие на прерывание цикла
the sin function maps over a list:
(%i1) sin([x,1,1.0]);
(%o1) [sin(x), sin(1), 0.8414709848078965]mod is a function with two arguments which maps over lists. mapping over nested lists is possible too:
(%i1) mod ([x, 11, 2*a] , 10);
(%o1) [mod(x, 10), 1, 2 mod(a, 5)]
(%i2) mod ([[x,y,z] , 11 , 2*a] , 10);
(%o2) [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)] функция пользователя:
(%i5) f (x,y) := x + y ;
(%o5) f(x, y) := x + y
(%i6) f ([x, 11, 2*a] , 10);
(%o6) [x + 10, 21, 2 a + 10] mapping of the floor function over a matrix:
(%i1) floor(matrix([a,b],[c,d]));
[ floor(a) floor(b) ]
(%o1) [ ]
[ floor(c) floor(d) ] ev оператор, обозначенный двумя апострофами, является синонимом к функции ev(выражение). сама функция ev() предоставляет широкие возможности: она может принимать произвольное число аргументов, первый из которых - вычисляемое выражение, а остальные - специальные опции, которые влияют на то, как именно будет производиться вычисление
(%i13) '' 1 + 2 ; (%o13) 3 (%i14) ev(4 + 7) ; (%o14) 11 (%i15) 12 + 78, simp ; (%o15) 90
точно так же, как двойной апостроф - сокращение для ev() без дополнительных опций, есть еще более упрощенная запись функции ev() с опциями: в этом случае вместо имени функции и скобок вообще ничего писать не нужно, т.е ev(выражение,опц1,опц2,…) можно записать просто как "выражение,опц1,опц2,…"
первая из таких опций связана с автоупрощением. глобально автоупрощение регулируется переключателем simp (от simplification), и по умолчанию оно включено; в любой момент его можно выключить, установив значение переключателя simp:false . опция функции ev , одноименная этому переключателю, позволяет включить упрощение для данного конкретного вычисления - вне зависимости от того, включено или выключено оно глобально
rat функция rat(выражение) преобразовывает рациональное выражение к канонической форме (Canonical Rational Expression, CRE), то есть раскрывает все скобки, затем приводит все к общему знаменателю, суммирует и сокращает; кроме того, приводит все числа в конечной десятичной записи к рациональным
это удобно, если вам нужно пошагово проделать большое количество рациональных преобразований: вы можете, один раз вызвав rat() , ссылаться на предыдущие ячейки и далее видеть на каждом шаге итоговое выражение в канонической форме. если на каком-то этапе такое поведение станет вам мешать, вы можете вернуть выражение из канонической к общей форме с помощью функции ratdisrep(выражение)
каноническая форма автоматически отменяется и в случае любых преобразований, не являющихся рациональными
ratsimp (expr, x_1,..,x_n) enables rational simplification with the specification of variable ordering as in ratvarsratsimpexpons is true, ratsimp is applied to the exponents of expressions during simplification expand examples :
(%i1) expr:(x+1)^2*(y+1)^3;
2 3
(%o1) (x + 1) (y + 1)
(%i2) expand(expr);
2 3 3 3 2 2 2 2 2
(%o2) x y + 2 x y + y + 3 x y + 6 x y + 3 y + 3 x y
2
+ 6 x y + 3 y + x + 2 x + 1
(%i3) expand(expr,2);
2 3 3 3
(%o3) x (y + 1) + 2 x (y + 1) + (y + 1)
(%i4) expr:(x+1)^-2*(y+1)^3;
3
(y + 1)
(%o4) --------
2
(x + 1)
(%i5) expand(expr);
3 2
y 3 y 3 y 1
(%o5) ------------ + ------------ + ------------ + ------------
2 2 2 2
x + 2 x + 1 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1
(%i6) expand(expr,2,2);
3
(y + 1)
(%o6) ------------
2
x + 2 x + 1
log10(x) := log(x) / log(10) is a useful definition
cons can also be used where the second argument is other than a list and this might be useful. in this case, cons (expr_1, expr_2) returns an expression with same operator as expr_2 but with argument cons(expr_1, args(expr_2))(%i1) cons(a,[b,c,d]); (%o1) [a, b, c, d] (%i2) cons(a,f(b,c,d)); (%o2) f(a, b, c, d)
(%i1) load (functs) $
(%i2) arithsum (1,1,3) ;
(%o2) 6
(%i3) geosum (1,0.5,inf) ;
(%o3) 2.0
(%i4) geosum (1,0.9,inf) ;
(%o4) 10.0(%i12) 5!; (%o12) 120 (%i13) factorial (7) ; (%o13) 5040
(%i9) binomial (6,3) ; (%o9) 20
(%i4) eq: x^3 - x ;
3
(%o4) x - x
(%i16) solve(eq) ;
(%o16) [x = - 1, x = 1, x = 0]
(%i4) eq : x^3 - x ;
3
(%o4) x - x
(%i18) diff (eq, x) ;
2
(%o18) 3 x - 1
функция diff принимает один либо два аргумента. с двумя, diff(выражение, переменная) , она возвращает производную от "выражения" по заданной переменной; с одним, diff(выражение) - полный дифференциал заданного выражения. запись diff(f, x) равнозначна математическому обозначению df/dx, а diff(f) равнозначна df
функция интегрирования называется integrate и имеет два варианта вызова: для нахождения неопределенного и определенного интегралов
первый выглядит как integrate (выражение, переменная)
второй - как integrate (выражение, переменная, нижний-предел, верхний-предел)
(%i26) integrate (sin(x),x,a,b) ; (%o26) cos(a) - cos(b) (%i27) integrate (1/(sqrt(x)), x, 0, 1) ; (%o27) 2
кроме определенных интегралов maxima умеет искать также и несобственные интегралы, то есть такие, у которых неограничена либо область интегрирования, либо подынтегральная функция; и делается это все той же функцией integrate
f : (1 + x^2) / (1 + x^4) ; integrate (f, x, minf, inf) ;
полноценных функций для нахождения предела существует в maxima аж одна, но зато какая!
она может принимать три различных варианта списка аргументов, и кроме того, на ее действие влияют еще и три флага. зовут эту функцию limit и в самом стандартном варианте ее вызов выглядит как
limit (выражение, переменная, точка)
(%i29) limit ((x^2 - 1) / (2*x^2-x-1) , x , 1) ;
2
(%o29) -
3 maxima может искать пределы не только в конечных точках, но и на бесконечности. среди стандартных обозначений программы существуют универсальные названия для разных бесконечностей:
inf (от слова infinity) minf (от minus infinity) infinityвторой вариант вызова функции limit() - это расширенная версия первого:
limit(выражение, переменная, точка, направление)
для поиска односторонних пределов. для предела справа в качестве "направления" указывается plus, для предела слева - minus
кроме упомянутых выше бесконечностей, на выходе возможно появление и еще двух обозначений, на случай, если заданный предел не существует:
ind
(от слова indefinite - неопределенный)
und
(от слова undefined - опять же неопределенный)функция limit() в третьем варианте :
limit(выражение)
предназначена уже не для поиска собственно пределов, а для упрощения выражений, содержащих символы inf и minf
(%i35) limit(1/inf) ; (%o35) 0
(%i1) divide (X^4 + X^2 - 3, X^2 + 1) ;
2
(%o1) [X , - 3]
(%i2) expand ((x + y)^3) ;
3 2 2 3
(%o2) y + 3 x y + 3 x y + x
(%i3) ratcoeff ((z + 1)^2 * (t + y)^2 , t^2) ;
2
(%o3) z + 2 z + 1
(%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
2 2 1
(%o1) ----- - ----- + --------
x + 2 x + 1 2
(x + 1)
(%i2) ratsimp (%);
x
(%o2) - -------------------
3 2
x + 4 x + 5 x + 2
(%i3) partfrac (%, x);
2 2 1
(%o3) ----- - ----- + --------
x + 2 x + 1 2
(x + 1)
(%i1) divide (x + y, x - y, x); (%o1) [1, 2 y] (%i2) divide (x + y, x - y); (%o2) [- 1, 2 x]
package distrib contains a set of functions for making probability computations on both discrete and continuous univariate models
there is a naming convention in package distrib. Every function name has two parts, the first one makes reference to the function or parameter we want to calculate,
functions:
density function pdf_
distribution function cdf_
quantile quantile_
mean mean_
variance var_
standard deviation std_
skewness coefficient skewness_
kurtosis coefficient kurtosis_
random variate random_
the second part is an explicit reference to the probabilistic model,
continuous distributions:
normal *normal
student *student_t
chi^2 *chi2
noncentral Chi^2 *noncentral_chi2
f *f
exponential *exp
lognormal *lognormal
gamma *gamma
beta *beta
continuous uniform *continuous_uniform
logistic *logistic
pareto *pareto
weibull *weibull
rayleigh *rayleigh
laplace *laplace
cauchy *cauchy
gumbel *gumbel
discrete distributions:
binomial *binomial
poisson *poisson
bernoulli *bernoulli
geometric *geometric
discrete uniform *discrete_uniform
hypergeometric *hypergeometric
negative binomial *negative_binomial
finite discrete *general_finite_discrete
(%i1) load (distrib)$
(%i2) pdf_general_finite_discrete(2, [1/7, 4/7, 2/7]);
4
(%o2) -
7
(%i3) pdf_general_finite_discrete(2, [1, 4, 2]);
4
(%o3) -
7
(%i1) load (distrib)$
(%i2) cdf_general_finite_discrete(2, [1/7, 4/7, 2/7]);
5
(%o2) -
7
(%i3) cdf_general_finite_discrete(2, [1, 4, 2]);
5
(%o3) -
7
(%i4) cdf_general_finite_discrete(2+1/2, [1, 4, 2]);
5
(%o4) -
7
(%i1) load (distrib)$
(%i2) random_general_finite_discrete([1,3,1,5]);
(%o2) 4
(%i3) random_general_finite_discrete([1,3,1,5], 10);
(%o3) [4, 2, 2, 3, 2, 4, 4, 1, 2, 2]точкой . обозначается матричное произведение
(%i5) a : [1,2,3] ; (%o5) [1, 2, 3] (%i6) a . a ; (%o6) 14
обращение к элементу матрицы x осуществляется как x[i,j]
(%i37) M : matrix ([1,2],[3,4]);
[ 1 2 ]
(%o37) [ ]
[ 3 4 ]
array) or an undeclared array, or an array function, or a lambda expression of two arguments (an array function is created like other functions with :=, but arguments are enclosed in square brackets instead of parentheses) eivals is a synonym for eigenvalueseivects is a synonym for eigenvectors
(%i37) M : matrix ([1,2],[3,4]) $
(%i38) K : triangularize (M);
[ 1 2 ]
(%o38) [ ]
[ 0 - 2 ]
load(diag)dispJordan using the output of jordan as the argumentdispJordan using the output of jordan as the argument
(%i1) toeplitz ([1,2,3] , [x,y,z]) ;
[ 1 y z ]
[ ]
(%o1) [ 2 1 y ]
[ ]
[ 3 2 1 ]
(%i2) toeplitz ([1 , 1+%i]) ;
[ 1 1 - %I ]
(%o2) [ ]
[ %I + 1 1 ]
(%i6) laplace (0,t,s) ;
(%o6) 0
(%i7) laplace (1,t,s) ;
1
(%o7) -
s
(%i8) laplace (t,t,s) ;
1
(%o8) --
2
s
(%i9) laplace (exp(t),t,s) ;
1
(%o9) -----
s - 1
(%i10) laplace (cos(t),t,s) ;
s
(%o10) ------
2
s + 1
(%i11) laplace (sin(t),t,s) ;
1
(%o11) ------
2
s + 1
(%i12) laplace (exp(t)*sin(t),t,s) ;
1
(%o12) ------------
2
s - 2 s + 2
(%i13) laplace (exp(t)*cos(t),t,s) ;
s - 1
(%o13) ------------
2
s - 2 s + 2
(%i15) ilt (1/s^2,s,t) ;
(%o15) t
(%i16) ilt (1/(s-1),s,t) ;
t
(%o16) %e
(%i1) load (fft) $
(%i2) fpprintprec : 4 $
(%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
(%i4) L1 : fft (L) ;
(%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0,
.3107 %i + .6036, 0.0, 1.811 %i - .1036]
(%i5) L2 : inverse_fft (L1) ;
(%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0,
4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0,
- 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0]
(%i6) lmax (abs (L2 - L)) ;
(%o6) 3.545L-16
the vector analysis package vect can combine and simplify symbolic expressions including dot products and cross products, together with the gradient, divergence, curl, and Laplacian operators. The distribution of these operators over sums or products is governed by several flags, as are various other expansions, including expansion into components in any specific orthogonal coordinate systems. There are also functions for deriving the scalar or vector potential of a field
для использвания операции векторного произведения ~ надо загрузить модуль vect :
load (vect) $
[x,y,z] ~ [x1,y1,z1] $
express (%) ;
[y z1 − y1 z, x1 z − x z1, x y1 − x1 y]so now you can
a ;
[1, 2, 3]
b ;
[- 2, 4, 1]
a ~ b;
- [- 2, 4, 1] ~ [1, 2, 3]
express(%) ;
[- 10, - 7, 8]expandall, expanddot, expanddotplus, expandcross, expandcrossplus, expandcrosscross, expandgrad, expandgradplus, expandgradprod, expanddiv, expanddivplus, expanddivprod, expandcurl, expandcurlplus, expandcurlcurl, expandlaplacian, expandlaplacianplus, expandlaplacianprodthe vect package is designed for working with vector dot (as .) and cross (as ~) products, and so redefines "." as the vector dot-product. the documentation does warn explicitly:
"Warning: The VECT package declares "." to be a commutative operator"and if you need both the vector simplifications defined by
vect and normal matrix functionality, you are out of luck
there are (at least) three ways of looking at tensors
first, one can think of a tensor in terms of its representation, i.e., a column or row vector, a matrix, an array of matrices, etc. the rules of tensor manipulation are then just the rules of matrix multiplication. this view of tensors through a specific representation can be very useful when one works in a specific coordinate system
second, one can think of a tensor in terms of the algebraic rules of matrix manipulation, without picking a specific representation. for instance, if two tensors are a row vector a_\mu\ and a column vector b^\mu\, than their scalar product is sum a_\mu b^\mu\ and the resulting number will be the same regardless of the choice of coordinate system. i.e., (a_\mu b^\mu\ (where dropped the summation sign in accordance with the Einstein summation convention) is a well defined scalar quantity even when you don’t specify a coordinate system and a specific representation of a_\mu \ and b^\mu\. the rules of tensor manipulation then boil down (largely) to an algebra of tensor indices and summation rules
third, you can do away with indices and components altogether, and focus on the purely algebraic properties of tensors. tensors form a noncommutative group under multiplication, but this group is reducible and there are sets of tensors that can be used to represent many associative algebras. the generators and commutation rules of an algebra are sufficient to fully define that algebra; this algebraic view is another way of thinking about tensors
these three views of tensors are implemented in Maxima by three add-on packages:
ctensor does component tensor manipulation
itensor is the indicial tensor manipulation
atensor stands for algebraic tensor manipulation
simplex is a package for linear optimization using the simplex algorithm
(%i1) load(simplex)$
(%i2) minimize_lp(x+y, [3*x+2*y>2, x+4*y>3]);
9 7 1
(%o2) [--, [y = --, x = -]]
10 10 5
(%i2) A: matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0])$
(%i3) b: [1,1,6]$
(%i4) c: [1,-2,0,0]$
(%i5) linear_program(A, b, c);
13 19 3
(%o5) [[--, 4, --, 0], - -]
2 2 2
load (simplex) $
/*
компания должна произвести за следующий календарный месяц как минимум (L):
50 коробок и 120 мешков
компания не может произвести за месяц более (U):
250 пакетов
у компании три фабрики: 1 2 3 ;
каждая фабрика может работать не более, чем 24 дня в месяц, но и не менее 12 дней
ежедневная производительность фабрики 1 : 2 коробки, 4 мешка и 6 пакетов
" 2 : 1 коробка, 3 мешка и 5 пакетов
" 3 : 3 коробки, 2 мешка и 4 пакета
полные ежедневные затраты 1 : $100
" 2 : $75
" 3 : $70
*/
minimize_lp ( 100.0 * x1 + 75.0 * x2 + 70.0 * x3 ,
[ 2 * x1 + 1 * x2 + 3 * x3 > 50.0
, 4 * x1 + 3 * x2 + 2 * x3 > 120.0
, 3 * x1 + 2 * x2 + 4 * x3 < 250.0
, x1 > 12 , x2 > 12 , x3 > 12
, x1 < 24 , x2 < 24 , x3 < 24
] , nonegative_lp=true
);
fmin_cobyla package minimizes an objective function F(X) subject to inequality constraints of the form
load (fmin_cobyla) $
fmin_cobyla (100*x1 + 75*x2 + 70*x3, [x1, x2, x3], [15,15,15],
constraints =
[ 2 * x1 + 1 * x2 + 3 * x3 >= 50.0
, 4 * x1 + 3 * x2 + 2 * x3 >= 120.0
, 3 * x1 + 2 * x2 + 4 * x3 <= 250.0
, x1 >= 12 , x2 >= 12 , x3 >= 12
, x1 <= 24 , x2 <= 24 , x3 <= 24
], iprint=1
) ;
/* min. r' * Q * r + r' * q
s.t. r <= ub, r >= lb
*/
Q : 0.5 * matrix ([2.4, 0, 1], [0, 0, 0.9], [1, 0.9, 0]) $
q : [0, -8, 0] $
r : [r1, r2, r3] $
S : r . Q . transpose(r) + q . transpose(r) $
load (fmin_cobyla) $
fmin_cobyla (S, [r1, r2, r3], [5, 5, 5] ,
constraints = [ r1 >= 1 , r1 <= 10
, r2 >= 1 , r2 <= 10
, r3 >= 1 , r3 <= 10
] ,
iprint = 0) ;
комментарии в скриптовых файлах Максимы начинаются с /* и завершаются */ при этом они могут быть многострочными
* * *
в файл записывается тело скрипта :
critpts () := (
print ("program to find critical points") ,
/* asks for a function */
f : read ("enter f (x , y) ") ,
/* echoes it , to make sure */
print ("f = " , f) ,
/* produces a list with the two partial derivs */
eqs : [ diff (f , x) , diff (f , y) ] ,
/* produces a list of unknowns */
uns : [x , y] ,
/* solves the system */
solve (eqs , uns)
) $ затем в repl этот скрипт загружается командой :
batch ("nameOfScriptFile") $ если скрипт не требует интерактивного режима, то все может быть выполнено из оболочки ОС с ключом :
$> maxima -q -b srciptname функции - для чтения и для вывода:
k : read ("enter your num ") ;
print (k) ;
display (k1,k2,...) ;
disp (k1,k2,...) ;
ldisp (k1,k2,...) ; с присваиванием метки каждому аргументу
ldisplay (k1,k2,...) ;
Lisp code may be executed from within a Maxima session. a single line of Lisp (containing one or more forms) may be executed by the special command :lisp. for example,
(%i1) :lisp (foo $x $y) calls the Lisp function foo with Maxima variables x and y as arguments. the :lisp construct can appear at the interactive prompt or in a file processed by batch or demo, but not in a file processed by load, batchload, translate_file, or compile_file
The function to_lisp opens an interactive Lisp session. entering (to-maxima) closes the Lisp session and returns to Maxima
:lisp (sleep 30) ;
основных функций всего две - plot2d и plot3d. возможности графической отрисовки не встроены в maxima, а реализованы посредством внешних программ, в чем и прослеживается пресловутый Unix-way: "одна задача - одна программа". по умолчанию, построением графиков занимается gnuplot
plot2dкороткий вариант ее вызова такой:
plot2d (выражение, [символ, начало, конец])
где выражение задает функцию, график которой нужно построить, символ - неизвестное (он, понятное дело, должен быть единственным неопределенным символом, входящим в выражение), а начало и конец задают отрезок оси Х для построения графика; участок по оси Y в таком варианте записи выбирается автоматически, исходя из минимума и Максимума функции на заданном промежутке
обратите внимание, что неизвестное и концы промежутка нужно задавать не тремя отдельными параметрами, как, скажем, в integrate, а в виде списка. это связано с тем, что plot2d может принимать еще и дополнительные аргументы - в таком случае они перечисляются следом за таким списком, что исключает всякую путаницу
(%i38) plot2d (x*cos(x), [x, -2*%pi, 2*%pi]) $
после вызова функции plot2d в таком варианте откроется окно gnuplot, в котором будет отображен график. окно с графиком можно закрыть клавишей Q
в некоторых случаях автоматический подбор отображаемого участка вертикальной оси может нас не устроить. например, он работает не очень хорошо, если функция имеет на заданном промежутке точку разрыва, хотя бы один из односторонних пределов в которой равен бесконечности: тогда промежуток по оси Y будет выбран слишком большим
для этого предусмотрен такой вариант вызова функции:
plot2d (выражение, [символ, начало, конец], [y, начало, конец])
здесь буква y используется в качестве обозначения вертикальной оси, а остальные два параметра имеют тот же смысл, что и выше
чтобы построить на одной и той же картинке одновременно два графика (или больше), просто передайте функции plot2d вместо отдельного выражения их список
функция plot2d понимает еще одно ключевое слово: discrete. предназначено оно для отображения на плоскости дискретных множеств; точнее говоря, конечных наборов точек. по записи аргументов такой вариант распадается еще на два:
plot2d ([discrete, x-список, y-список]) plot2d ([discrete, [x, y]-список])
в первом варианте координаты задаются как два отдельных списка
[x1, x2, …, xn], [y1, y2, ,…, yn]
а во втором - как список пар координат отдельных точек
[[x1, y1], [x2, y2], …, [xn, yn]]
если мы, к примеру, имеем набор статистических значений, зависящих от номера, мы можем отобразить его, задав в качестве x-координат сами эти номера
plot3d имеет два варианта вызова: один для явного задания функции и один для параметрического. в обоих случаях функция принимает три аргумента. для явно заданной функции:
plot3d (выражение, [переменная1, начало, конец], [переменная2, начало, конец])аргументы аналогичны plot2d, с той разницей, что здесь независимых переменных две