система символьной математики (computer algebra system)


  • repl
  • переменные
  • списки
  • массивы
  • хеши
  • структуры
  • опция fpprintprec : значащие цифры во флоатах
  • вычисление выражения
  • преобразование выражения к рациональной форме
  • расширение выражений
  • функциональный стиль
  • файлы
  • комбинаторика
  • решение уравнений
  • дифференцирование
  • интегрирование
  • пределы
  • полиномы
  • пакет distrib для теорвера
    1. functions for continuous distributions
    2. functions for descrete distributions
  • матрицы
  • функции, опции и пакеты для матриц
  • функции, опции и пакеты для линейной алгебры
  • преобразования Лапласа
  • преобразования Фурье
  • функции Бесселя
  • векторный анализ
  • тензоры
    1. пакет ctensor
    2. пакет itensor
    3. пакет atensor
  • линейное программирование
    1. скрипты
    2. функции пользователя
    3. комментарии
    4. терминал
    5. встроенный lisp

  • графики

  • maxima производит численные расчеты, используя точные дроби, целые числа и числа с плавающей точкой произвольной точности

    maxima знает три константы: %phi %e %pi

    числовые функции:

     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 , imagpart , cabs , carg , polarform , rectform , conjugate


    repl

    команда завершается точкой с запятой. вывод результата вычисления можно заглушить, завершив команду символом $ вместо ;

    -   +   *   /   ** или ^   sqrt()

    (%i2) 3 + 4 ;
    (%o2)                                  7
    (%i3) _ + 6 ;
    (%o3)                                 13
    

    каждая ячейка имеет свою метку — заключенное в скобки имя ячейки. ячейки ввода именуются как %i с номером (i от input — ввод), ячейки вывода — как %o с соответствующим номером (o от output — вывод). со знака % начинаются все встроенные служебные имена. внутренними именами %phi, %e и %pi обозначены математические постоянные; а через %c с номером обозначаются константы, используемые при интегрировании

    мы можем обращаться к любой из предыдущих ячеек по ее имени, подставляя его в любые выражения. последняя ячейка вывода обозначается % , а последняя ячейка ввода _

    встроенный 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
    
    (%i6) f,x=1,y=2,z=3;
    (%o6)                                - 13
    (%i7) %i1,x=1,y=2,z=3 ;
    (%o7)                                - 13
    

    посмотреть все уже присвоенные переменные можно командой values ;, а все уже определенные функции - командой functions ;

    имя name можно очистить от присвоенного ему выражения и освободить занимаемую этим выражением память. для этого нужно набрать kill (name) . можно очистить разом всю память и освободить все имена, введя kill (all) . можно очистить все переменные командой kill (values) . можно очистить все функции командой kill (functions) ;

    списки

    lists are the basic building block for Maxima. all data types other than arrays, hash tables and numbers are represented as lists

    функции:

      cons (expr, list)
      endcons (expr, list)
      copylist (list)
      delete (expr, list)
    
      first (list)
          functions 'second' ... 'tenth' yield the second through the tenth part of their argument
      last (list)
    
      length (list)
      listp (expr) returns 'true' if expr is a list else 'false'
      member (expr, list) returns 'true' or 'false'
    
      pop (list) removes and returns the first element from the list 
      push (item, list) prepends the item item to the list and returns a copy of the new list
    
      reverse (list)
    
      sort (list)
      sort (list, p)
        the predicate may be specified as the name of a function
        or binary infix operator, or as a 'lambda' expression
      unique (list)
    
      sublist (list, p)
         returns the list of elements of list for which the predicate 'p' returns 'true'
    

    массивы

              (%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
              read_hashed_array (S, A)
              read_hashed_array (S, A, separator_flag)
    
    Reads the source S and returns its entire content as a hashed array A
    The source S may be a file name or a stream
    
    '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 the 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 elements
    the recognized values of separator_flag are 'comma', 'pipe', 'semicolon', and 'space'
    if separator_flag is not specified, the file is assumed space-delimited
    

    структуры

    кроме переменных есть еще и структуры, аргументы которых (поля) идентифицируются именем поля, а сама структура идентифицируется именем структуры. оператор @ обращается по имени к полю и получает значение. оператор 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

    знак апострофа введенный перед любым символом или выражением предотвращает его вычисление


    FP стиль

         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 and an equation:
    
         (%i1) floor(matrix([a,b],[c,d]));
                              [ floor(a)  floor(b) ]
         (%o1)                [                    ]
                              [ floor(c)  floor(d) ]    
    


    опция fpprintprec : значащие цифры во флоатах

    (%i4) fpprintprec : 3 ;
    (%o4)                                  3
    (%i5) sin ([1.0 , 2.0 , 3.0]) ;
    (%o5)                        [0.841, 0.909, 0.141]
    (%i6)   
    

    функция 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(выражение)

    каноническая форма автоматически отменяется и в случае любых преобразований, не являющихся рациональными

    функция expand

    expand (expr)
    expand (expr, p, n)
    expand expression "expr". products of sums and exponentiated sums are multiplied out, numerators of rational expressions which are sums are split into their respective terms, and multiplication (commutative and non-commutative) are distributed over addition at all levels of "expr"
    for polynomials one should usually use 'ratexpand' which uses a more efficient algorithm

    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    
      

    файлы

    чтение

    функции чтения файлов с выражениями 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, с точностью до пробелов


    разные полезные функции

    cons (expr, list)
    cons (expr_1, expr_2)
    returns a new list constructed of the element expr as its first element, followed by the elements of list. this is analogous to the Lisp language construction operation "cons"
    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))
    example:
              (%i1) cons(a,[b,c,d]);
              (%o1)                     [a, b, c, d]
              (%i2) cons(a,f(b,c,d));
              (%o2)                     f(a, b, c, d)
    in general, cons applied to a nonlist doesn't make sense
    exponentialize(cos(x));
    exponentialize(tanh(x));
    taylor (cos(x), x, 0, 5) ;
    taylor (log(x), x, 1, 4) ;

    комбинаторика

    factorial (x) or x!
    (%i12) 5!;
    (%o12)                                120  
    (%i13) factorial (7) ;
    (%o13)                               5040
    
    binomial (x , y)
    (%i9) binomial (6,3) ;
    (%o9)                                 20  
    

    решение уравнений

    solve (expr)
    solve (expr, x)
    solve ([expr1, ..., eqxpn], [x1, ..., xn])

    решает уравнение expr для переменной x, которое может быть опущено, если х - единственная переменная в уравенении

    (%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


    пределы

    полноценных функций для нахождения предела существует в 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
    
      

    factor (expr)
    gfactor (expr)
    разлагает полином на простейшие

    allroots (expr)
    находит корни полинома

    partfrac (expr, var)
    expands the expression expr in partial fractions with respect to the main variable var . it does a complete partial fraction decomposition
              (%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)
          
    divide (p_1, p_2, x_1, ..., x_n)
    computes the quotient and remainder of the polynomial p_1 divided by the polynomial p_2, in a main polynomial variable, x_n. the result is a list whose first element is the quotient and whose second element is the remainder
              (%i1) divide (x + y, x - y, x);
              (%o1)                       [1, 2 y]
    
              (%i2) divide (x + y, x - y);
              (%o2)                      [- 1, 2 x]

    quotient (p_1, p_2)
    quotient (p_1, p_2, x_1, ..., x_n)
    returns the polynomial p_1 divided by the polynomial p_2. it returns the first element of the two-element list returned by divide

    remainder (p_1, p_2)
    remainder (p_1, p_2, x_1, ..., x_n)
    returns the remainder of the polynomial p_1 divided by the polynomial p_2. it returns the second element of the two-element list returned by divide


    functions for continuous distributions

    pdf_normal (x,m,s)
    returns the value at x of the density function of a Normal(m,s) random variable, with s>0
    cdf_normal (x,m,s)
    returns the value at x of the distribution function of a Normal(m,s) random variable, with s>0
    quantile_normal (q,m,s)
    returns the q-quantile of a Normal(m,s) random variable, with s>0; q must be an element of [0,1]
    random_normal (m,s)
    random_normal (m,s,n)
    returns a Normal(m,s) random variate, with s>0. calling random_normal with a third argument n, a random sample of size n will be simulated
    pdf_continuous_uniform (x,a,b)
    returns the value at x of the density function of a Continuous Uniform(a,b) random variable, with a < b
    cdf_continuous_uniform (x,a,b)
    returns the value at x of the distribution function of a Continuous Uniform(a,b) random variable, with a < b
    quantile_continuous_uniform (q,a,b)
    returns the q-quantile of a Continuous Uniform(a,b) random variable, with a < b ; q must be an element of [0,1]

    functions for descrete distributions

    TODO

    матричные вычисления

    точкой . обозначается матричное произведение

    (%i5) a : [1,2,3] ;
    (%o5)                              [1, 2, 3]
    (%i6) a . a ;
    (%o6)                                 14
    

    обращение к элементу матрицы x осуществляется как x[i,j]

    создание матриц

    read_matrix ("/path/to/the/text.file")
    returns matrix with lines from the file as its rows
    entermatrix (m, n)
    returns an m by n matrix, reading the elements interactively
    matrix (row_1, …, row_n)
    returns a rectangular matrix which has the rows row_1, …, row_n each row is a list of expressions all rows must be the same length
    (%i37) M : matrix ([1,2],[3,4]);
                                       [ 1  2 ]
    (%o37)                             [      ]
                                       [ 3  4 ]
    

    copymatrix (M)
    returns a copy of the matrix M
    ident (n)
    returns an n by n identity matrix
    zeromatrix (m, n)
    returns an m by n matrix, all elements of which are zero
    diag_matrix (d, d2, ..., dn)
    return a diagonal matrix with diagonal entries d1, d2, ..., dn
    ematrix (m, n, x, i, j)
    returns an m-by-n matrix, all elements of which are zero except for the '[i, j]' element which is x
    genmatrix
    genmatrix (<a>, <i_2>, <j_2>, <i_1>, <j_1>)
    genmatrix (<a>, <i_2>, <j_2>, <i_1>)
    genmatrix (<a>, <i_2>, <j_2>)
    returns a matrix generated from <a>, taking element '<a>[<i_1>, <j_1>]' as the upper-left element and '<a>[<i_2>, <j_2>]' as the lower-right element of the matrix here <a> is a declared array (created by '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)
    if <j_1> is omitted, it is assumed equal to <i_1> if both <j_1> and <i_1> are omitted, both are assumed equal to 1 if a selected element 'i,j' of the array is undefined, the matrix will contain a symbolic element '<a>[i,j]'

    матричные операции

    transpose (M)
    returns the transpose of M
    invert (M)
    returns the inverse of the matrix M

    матричные параметры

    rank (M)
    computes the rank of the matrix M
    determinant (M)
    computes the determinant of M
    mat_trace (M)
    returns the trace of the square matrix M
    eigenvalues (M) eivals (M)
    returns a list of two lists containing the eigenvalues of the matrix M the first sublist of the return value is the list of eigenvalues of the matrix, and the second sublist is the list of the multiplicities of the eigenvalues in the corresponding order 'eivals' is a synonym for 'eigenvalues'
    eigenvectors (M) eivects (M)
    computes eigenvectors of the matrix M the return value is a list of two elements the first is a list of the eigenvalues of M and a list of the multiplicities of the eigenvalues the second is a list of lists of eigenvectors there is one list of eigenvectors for each eigenvalue there may be one or more eigenvectors in each list 'eivects' is a synonym for 'eigenvectors'
    (%i37) M : matrix ([1,2],[3,4]) $
    (%i38) K : triangularize (M);
                                      [ 1   2  ]
    (%o38)                            [        ]
                                      [ 0  - 2 ]
    

    специальные матрицы

    jordan (mat)

    to use this function write first load("diag")

    returns the Jordan form of matrix mat, encoded as a list in a particular format
    to get the corresponding matrix, call the function dispJordan using the output of jordan as the argument

    the elements of the returned list are themselves lists
    the first element of each is an eigenvalue of mat
    the remaining elements are positive integers which are the lengths of the Jordan blocks for this eigenvalue. these integers are listed in decreasing order
    eigenvalues are not repeated

    to get the corresponding matrix, call the function 'dispJordan' using the output of 'jordan' as the argument

    vandermonde_matrix ([x1, ..., xn])
    return n-by-n matrix whose i-th row is [1, xi, xi^2, ... xi^(n-1)]
    jacobian ([f], [x])
    returns the Jacobian matrix of the list of functions f with respect to the list of variables x the (i,j)-th element of the Jacobian matrix is diff (f[i], x[j])
    hessian (f, [x])
    returns the Hessian matrix of f with respect to the list of variables x the (i,j)-th element of the Hessian matrix is diff (f, x[i], 1, x[j], 1)
    toeplitz (<col>)
    toeplitz (<col>, <row>)
    return a Toeplitz matrix. the first first column of it is 'col' except for the first entry, the first row of it is 'row' the default for 'row' is complex conjugate of 'col'
              (%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    ]
    
    

    столбцы и строки

    col (M, i)
    returns the i'th column of the matrix M
    row (M, i)
    returns the i'th row of the matrix M
    submatrix (i1 , ..., im , M , j1 , ... , jn) submatrix (i1 , ..., im , M) submatrix (M, j1 , ... , jn)
    returns a new matrix composed of the matrix M with rows i1, ..., im deleted, and columns j1, ..., jn deleted
    addrow (M, list_1, …, list_n)
    appends the row(s) given by the one or more lists (or matrices) onto the matrix M
    addcol (M, list_1, …, list_n)
    appends the column(s) given by the one or more lists (or matrices) onto the matrix M


    преобразования Лапласа

    (%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
    

    функции Бесселя

    bessel_j (v, z)
    the Bessel function of the first kind of order v and argument z
    bessel_y (v, z)
    the Bessel function of the second kind of order v and argument z

    векторный анализ

    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]

    функции модуля:

    express (expr)
    expands differential operator nouns into expressions in terms of partial derivatives
    'express' recognizes the operators 'grad', 'div', 'curl', 'laplacian'
    'express' also expands the cross product '~'
    symbolic derivatives (that is, 'diff' nouns) in the return value of express may be evaluated by including 'diff' in the 'ev' function call or command line. in this context, 'diff' acts as an 'evfun'

    vectorsimp (expr)
    applies simplifications and expansions according to the following global flags:
    expandall,  expanddot,      expanddotplus,  expandcross,     expandcrossplus,     expandcrosscross,
    expandgrad, expandgradplus, expandgradprod, expanddiv,       expanddivplus,       expanddivprod,
    expandcurl, expandcurlplus, expandcurlcurl, expandlaplacian, expandlaplacianplus,
    expandlaplacianprod
    all these flags have default value false
    the plus suffix refers to employing additivity or distributivity
    the prod suffix refers to the expansion for an operand that is any kind of product

    expandcrosscross
    simplifies p ~ (q ~ r) to (p . r)*q - (p . q)*r

    expandcurlcurl
    simplifies curl curl p to grad div p + div grad p

    expandlaplaciantodivgrad
    simplifies laplacian p to div grad p

    expandcross
    enables expandcrossplus and expandcrosscross

    expandplus
    enables expanddotplus, expandcrossplus, expandgradplus, expanddivplus, expandcurlplus, and expandlaplacianplus

    expandprod
    enables expandgradprod, expanddivprod, and expandlaplacianprod

    these flags have all been declared evflag

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

    (%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
    

    linear_program (A, b, c)
    computes a vector x for which c.x is minimum possible among vectors
    for which A.x = b and x >= 0
    argument A is a matrix and arguments b and c are lists
    returns a list which contains the minimizing vector x and the minimum value c.x
    if the problem is not bounded, it returns "Problem not bounded!"
    and if the problem is not feasible, it returns "Problem not feasible!"
    пример

        (%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
    


    скрипты

    в файл записывается тело скрипта :

    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  

    комментарии

    комментарии в скриптовых файлах Максимы начинаются с /* и завершаются */ при этом они могут быть многострочными

    функции

    оператор задания функции обозначается через :=

    (%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 */
    
    и теперь в repl:
    (%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  

    цикл будет прокручен с переменной, изменяющейся по всем элементам списка; можно задать еще и дополнительное условие на прерывание цикла

    терминал

    функции - для чтения и для вывода:

       k : read ("enter your num ") ;
    
       print (k) ;
       
       display (k1,k2,...) ;
       disp (k1,k2,...) ;
       
       ldisp (k1,k2,...) ;       с присваиванием метки каждому аргументу
       ldisplay (k1,k2,...) ;
    

    lisp

    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, с той разницей, что здесь независимых переменных две