Previous: Файлы, Up: Ввод и вывод [Contents][Index]
__ - введенное выражение, обрабатываемое в данный момент.
То есть, пока вычисляется expr, __ равно expr.
Введенное выражение присваивается переменной __ до упрощения или вычисления.
Однако, значение __ упрощается (но не вычисляется) во время вывода.
__ распознается функциями batch и load.
В файле, обрабатываемом с помощью batch, __ означает то же самое,
что и в режиме диалога. Когда файл обрабатывается функцией load, __
имеет значения последнего, введенного в режиме диалога или пакетном файле, выражения.
__ не принимает значения выражений, которые вводятся в обрабатываемом файле.
В частности, если load (filename) вызывается в режиме диалога,
то во время выполнения файла __ имеет значение load(filename).
См. также _ и %.
Примеры:
(%i1) print ("I was called as", __);
I was called as print(I was called as, __)
(%o1) print(I was called as, __)
(%i2) foo (__);
(%o2) foo(foo(__))
(%i3) g (x) := (print ("Current input expression =", __), 0);
(%o3) g(x) := (print("Current input expression =", __), 0)
(%i4) [aa : 1, bb : 2, cc : 3];
(%o4) [1, 2, 3]
(%i5) (aa + bb + cc)/(dd + ee + g(x));
cc + bb + aa
Current input expression = --------------
g(x) + ee + dd
6
(%o5) -------
ee + dd
_ - самое последнее из введенных выражений (таких как %i1, %i2, %i3, ...).
Введенное выражение присваивается переменной _ до упрощения или вычисления.
Однако, это значение упрощается (но не вычисляется) во время вывода.
_ обрабатывается функциями batch и load.
Во время обработки файла функцией batch переменная _ означает то же, что и в
режиме диалога.
Когда файл обрабатывается функцией load, значение переменной _ принимает
последнее вычисленное выражение, которое было введено в диалоговом режиме или пакетном файле.
Выражения, вводимые в обрабатываемом файле, не присваиваются переменной _.
См. также __ и %.
Примеры:
(%i1) 13 + 29; (%o1) 42 (%i2) :lisp $_ ((MPLUS) 13 29) (%i2) _; (%o2) 42 (%i3) sin (%pi/2); (%o3) 1 (%i4) :lisp $_ ((%SIN) ((MQUOTIENT) $%PI 2)) (%i4) _; (%o4) 1 (%i5) a: 13$ (%i6) b: 29$ (%i7) a + b; (%o7) 42 (%i8) :lisp $_ ((MPLUS) $A $B) (%i8) _; (%o8) b + a (%i9) a + b; (%o9) 42 (%i10) ev (_); (%o10) 42
% - вывод (%o1, %o2, o3, ...) последнего обработанного
выражения, даже если он не выводится.
% обрабатывается командами batch и load.
В файле, обрабатываемом командой batch, % имеет то же значение, что и
в режиме диалога. В файле, обрабатываемого командой load, Значение % принимает
вывод последнего обработанного в диалоговом режиме выражения. Переменной % не присваивается
вывод выражений обрабатываемого файла.
См. также _, %% и %th.
В составных выражениях таких как block, lambda, или (s_1, ..., s_n),
%% - значение предыдущего утверждения. К примеру выражения,
block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
block ([prev], prev: integrate (x^5, x),
ev (prev, x=2) - ev (prev, x=1));
дадут один и тот же результат, то есть 21/2.
Составное выражение может быть частью другого составного выражения. И в случае простого утверждения,
и в случае, когда утверждение является составным выражением, %% принимает значение предыдущего утверждения.
К примеру,
block (block (a^n, %%*42), %%/6)
выдаст 7*a^n.
Внутри составного утверждения, значение %% можно проверить в диалоге
команды break. К примеру, следующее выражение
block (a: 42, break ())$
открывает диалог, в котором результатом ввода %%; будет 42.
В первом утверждении составного выражения или вне составного выражения
переменная %% не определена.
Переменная %% распознается функциями batch и load,
и имеет то же значение, что и в режиме диалога.
См. также %.
Значение по умолчанию: false
Когда %edispflag установлена равной true, Maxima отображает %e отрицательной
степени. К примеру, %e^-x отображается как 1/%e^x.
Значение i-го предыдущего вывода. То есть, если следующим вычисленным выражением
будет вывод с номером n, то %th (m) примет значение вывода с номером (n - m).
%th полезна в пакетных batch-файлах или в ссылках на группу выведенных выражений.
К примеру,
block (s: 0, for i:1 thru 10 do s: s + %th (i))$
присвоит переменной s сумму последних десяти выведенных выражений.
%th обрабатывается функциями batch и load.
В файле, обрабатываемом функцией batch, %th означает то же,
что и в режиме диалога. В файле, обрабатываемом командой load,
%th ссылается на выведенные выражения, которые были вычислены последними в режиме диалога
или пакетном файле. %th не ссылается на выражения, выводимые в процессе работы load.
См. также %.
Стоящий перед именем функции или переменной символ ? означает что
это имя функции или переменной из Lisp, а не из Maxima.
К примеру, ?round означает Lisp-функцию ROUND.
См. дополнительно Lisp и Maxima.
Запись ? word (вопросительный знак и следующее за ним слово разделены пробелом)
эквивалентна записи describe("word").
Вопросительный знак должен находиться в начале строки ввода, иначе он не определится
как запрос на документацию.
Запись ?? word (?? и следующее за ним слово разделяются символом пробела)
эквивалентна записи descrive("word", inexact).
Значение по умолчанию: !
Символ absboxchar используется для изображения знака модуля вокруг,
выражений, занимающих по высоте больше одной строчки.
Значение по умолчанию: false
file_output_append управляет тем, будет ли вывод в функции добавляться в конец
или замещать содержимое выводимого файла.
Когда file_output_append равна true, такие функции добавляют вывод к файлу,
иначе выводимый файл переписывается заново.
Функции save, strungout и with_stdout учитывают file_output_append.
Остальные функции, которые записываю выход во внешние файлы, не учитывают file_output_append.
В частности, графические и транслирующие функции всегда замещает содержимое выводимого файла, а
tex и strungout всегда дописываю в конец.
Добавляет копию консольного вывода в filename.
appendfile работает так же как и writefile,
но отличие в том, что если файл существует, он всегда дописывается.
closefile закрывает трансляцию в файл открытый функциями appendfile или writefile.
Считывает выражения Maxima из filename, и обрабатывает их.
batch ищет filename в директориях списка file_search_maxima.
См. file_search.
filename содержит последовательность выражений Maxima,
завершающихся символами ; или $.
Специальные переменная % и функция %th
ссылаются на предыдущие результаты внутри файла.
Файл может включать конструкции :lisp.
Символы пробела, табуляции и новой строки в файле игнорируются.
Подходящий входной файл может быть создан при помощи текстового редактора или
функцией stringout.
batch считывает каждое входящее выражение из filename,
отображает его ввод в консоли,
вычисляет соответствующее выходящее выражение
и выводит его.
Входящим выражениям присваиваются входные метки, а выходящим – выходные.
batch вычисляет все входящие выражения файла до тех пор пока в них не
встретится ошибка.
Если запрашивается пользовательский ввод (к примеру, командами asksign или askinteger),
выполнение batch останавливается для сбора требуемого ввода и затем продолжается.
Возможна остановка batch нажатием control-C в консоли.
Эффект нажатия control-C зависит от реализации лежащего в основе Lisp.
batch может использоваться в различных целях.
Для хранения рабочих командных строк, дающих возможность проводить демонстрации без ошибок,
или может помочь организовать работу над решением сложных задач.
batch вычисляет свой аргумент.
batch не возвращает значений.
См. также load, batchload и demo.
Считывает выражения Maxima из filename и вычисляет их,
не отображая входные и выходные выражения и не присваивая ссылок
выходным выражениям.
Однако, печатаемый вывод (такой, какой производят команды print или describe)
отображается.
Специальная переменная % и функция %th
ссылается на предыдущие результаты из режима диалога, но не на результаты
внутри файла.
Файл не может включать конструкции :lisp.
batchload возвращает путь к filename в виде строки.
batchload вычисляет свой аргумент.
См. также batch и load.
Закрывает запись в файл, открытую командой writefile или appendfile.
Сворачивает выражение expr делая все его общие (т.е. равные)
ссылающимися на одни ячейки памяти, тем самым сохраняя память.
Функция (collapse используется командой optimize.
Таким образом, вызов collapse может быть полезным до выгрузки в save файл.
Можно свернуть несколько выражений вместе используя команду
collapse ([expr_1, ..., expr_n]).
Аналогично, можно свернуть элементы массива A
при помощи команды collapse (listarray ('A)).
Сцепляет свои аргументы. Аргументы должны быть атомами. Возвращаемое значение является символом, если первый аргумент – символ, и строкой в противном случае.
concat вычисляет свои аргументы.
Одиночная кавычка ' предотвращает вычисление.
(%i1) y: 7$
(%i2) z: 88$
(%i3) concat (y, z/2);
(%o3) 744
(%i4) concat ('y, z/2);
(%o4) y44
Символу, полученному с помощью concat, можно присваивать значения
и использовать его в выражениях.
:: (двойное двоеточие) – оператор присваивания, который вычисляет свой левый операнд.
(%i5) a: concat ('y, z/2);
(%o5) y44
(%i6) a:: 123;
(%o6) 123
(%i7) y44;
(%o7) 123
(%i8) b^a;
y44
(%o8) b
(%i9) %, numer;
123
(%o9) b
Заметьте, что несмотря на то, что concat (1, 2) выглядит как число, результат является строкой.
(%i10) concat (1, 2) + 3; (%o10) 12 + 3
Сцепляет аргументы в строки. В отличии от concat, аргументы не обязаны
быть атомами.
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
(%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
то же что и display, но отличается тем что значение аргументов отображаются
без выражений. Это полезно для сложных аргументов, у которых нет имени или
в случае, когда интерес представляет только значение без имени.
Отображает ограничения аргументов, наложенные на них командой defcon.
dispcon (all) отображает все ограничения, которые были заданы.
Отображает равенства, выравненные по центру. Левыми частями равенств являются не вычисленные
выражения expr_i, a правыми – их значения.
Эта функция полезна в блоках и конструкциях for для вывода промежуточных результатов.
Аргументы display обычно являются атомами, переменными с индексом, или
вызовами функций. См. также disp.
(%i1) display(B[1,2]);
2
B = X - X
1, 2
(%o1) done
Значение по умолчанию: true
Когда display2d равна false, консольный вывод производится в строковой (одномерной) форме,
а не в наглядной (двумерной).
Значение по умолчанию: false
Когда display_format_internal равна true,
выражения отображаются без преобразования, которое "прячет"
внутреннее математическое представление.
Тогда вывод соответствует результату функции inpart, а не part.
Примеры:
User part inpart
a-b; a - b a + (- 1) b
a - 1
a/b; - a b
b
1/2
sqrt(x); sqrt(x) x
4 X 4
X*4/3; --- - X
3 3
Выводит друг под другом части expr.
Первым отображается оператор выражения expr, затем каждое слагаемое суммы, множители
произведения или части более общего выражения отображаются отдельно. Это полезно,
когда expr слишком большое для иных способов отображения. К примеру, если
P1, P2, ... – очень большие выражения, то программе может не хватить
памяти при попытке отобразить P1 + P2 + ... как единое целое.
Однако, dispterms (P1 + P2 + ...) отображает P1, затем ниже P2 и т. д.
Если не использовать dispterms, когда показательное выражение
слишком широко, для отображения в виде A^B, то оно выводится в виде expt (A, B)
(или ncexpt (A, B) в случае A^^B).
Значение по умолчанию: 10
error_size изменяет сообщения об ошибках, в зависимости от размера выражения, которое появляется в нем.
Если размер выражения (определенный с помощью Lisp-функции ERROR-SIZE)
больше чем error_size, выражение замещается символом, а символу присваивается
выражение. Символы берутся из списка error_syms.
В противном случае, когда выражение меньше чем error_size, оно и выводится
в сообщении.
См. также error и error_syms.
Пример:
ERROR-SIZE задает размер U равным 24.
(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$
(%i2) error_size: 20$
(%i3) error ("Example expression is", U);
Example expression is errexp1
-- an error. Quitting. To debug this try debugmode(true);
(%i4) errexp1;
E
D
C + B + A
(%o4) --------------
cos(X - 1) + 1
(%i5) error_size: 30$
(%i6) error ("Example expression is", U);
E
D
C + B + A
Example expression is --------------
cos(X - 1) + 1
-- an error. Quitting. To debug this try debugmode(true);
Значение по умолчанию: [errexp1, errexp2, errexp3]
В сообщениях об ошибках, выражения большие чем error_size заменяются символами
и присваиваются этим символам. Символы берутся из списка error_syms.
Первое слишком большое выражения заменяется символом error_syms[1],
второе символом error_syms[2] и так далее.
Если слишком больших выражений больше чем элементов в error_syms,
то символы генерируются автоматически, n-ный символ равен concat ('errexp, n).
См. также error и error_size.
Если показательное выражение слишком широко для отображения в виде a^b),
оно выводится в виде expt (a, b) (или ncexpt (a, b)
в случае a^^b).
expt и ncexpt не распознаются при вводе.
Значение по умолчанию: true
Когда exptdispflag равна true, Maxima отображает выражения
с отрицательными степенями в виде дробей, например X^(-1) в виде 1/X.
Составляет путь из path и filename. Если последняя часть пути path
имеет форму ###.something, эта часть заменяется на filename.something.
В противном случае последняя часть заменяется на filename.
Результатом является объект пути Lisp.
file_search ищет файл filename и возвращает путь к этому файлу (в виде строки),
если может его найти, иначе возвращает false.
file_search (filename) ищет в определенных по умолчанию каталогах для поиска, которые
указаны в переменных file_search_maxima, file_search_lisp и file_search_demo.
Перед попыткой сопоставить имя с шаблонами поиска файлов.
file_search первым делом проверяет существование искомого файла.
См. file_search_maxima о шаблонах поиска файла.
Аргумент filename может быть как путем с именем, так и просто именем файла. Если каталог включен в пути поиска вместе с поисковым шаблоном файла, то filename может быть именем без расширения. В примере
file_search ("/home/wfs/special/zeta.mac");
file_search ("zeta.mac");
file_search ("zeta");
будет найден один и тот же файл, если он существует и /home/wfs/special/###.mac включен
в file_search_maxima.
file_search (filename, pathlist) осуществляет поиск в каталогах,
заданных переменной pathlist, которая представляет из себя список строк.
Аргумент pathlist замещает каталоги поиска, определенные по умолчанию, так если дан список путей,
file_search ищет только в заданных там и не ищет в путях по умолчанию.
Даже если pathlist содержит только один каталог, pathlist должен быть задан, как список из одного
элемента.
Пользователь может изменять пути, определенные по умолчанию. См. file_search_maxima.
file_search используется функцией load, шаблоны поиска файлов берутся
из file_search_maxima и file_search_lisp.
Эти переменные задают списки каталогов, в которых производят поиск функции
load, demo и некоторые другие функции Maxima.
По умолчанию в них заданы различные каталоги из путей установки Maxima.
Пользователь может изменить эти переменные, удалить значения по умолчанию или добавить дополнительные каталоги. Например,
file_search_maxima: ["/usr/local/foo/###.mac",
"/usr/local/bar/###.mac"]$
удаляет начальные директории списка file_search_maxima,
в то время как
file_search_maxima: append (file_search_maxima,
["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
добавляет две дополнительные директории.
Иногда удобно разместить такие выражения в файле maxima-init.mac,
чтобы путь поиска файла назначался автоматически при запуске Maxima.
При помощи шаблонов поиска файлов можно определить несколько расширений файлов и несколько путей.
Строка ### заменяется запрашиваемым именем,
в то время как список разделенных запятыми имен, заключенный в фигурные скобки, {foo,bar,baz}
раскрывается в множество строк.
В качестве примера предположим, что искомое имя – neumann, тогда
"/home/{wfs,gcj}/###.{lisp,mac}"
раскроется в /home/wfs/neumann.lisp, /home/gcj/neumann.lisp, /home/wfs/neumann.mac и
/home/gcj/neumann.mac.
Возвращает предположение о содержимом filename, на основе его расширения. filename не должен ссылаться на существующий файл, не происходит попыток открыть файл и проверить содержимое.
Возвращаемое значение является одним из символов: object, lisp или maxima.
Если расширение начинается на m или d, file_type возвращается maxima.
Если расширение начинается на l, file_type возвращается lisp.
Если ни один из перечисленных вариантов, то file_type возвращается object.
Функция grind выводит expr в консоль в форме
подходящем для ввода в Maxima. grind всегда возвращает done.
Когда expr является именем функции или макрокоманды, grind печатает
определение функции или макрокоманды вместо просто имени.
См. также string, которая возвращает строку, а не печатает вывод.
grind пытается печатать выражение способом, который делает его проще
для чтения, чем вывод команды string.
Когда переменная grind равна true, вывод string и stringout
имеет тот же вид, что и вывод grind.
В противном случае специального форматирования вывода этих функций не производится.
По умолчанию значение переменной grind равно false.
grind может так же быть задана как аргумент playback.
Когда grind задана, playback печатает входное выражение в таком же
виде как функция grind.
В противном случае специального форматирования вывода не производится.
grind вычисляет свой аргумент.
Примеры:
(%i1) aa + 1729;
(%o1) aa + 1729
(%i2) grind (%);
aa+1729$
(%o2) done
(%i3) [aa, 1729, aa + 1729];
(%o3) [aa, 1729, aa + 1729]
(%i4) grind (%);
[aa,1729,aa+1729]$
(%o4) done
(%i5) matrix ([aa, 17], [29, bb]);
[ aa 17 ]
(%o5) [ ]
[ 29 bb ]
(%i6) grind (%);
matrix([aa,17],[29,bb])$
(%o6) done
(%i7) set (aa, 17, 29, bb);
(%o7) {17, 29, aa, bb}
(%i8) grind (%);
{17,29,aa,bb}$
(%o8) done
(%i9) exp (aa / (bb + 17)^29);
aa
-----------
29
(bb + 17)
(%o9) %e
(%i10) grind (%);
%e^(aa/(bb+17)^29)$
(%o10) done
(%i11) expr: expand ((aa + bb)^10);
10 9 2 8 3 7 4 6
(%o11) bb + 10 aa bb + 45 aa bb + 120 aa bb + 210 aa bb
5 5 6 4 7 3 8 2
+ 252 aa bb + 210 aa bb + 120 aa bb + 45 aa bb
9 10
+ 10 aa bb + aa
(%i12) grind (expr);
bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
+10*aa^9*bb+aa^10$
(%o12) done
(%i13) string (expr);
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
bb+aa^10
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
p : makelist (0, i, 1, length (A))], for i thru n do
for j : i thru n do
(x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
for i thru n do L[i, i] : 1 / p[i],
for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
(%i15) grind (cholesky);
cholesky(A):=block(
[n:length(A),L:copymatrix(A),
p:makelist(0,i,1,length(A))],
for i thru n do
(for j from i thru n do
(x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
if i = j then p[i]:1/sqrt(x)
else L[j,i]:x*p[i])),
for i thru n do L[i,i]:1/p[i],
for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
(%o15) done
(%i16) string (fundef (cholesky));
(%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
n do (for j from i+1 thru n do L[i,j]:0),L)
Значение по умолчанию: 10
Целые вводимые в Maxima распознаются с учетом основания системы счисления ibase.
Переменной ibase может быть присвоено значение между 2 и 35 (в десятичной), включительно.
Когда ibase больше чем 10, в состав цифр входят десятичные цифры от 0 до 9
и заглавные буквы алфавита A, B, C, ..., по мере необходимости.
Цифры для основания 35, наибольшего возможного, включают цифры от 0 до 9 и буквы от A до Z.
См. также obase.
Значение по умолчанию: %i
inchar – префикс перед метками выражений, вводимых пользователем.
Maxima автоматически генерирует ссылку для каждого входного выражения,
соединяя inchar и linenum.
Переменной inchar может быть присвоена любая строка или обозначение, не обязательно
состоящее из одной буквы.
(%i1) inchar: "input";
(%o1) input
(input1) expand ((a+b)^3);
3 2 2 3
(%o1) b + 3 a b + 3 a b + a
(input2)
См. также labels.
Отображает выражения expr_1, ..., expr_n в консоли как в печатном выводе.
ldisp присваивает метки промежуточных выражений для каждого аргумента
и возвращает список меток.
См. также disp.
(%i1) e: (a+b)^3;
3
(%o1) (b + a)
(%i2) f: expand (e);
3 2 2 3
(%o2) b + 3 a b + 3 a b + a
(%i3) ldisp (e, f);
3
(%t3) (b + a)
3 2 2 3
(%t4) b + 3 a b + 3 a b + a
(%o4) [%t3, %t4]
(%i4) %t3;
3
(%o4) (b + a)
(%i5) %t4;
3 2 2 3
(%o5) b + 3 a b + 3 a b + a
Отображает выражения expr_1, ..., expr_n в консоли как при выводе.
Каждое выражение печатается в виде равенства lhs = rhs,
в котором lhs – один из аргументов функции ldisplay,
а rhs – его значение.
Обычно каждый аргумент – переменная.
ldisp присваивает метки промежуточных выражений каждому равенству
и возвращает список меток.
См. также display.
(%i1) e: (a+b)^3;
3
(%o1) (b + a)
(%i2) f: expand (e);
3 2 2 3
(%o2) b + 3 a b + 3 a b + a
(%i3) ldisplay (e, f);
3
(%t3) e = (b + a)
3 2 2 3
(%t4) f = b + 3 a b + 3 a b + a
(%o4) [%t3, %t4]
(%i4) %t3;
3
(%o4) e = (b + a)
(%i5) %t4;
3 2 2 3
(%o5) f = b + 3 a b + 3 a b + a
Значение по умолчанию: %t
linechar – префикс меток промежуточных выражений, генерируемых Maxima.
Maxima генерирует метки для каждого промежуточного выражения (если оно отображается),
соединяя linechar и linenum.
Переменной linechar может быть присвоена любая строка или символ, не обязательно
одиночная буква.
Промежуточный выражения могут отображаться, а могут и не отображаться.
См. programmode и labels.
Значение по умолчанию: 79
linel – ширина консоли (в символах) для вывода выражений.
Пользователь может задать любое значение linel, хотя очень маленькие или
очень большие значения могут оказаться неудобными.
Текст выводимый встроенными функциями Maxima, такой как сообщения об ошибках и вывод describe,
не зависит от linel.
Значение по умолчанию: false
Когда lispdisp равна true,
Lisp символы отображаются с вопросительным знаком ? перед ними.
В противном случае Lisp символы отображаются без знака.
Примеры:
(%i1) lispdisp: false$ (%i2) ?foo + ?bar; (%o2) foo + bar (%i3) lispdisp: true$ (%i4) ?foo + ?bar; (%o4) ?foo + ?bar
Вычисляет выражения в filename,
тем самым загружая переменные, функции и другие объекты в Maxima.
Значения любых существовавших объектов заменяются связями, полученными из filename.
Для поиска файла load вызывает file_search,
пути поиска берутся из file_search_maxima и file_search_lisp.
Если load выполнена успешно, то возвращается имя файла, иначе печатается сообщение об ошибке.
load работает с равным успехом как для Lisp, так и для Maxima программ.
Файлы, созданные командами save, translate_file и compile_file, которые создают
код Lisp, и stringout, которая создает код Maxima, могут быть обработаны функцией load.
load вызывает loadfile для загрузки Lisp файлов и batchload для загрузки Maxima файлов.
load не распознает конструкции :lisp в файлах Maxima, и во время обработки filename,
глобальные переменные _, __, % и %th имеют те связи, которые были у них в момент
вызова load.
См. также loadfile, batch, batchload и demo.
batch, batchload и demo выполняют Maxima файлы.
См. file_search для более подробного ознакомления с механизмом поиска файлов.
load вычисляет свой аргумент.
Вычисляет выражения Lisp в filename.
loadfile не вызывает file_search, поэтому filename должен включать
расширение и информацию о пути, достаточную для поиска файла.
loadfile может обрабатывать файлы, созданные командами save, translate_file и compile_file.
Возможно, удобнее использовать load вместо loadfile.
Значение по умолчанию: true
loadprint управляет печатью сообщение после загрузки файла.
loadprint равна true, сообщение всегда выводится.
loadprint равна 'loadfile, сообщение выводится только в случае,
когда файл загружается функцией loadfile.
loadprint равна 'autoload,
сообщение выводится только если файл загружается автоматически.
См. setup_autoload.
loadprint равен false, сообщение не выводится.
Значение по умолчанию: 10
obase – основание системы счисления в которой Maxima отображает целые числа.
Переменной obase можно присвоить любое целое число между 2 и 35 (десятичное),
включительно.
Когда obase больше десяти, цифрами являются десятичные цифры от 0 до 9 и
заглавные буквы латинского алфавита A, B, C, ..., по мере необходимости.
Цифры системы с основанием 35, самым большим из допустимых,
включают цифры от 0 до 9 и буквы от A до Y.
См. также ibase.
Значение по умолчанию: %o
outchar – это префикс меток для выражений, вычисленных системой Maxima.
Maxima автоматически генерирует метки для каждого вычисленного выражения, соединяя
outchar с linenum.
Переменной outchar можно присвоить любую строку или символ, не обязательно
одиночную букву.
(%i1) outchar: "output";
(output1) output
(%i2) expand ((a+b)^3);
3 2 2 3
(output2) b + 3 a b + 3 a b + a
(%i3)
См. также labels.
Значение по умолчанию: false
Разработчики, которые используют save или translate, создавая пакеты (файлы)
для использования другими, возможно захотят установить packagefile: true,
чтобы при загрузке файла предотвратить
занесение информации, кроме необходимой, в списки Maxima (такие как values,
functions).
В этом случае содержимое пакета будет загружено не в виде пользовательских данных.
Заметим, что это не решает проблему возможного конфликта имен.
Также заметим, что переменная просто указывает на то, что выводится в пакетный файл.
Установка управляющей переменной в true также полезна для создания
инициализационных файлов Maxima.
Значение по умолчанию: false
Когда pfeformat равна true, рациональная дробь отображается при помощи
косой черты (прямого слэша). Целочисленный знаменатель n отображается
как множитель 1/n.
(%i1) pfeformat: false$
(%i2) 2^16/7^3;
65536
(%o2) -----
343
(%i3) (a+b)/8;
b + a
(%o3) -----
8
(%i4) pfeformat: true$
(%i5) 2^16/7^3;
(%o5) 65536/343
(%i6) (a+b)/8;
(%o6) 1/8 (b + a)
Вычисляет и отображает expr_1, ..., expr_n одно за другим, слева направо, начиная с левого края экрана консоли.
Функция print возвращает значение своего последнего аргумента.
print не создает меток промежуточных выражений.
См. также display, disp, ldisplay и ldisp.
Эти функции отображают по одному выражению на строку, в то время как print старается
отобразить по два или больше выражений в каждой строке.
Чтобы отобразить содержимое файла, см. printfile.
(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
radcan (log (a^10/b)))$
3 2 2 3
(a+b)^3 is b + 3 a b + 3 a b + a log (a^10/b) is
10 log(a) - log(b)
(%i2) r;
(%o2) 10 log(a) - log(b)
(%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
radcan (log (a^10/b)))$
(a+b)^3 is
3 2 2 3
b + 3 a b + 3 a b + a
log (a^10/b) is
10 log(a) - log(b)
Выводит файл с именем path на консоль. Значение path может быть строкой или символом. Если символ, то он преобразуется в строку.
Если файл с именем path доступен в текущей директории, то
он печатается на консоли.
В противном случае printfile пытается найти файл добавляя path
ко всем элементам file_search_usage
при помощи filename_merge.
printfile возвращает path, если файл существует,
и результат успешного поиска файла.
Выводит элементы списков заключенными в фигурные скобки { },
в виде пригодном для использования в языке Tcl/Tk.
tcl_output (list, i0, skip)
выводит элементы списка list с номерами i0, i0 + skip,
i0 + 2 skip и так далее.
tcl_output (list, i0) равнозначна tcl_output (list, i0, 2).
tcl_output ([list_1, ..., list_n], i)
выводит i-ые элементы списков list_1, ..., list_n.
Примеры:
(%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$
{1.000000000 4.000000000
}
(%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$
{2.000000000 5.000000000
}
(%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$
{((RAT SIMP) 3 7) ((RAT SIMP) 11 13)
}
(%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$
{$Y1 $Y2 $Y3
}
(%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$
{SIMP 1.000000000 11.00000000
}
Выводит expr_1, ..., expr_n, затем считывает одно выражение с консоли и возвращает вычисленное выражение.
См. также readonly.
(%i1) foo: 42$
(%i2) foo: read ("foo is", foo, " -- enter new value.")$
foo is 42 -- enter new value.
(a+b)^3;
(%i3) foo;
3
(%o3) (b + a)
Выводит expr_1, ..., expr_n, затем считывает одно выражение с консоли и Возвращает его без вычисления.
(%i1) aa: 7$
(%i2) foo: readonly ("Enter an expression:");
Enter an expression:
2^aa;
aa
(%o2) 2
(%i3) foo: read ("Enter an expression:");
Enter an expression:
2^aa;
(%o3) 128
См. также read.
Замещает части выражения expr заданного уровня вложенности depth кратким описанием.
Sum(n),
где n – количество слагаемых.
Product(n),
где n – количество множителей.
Expt.
Quotient.
Negterm.
Если depth больше или равен максимальному уровню вложенности в выражении expr,
то reveal (expr, depth) возвращает expr без изменений.
reveal вычисляет свои аргументы.
reveal возвращает анализируемое выражение.
Пример:
(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
2 2
b - 2 a b + a
(%o1) -------------------------
b + a 2 b 2 a
2 %e + %e + %e
(%i2) reveal (e, 1);
(%o2) Quotient
(%i3) reveal (e, 2);
Sum(3)
(%o3) ------
Sum(3)
(%i4) reveal (e, 3);
Expt + Negterm + Expt
(%o4) ------------------------
Product(2) + Expt + Expt
(%i5) reveal (e, 4);
2 2
b - Product(3) + a
(%o5) ------------------------------------
Product(2) Product(2)
2 Expt + %e + %e
(%i6) reveal (e, 5);
2 2
b - 2 a b + a
(%o6) --------------------------
Sum(2) 2 b 2 a
2 %e + %e + %e
(%i7) reveal (e, 6);
2 2
b - 2 a b + a
(%o7) -------------------------
b + a 2 b 2 a
2 %e + %e + %e
Значение по умолчанию: ]
Правая сторона матриц изображается символами rmxchar.
См. также lmxchar.
Сохраняет текущие значения аргументов name_1, name_2, name_3, ..., в filename.
Аргументами являются имена переменных, функций и прочих объектов.
Если имя не имеет значения или связанной с ним функцией, оно игнорируется.
save возвращает filename.
save сохраняет данные в форме Lisp выражений.
Данные, сохраненные функцией save, можно загрузить при помощи load (filename).
Глобальная управляющая переменная file_output_append управляет тем,
будет ли информация добавлена к файлу, или файл будет переписан заново.
Когда file_output_append равен true, происходит добавление,
иначе save переписывает файл вывода. В обоих случаях save создает
файл, если он до этого не существовал.
Особая форма save (filename, values, functions, labels, ...)
сохраняет элементы перечисленные в списках values, functions, labels и т. д.
Возможны любые имена определенные в infolist.
values включает все определенные пользователем переменные.
Особая форма save (filename, [m, n]) сохраняет значения
входных и результирующих выражений с номерами от m до n.
Заметим, что m и n должны быть буквальными целыми.
Входные и результирующие метки можно также записать одну за другой, например, save ("foo.1", %i42, %o42).
save (filename, labels) сохраняет все входные и результирующие выражения.
Сохраненные выражения при загрузке заменяют существующие.
Особая форма save (filename, name_1=expr_1, name_2=expr_2, ...)
сохраняет значения expr_1, expr_2, ... с именами name_1, name_2, ...
Эту форму полезно применять для входных и результирующих меток,
например, save ("foo.1", aa=%o88).
С правой стороны равенства в этой форме может стоять любое выражение, которое вычисляется.
Эта форма не вводит новые имена в текущий сеанс Maxima, только сохраняет их в filename.
Эти особые формы и общую форму функции save можно как угодно смешивать.
Например: save (filename, aa, bb, cc=42, functions, [11, 17]).
Особая форма save (filename, all) сохраняет текущее состояние Maxima,
включая все определенные пользователем переменные, функции, массивы и т. д., а также
элементы, заданные автоматически.
Сохраняемые элементы включают в себя системные переменные, такие как file_search_maxima или showtime,
если пользователь присвоил им новые значения. См. myoptions.
save вычисляет filename, все остальные аргументы не вычисляются.
Значение по умолчанию: true
Когда savedef равно true, Maxima версия определенной пользователем функции
защищается, при ее трансляции. Это позволяет
отобразить ее определение при помощи dispfun и дает возможность редактировать ее.
Когда savedef равна false, имена транслируемых функций
удаляются из списка functions.
При отображении expr, у индексированных объектов ковариантные
индексы показываются как нижние, а контравариантные –
как верхние. Индексы дифференцирования отображаются нижними и отделяются от
ковариантных запятой.
Возвращает список переменных в каноническом рациональном выражении expr.
См. также ratvars.
Значение по умолчанию: false
Когда stardisp равно true, произведение отображается
со звездочкой между операндами.
Преобразовывает expr в линейное представление,
как оно было бы введено с клавиатуры.
Значение, возвращаемое функцией string, является строкой,
поэтому не может использоваться в вычислениях.
Значение по умолчанию: false
Когда stringdisp равна true,
строки отображаются заключенными в двойные кавычки.
В противном случае кавычки опускаются.
stringdisp всегда true, при выводе определений функций.
Примеры:
(%i1) stringdisp: false$
(%i2) "This is an example string.";
(%o2) This is an example string.
(%i3) foo () :=
print ("This is a string in a function definition.");
(%o3) foo() :=
print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string.";
(%o5) "This is an example string."
stringout записывает выражение в файл в той же форме, в которой
оно было бы введено с клавиатуры. Файл можно использовать в качестве входного для
команд batch или demo, его также можно редактировать для любых целей.
stringout можно выполнять во время работы writefile.
Глобальная переменная file_output_append определяет будет ли
stringout добавлять или переписывать выходной файл.
Если file_output_append равна true,
stringout дописывает выходной файл, иначе переписывает его.
В обоих случаях stringout создает файл, если тот не существовал.
Общий вид команды stringout записывает значения одного или нескольких выражений в файл.
Заметим, что если выражения являются переменной, записывается только значение переменной, но не ее имя.
В полезном специальном случае, выражения могут быть метками входных
(%i1, %i2, %i3, ...) или результирующих (%o1, %o2, %o3, ...) выражений.
Если grind равна true, stringout форматирует выход используя формат grind.
Иначе используется формат string. См. grind и string.
Особая форма stringout (filename, [m, n) записывает значения входных выражений,
с номерами от m до n, включительно.
Особая форма stringout (filename, input) записывает в файл все входные выражения.
Особая форма stringout (filename, functions) записывает в файл все пользовательские функции
(перечисленные в глобальном списке functions).
Особая форма stringout (filename, values) записывает в файл все пользовательские
переменные (перечисленные в глобальном списке values). Каждая переменная выводится как
оператор присваивания: с именем переменной, двоеточием и ее значением. Заметим, что общая форма
stringout не выводит переменные в виде операторов присваивания.
Отображает выражение в представлении подходящим для системы подготовки документов TeX. Результат – фрагмент документа, который можно скопировать в больший документ, но сам по себе он для обработки не подходит.
tex (expr) отображает TeX-представление выражения expr в консоль.
(label) отображает TeX-представление выражения, помеченное label,
и назначает его метке выражения (отображаемой слева от выражения).
Метки выражений TeX совпадают с метками Maxima.
tex (expr, filename) и tex (label, filename)
добавляют свой TeX-вывод в файл filename.
tex (expr, false) и tex (label, false)
возвращают свой вывод в виде строки.
tex вычисляет свой первый аргумент после попытки определить, не является ли он меткой.
Оператор две кавычки '' вызывает вычисление аргумента, предотвращая
попытки проверить, является ли он меткой.
См. также texput.
Примеры:
(%i1) integrate (1/(1+x^3), x);
2 x - 1
2 atan(-------)
log(x - x + 1) sqrt(3) log(x + 1)
(%o1) - --------------- + ------------- + ----------
6 sqrt(3) 3
(%i2) tex (%o1);
$$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
}\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
}\over{3}}\leqno{\tt (\%o1)}$$
(%o2) (\%o1)
(%i3) tex (integrate (sin(x), x));
$$-\cos x$$
(%o3) false
(%i4) tex (%o1, "foo.tex");
(%o4) (\%o1)
tex (expr, false) возвращает свой вывод в виде строки.
(%i1) S : tex (x * y * z, false); (%o1) $$x\,y\,z$$ (%i2) S; (%o2) $$x\,y\,z$$
Задает TeX вывод для атома a, который может быть символом или именем оператора.
texput (a, s) заставляет функцию tex в своем выводе вставлять
строку s вместо a.
texput (a, s, operator_type),
где operator_type можеть принимать значения prefix, infix, postfix, nary
или nofix, заставляет функцию tex вставлять s вместо a и помещать
вставленный текст в подходящую позицию.
texput (a, [s_1, s_2], matchfix)
заставляет tex вставлять s_1 и s_2 в вывод TeX с обоих сторон аргументов атома a.
Аргументы (если их несколько) разделяются запятыми.
textpput (a, [s_1, s_2, s_3], matchfix)
заставляет tex в TeX-выводе вставлять s_1 и s_2 с обоих сторон аргументов атома a
и разделять их аргументом s_3.
Примеры:
Определение TeX вывода переменной.
(%i1) texput (me,"\\mu_e"); (%o1) \mu_e (%i2) tex (me); $$\mu_e$$ (%o2) false
Определение TeX вывода обычной функции (не оператору).
(%i1) texput (lcm, "\\mathrm{lcm}");
(%o1) \mathrm{lcm}
(%i2) tex (lcm (a, b));
$$\mathrm{lcm}\left(a , b\right)$$
(%o2) false
Определение TeX вывода префиксного оператора.
(%i1) prefix ("grad");
(%o1) grad
(%i2) texput ("grad", " \\nabla ", prefix);
(%o2) \nabla
(%i3) tex (grad f);
$$ \nabla f$$
(%o3) false
Определение вывода инфиксного оператора.
(%i1) infix ("~");
(%o1) ~
(%i2) texput ("~", " \\times ", infix);
(%o2) \times
(%i3) tex (a ~ b);
$$a \times b$$
(%o3) false
Определение вывода постфиксного оператора.
(%i1) postfix ("##");
(%o1) ##
(%i2) texput ("##", "!!", postfix);
(%o2) !!
(%i3) tex (x ##);
$$x!!$$
(%o3) false
Определение вывода n-арного оператора.
(%i1) nary ("@@");
(%o1) @@
(%i2) texput ("@@", " \\circ ", nary);
(%o2) \circ
(%i3) tex (a @@ b @@ c @@ d);
$$a \circ b \circ c \circ d$$
(%o3) false
Определение TeX вывода безфиксного оператора без аргументов.
(%i1) nofix ("foo");
(%o1) foo
(%i2) texput ("foo", "\\mathsc{foo}", nofix);
(%o2) \mathsc{foo}
(%i3) tex (foo);
$$\mathsc{foo}$$
(%o3) false
Назначение вывода матчфиксному парному оператору.
(%i1) matchfix ("<<", ">>");
(%o1) <<
(%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
(%o2) [ \langle , \rangle ]
(%i3) tex (<<a>>);
$$ \langle a \rangle $$
(%o3) false
(%i4) tex (<<a, b>>);
$$ \langle a , b \rangle $$
(%o4) false
(%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
matchfix);
(%o5) [ \langle , \rangle , \, | \,]
(%i6) tex (<<a>>);
$$ \langle a \rangle $$
(%o6) false
(%i7) tex (<<a, b>>);
$$ \langle a \, | \,b \rangle $$
(%o7) false
Выполняет команду command как отдельный процесс.
Команда отправляется на выполнение командной оболочке, заданной по умолчанию.
system поддерживается не всеми операционными системами, она в основном существует
в Unix и Unix-подобных окружениях.
Предположим, что _hist.out – список частот, который вы хотите изобразить в виде гистограммы
при помощи программы xgraph.
(%i1) (with_stdout("_hist.out",
for i:1 thru length(hist) do (
print(i,hist[i]))),
system("xgraph -bar -brw .7 -nl < _hist.out"));
Для того чтобы создать готовый график в фоновом режиме (вернуться к управлению Maxima) и удалить временный файл после завершения, сделайте так:
system("(xgraph -bar -brw .7 -nl < _hist.out; rm -f _hist.out)&")
Значение по умолчанию: false
Когда ttyoff равна true, выводимые выражения не отображаются.
Выводимые выражения по прежнему вычисляются и связываются с метками. См. labels.
ttyoff не влияет на текст, отображаемый встроенными функциями, такой как
сообщения об ошибках и вывод describe.
Вычисляет expr_1, expr_2, expr_3, ... и записывает любой сгенерированный
вывод в файл f или в выходной поток s.
Вычисленные выражения не записываются в вывод.
Вывод может генерироваться кроме прочих функциями print, display, grind.
Глобальная переменная file_output_append управляет тем, будет ли with_stdout
дописывать или переписывать заново файл f.
Если file_output_append равна true, with_stdout добавляет вывод к файлу.
Иначе with_stdout переписывает файл.
В обоих случаях, with_stdout создает файл, если тот не существовал.
with_stdout возвращает значение своего последнего аргумента.
См. также writefile.
(%i1) with_stdout ("tmp.out", for i:5 thru 10 do
print (i, "! yields", i!))$
(%i2) printfile ("tmp.out")$
5 ! yields 120
6 ! yields 720
7 ! yields 5040
8 ! yields 40320
9 ! yields 362880
10 ! yields 3628800
Начинает записывать копию сессии Maxima в filename. Все взаимодействия между пользователем и Maxima записываются в этот файл точно в том виде, в котором они показываются в консоли.
Копия печатается в формате консольного вывода, который не может быть перезагружен в Maxima.
Если хотите создать файл, содержащий выражения, с возможностью его загрузки, см. save и stringout.
save сохраняет выражения в форме Lisp, в то время как stringout сохраняет их в форме Maxima.
Результат выполнения writefile, когда filename уже существует, зависит
от реализации лежащего в основе Lisp. Выходной файл может быть стерт или дописан.
appendfile всегда дописывает файл.
Может оказаться удобным выполнить playback после writefile чтобы сохранить
отображение предыдущих взаимодействий. Так playback отображает только входные или результирующие
переменные (%i1, %o1 и т. д.), любой вывод, создаваемый печатающими выражениями в
функциях (в противоположность возвращаемому значению), не отображается функцией playback.
closefile закрывает файл, который открыла writefile или appendfile.
Previous: Файлы, Up: Ввод и вывод [Contents][Index]