| blob | 76102f4bd24e50c69d2daaad1702bd9ccc9fbefc |
1 @menu
2 * Introduction to Expressions::
3 * Nouns and Verbs::
4 * Identifiers::
5 * Inequality::
6 * Functions and Variables for Expressions::
7 @end menu
9 @c -----------------------------------------------------------------------------
10 @node Introduction to Expressions, Nouns and Verbs, Expressions, Expressions
11 @section Introduction to Expressions
12 @c -----------------------------------------------------------------------------
14 変数名として使えないたくさんの予約語があります。
15 これらを使うと、不可解な構文法エラーの原因となります。
17 @example
18 integrate next from diff
19 in at limit sum
20 for and elseif then
21 else do or if
22 unless product while thru
23 step
24 @end example
26 Maximaのほとんどのものは式です。
27 括弧で囲み、コンマで区切ることで、式の列が構成できます。
28 これは、@b{C}言語の@i{コンマ式}に似ています。
30 @example
31 (%i1) x: 3$
32 (%i2) (x: x+1, x: x^2);
33 (%o2) 16
34 (%i3) (if (x > 17) then 2 else 4);
35 (%o3) 4
36 (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
37 (%o4) 20
38 @end example
40 ループが返す値はあまり役に立たない@code{done}ですが、Maximaではループでさえ式です。
42 @example
43 (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
44 (%i2) y;
45 (%o2) done
46 @end example
48 ところが、本当に欲しいものは、たぶん、実際に値を戻す@i{コンマ式}の３番目の項を含むことで得られます。
50 @example
51 (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
52 (%i4) y;
53 (%o4) 3628800
54 @end example
56 @c -----------------------------------------------------------------------------
57 @node Nouns and Verbs, Identifiers, Introduction to Expressions, Expressions
58 @section Nouns and Verbs
59 @c -----------------------------------------------------------------------------
61 Maximaは「名詞(Noun)」演算子と「動詞(Verb)」演算子を区別します。
62 動詞は実行される演算子です。
63 名詞は式の中で、実行されずシンボルとして現れる演算子です。
64 デフォルトでは、関数名は動詞です。
65 動詞は、関数名をクォートすることで、また、@mref{nounify}関数を適用することで、
66 名詞に変えることができます。
67 名詞は、@mref{verbify}関数を適用することで動詞に変えることができます。
68 評価フラグ@mref{nouns}は、@mref{ev}を式の中の名詞を評価するようにします。
70 動詞形は、対応するLispシンボル上では、先頭のドル記号@code{$}で区別されます。
71 対照的に、
72 名詞形は、対応するLispシンボル上では、先頭のパーセント記号@code{%}で区別されます。
73 @code{'integrate}や（@code{diff}が返す）@code{'derivative}のように、
74 いくつかの名詞は特別な表示プロパティを持ちますが、ほとんどは特別な表示を持ちません。
75 デフォルトでは、表示される時、関数の名詞と動詞形は同一です。
76 グローバルフラグ@code{noundisp}は、
77 Maximaに、先頭のクォートマーク@code{'}で名詞形を表示させます。
79 @mref{noun}, @mref{nouns}, @mref{nounify}, や@mref{verbify}も参照してください。
81 例:
83 @c ===beg===
84 @c foo (x) := x^2;
85 @c foo (42);
86 @c 'foo (42);
87 @c 'foo (42), nouns;
88 @c declare (bar, noun);
89 @c bar (x) := x/17;
90 @c bar (52);
91 @c bar (52), nouns;
92 @c integrate (1/x, x, 1, 42);
93 @c 'integrate (1/x, x, 1, 42);
94 @c ev (%, nouns);
95 @c ===end===
96 @example
97 (%i1) foo (x) := x^2;
98 2
99 (%o1) foo(x) := x
100 (%i2) foo (42);
101 (%o2) 1764
102 (%i3) 'foo (42);
103 (%o3) foo(42)
104 (%i4) 'foo (42), nouns;
105 (%o4) 1764
106 (%i5) declare (bar, noun);
107 (%o5) done
108 (%i6) bar (x) := x/17;
109 x
110 (%o6) ''bar(x) := --
111 17
112 (%i7) bar (52);
113 (%o7) bar(52)
114 (%i8) bar (52), nouns;
115 52
116 (%o8) --
117 17
118 (%i9) integrate (1/x, x, 1, 42);
119 (%o9) log(42)
120 (%i10) 'integrate (1/x, x, 1, 42);
121 42
122 /
123 [ 1
124 (%o10) I - dx
125 ] x
126 /
127 1
128 (%i11) ev (%, nouns);
129 (%o11) log(42)
130 @end example
132 @opencatbox
133 @category{Evaluation}
134 @category{Nouns and verbs}
135 @closecatbox
137 @c -----------------------------------------------------------------------------
138 @node Identifiers, Inequality, Nouns and Verbs, Expressions
139 @section Identifiers
140 @c -----------------------------------------------------------------------------
142 Maximaの識別子は、アルファベット文字と、0から9までの数詞と、
143 バックスラッシュ@code{\}文字に続く任意の特別文字で構成されます。
145 もしバックスラッシュが先行するなら、数詞は、識別子の最初の文字となることができます。
146 ２番目や後の文字の数詞は、バックスラッシュが先行する必要はありません。
148 文字は、@code{declare}関数によってアルファベットと宣言することができます。
149 もし宣言されたら、識別子の中でバックスラッシュで先行する必要はありません。
150 アルファベット文字は、@code{A}から@code{Z}まで, @code{a}から @code{z}まで, @code{%},と@code{_}が初期設定です。
152 Maximaは大文字小文字を区別します。
153 識別子@code{foo}, @code{FOO}, と@code{Foo}は別の物です。
154 この点に関して@ref{Lisp and Maxima}を参照してください。
156 Maximaの識別子は、ドル記号@code{$}で始まるLispのシンボルです。
157 Maximaの中で現れる時、他の任意のLispシンボルは、クエスチョンマーク@code{?}で始まります。
158 この点に関して@ref{Lisp and Maxima}を参照してください。
160 例:
162 @c ===beg===
163 @c %an_ordinary_identifier42;
164 @c embedded\ spaces\ in\ an\ identifier;
165 @c symbolp (%);
166 @c [foo+bar, foo\+bar];
167 @c [1729, \1729];
168 @c [symbolp (foo\+bar), symbolp (\1729)];
169 @c [is (foo\+bar = foo+bar), is (\1729 = 1729)];
170 @c baz\~quux;
171 @c declare ("~", alphabetic);
172 @c baz~quux;
173 @c [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
174 @c :lisp (defvar *my-lisp-variable* '$foo)
175 @c ?\*my\-lisp\-variable\*;
176 @c ===end===
177 @example
178 (%i1) %an_ordinary_identifier42;
179 (%o1) %an_ordinary_identifier42
180 (%i2) embedded\ spaces\ in\ an\ identifier;
181 (%o2) embedded spaces in an identifier
182 (%i3) symbolp (%);
183 (%o3) true
184 (%i4) [foo+bar, foo\+bar];
185 (%o4) [foo + bar, foo+bar]
186 (%i5) [1729, \1729];
187 (%o5) [1729, 1729]
188 (%i6) [symbolp (foo\+bar), symbolp (\1729)];
189 (%o6) [true, true]
190 (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
191 (%o7) [false, false]
192 (%i8) baz\~quux;
193 (%o8) baz~quux
194 (%i9) declare ("~", alphabetic);
195 (%o9) done
196 (%i10) baz~quux;
197 (%o10) baz~quux
198 (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
199 (%o11) [false, false, false]
200 (%i12) :lisp (defvar *my-lisp-variable* '$foo)
201 *MY-LISP-VARIABLE*
202 (%i12) ?\*my\-lisp\-variable\*;
203 (%o12) foo
204 @end example
206 @opencatbox
207 @category{Syntax}
208 @closecatbox
210 @c -----------------------------------------------------------------------------
211 @node Inequality, Functions and Variables for Expressions, Identifiers, Expressions
212 @section Inequality
213 @c -----------------------------------------------------------------------------
215 Maximaは、不等式演算子@code{<}, @code{<=}, @code{>=}, @code{>}, @code{#}, @code{notequal}を持ちます。
216 条件式の記述に関しては、@code{if}を参照してください。
218 @c -----------------------------------------------------------------------------
219 @node Functions and Variables for Expressions, , Inequality, Expressions
220 @section Functions and Variables for Expressions
221 @c -----------------------------------------------------------------------------
223 @c NEEDS WORK, ESPECIALLY EXAMPLES
225 @c -----------------------------------------------------------------------------
226 @anchor{alias}
227 @deffn {関数} alias (@var{new_name_1}, @var{old_name_1}, @dots{}, @var{new_name_n}, @var{old_name_n})
229 (利用者もしくはシステム)関数や変数、配列等に対して別名を与えます。
230 任意の偶数個の引数を取ります。
232 @opencatbox
233 @category{Declarations and inferences}
234 @closecatbox
235 @end deffn
237 @c -----------------------------------------------------------------------------
238 @anchor{aliases}
239 @defvr {システム変数} aliases
240 デフォルト値: @code{[]}
242 @code{aliases}は、
243 (@mref{alias}, @mref{ordergreat}, @mref{orderless}関数によって、もしくは、
244 @mref{declare}で
245 アトムを@mref{noun}に宣言することで、設定される)
246 ユーザー定義のエーリアスを持つ
247 アトムのリストです。
249 @opencatbox
250 @category{Declarations and inferences}
251 @category{Global variables}
252 @closecatbox
253 @end defvr
255 @c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
256 @c (SHOULD BE DESCRIBED IN CONTEXT OF EACH FUNCTION WHICH RECOGNIZES IT)
258 @c -----------------------------------------------------------------------------
259 @anchor{allbut}
260 @defvr {キーワード} allbut
262 @code{part}コマンド(すなわち、@mref{part},@mref{inpart},@mref{substpart},
263 @mref{substinpart},@mref{dpart}, @mref{lpart})と共に動作します。例えば、
265 @c ===beg===
266 @c expr : e + d + c + b + a;
267 @c part (expr, [2, 5]);
268 @c ===end===
269 @example
270 (%i1) expr : e + d + c + b + a;
271 (%o1) e + d + c + b + a
272 (%i2) part (expr, [2, 5]);
273 (%o2) d + a
274 @end example
276 一方、
278 @c ===beg===
279 @c expr : e + d + c + b + a;
280 @c part (expr, allbut (2, 5));
281 @c ===end===
282 @example
283 (%i1) expr : e + d + c + b + a;
284 (%o1) e + d + c + b + a
285 (%i2) part (expr, allbut (2, 5));
286 (%o2) e + c + b
287 @end example
289 @mref{kill}も@code{allbut}を認識します。
291 @c ===beg===
292 @c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
293 @c kill (allbut (cc, dd));
294 @c [aa, bb, cc, dd];
295 @c ===end===
296 @example
297 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
298 (%o1) [11, 22, 33, 44, 55]
299 (%i2) kill (allbut (cc, dd));
300 (%o0) done
301 (%i1) [aa, bb, cc, dd];
302 (%o1) [aa, bb, 33, 44]
303 @end example
305 @code{kill(allbut(@var{a_1}, @var{a_2}, ...))}は、
306 シンボル@var{a_1}, @var{a_2}, @dots{}をキルしないよう除外して
307 @code{kill(all)}を実行します。
309 @end defvr
311 @c THE FUNCTION APRPOS IS MOVED TO THE FILE HELP.TEXI
313 @c -----------------------------------------------------------------------------
314 @anchor{args}
315 @deffn {関数} args (@var{expr})
317 @code{expr}の引数のリストを返します。
318 ここで、@code{expr}アトム以外のいかなる種類の式を取り得ます。
319 トップレベル演算子の引数だけが抽出されます;
320 @code{expr}の部分式は、要素として、または、引数のリストの要素の部分式として現れます。
322 リストの中の項目の順序は、グローバルフラグ@mref{inflag}に依存するかもしれません。
324 @code{args (@var{expr})}は、@code{substpart ("[", @var{expr}, 0)}と同値です。
325 @mref{substpart}と@mref{op}も参照してください。
327 @c NEEDS EXAMPLES
328 @opencatbox
329 @category{Expressions}
330 @closecatbox
331 @end deffn
333 @c REPHRASE
334 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
336 @c -----------------------------------------------------------------------------
337 @anchor{atom}
338 @deffn {関数} atom (@var{expr})
340 もし @var{expr}がアトム(すなわち、数や名前や文字)なら、
341 @code{true}、そうでなければ @code{false}を返します。
342 例えば、 @code{atom(5)}は @code{true}ですが、
343 (@code{a[1]}と @code{x}はバインドされていないと仮定して) @code{atom(a[1])}や @code{atom(sin(x))}は @code{false}です。
345 @opencatbox
346 @category{Expressions}
347 @category{Predicate functions}
348 @closecatbox
349 @end deffn
351 @c -----------------------------------------------------------------------------
352 @anchor{box}
353 @deffn {関数} box (@var{expr})
354 @deffnx {関数} box (@var{expr}, @var{a})
356 枠で囲んだ@var{expr}を返します。
357 返り値は、演算子として@code{box}を持ち、引数として@var{expr}を持つ式です。
358 @code{display2d}が@code{true}の時、ディスプレイ上に枠が描かれます。
360 @code{box (@var{expr}, @var{a})}は、
361 シンボル@var{a}でラベルされた枠で@var{expr}を囲みます。
362 もし枠の幅より長ければ、ラベルは切りつめられます。
364 @code{box}は引数を評価します。
365 しかしながら、枠に入れられた式は中身に評価されないので、
366 枠に入れられた式は、計算から効果的に除外されます。
368 @mref{boxchar}は、@code{box}, @mref{dpart}, @mref{lpart}関数において
369 枠を描くのに使われる文字です。
371 例:
373 @c ===beg===
374 @c box (a^2 + b^2);
375 @c a : 1234;
376 @c b : c - d;
377 @c box (a^2 + b^2);
378 @c box (a^2 + b^2, term_1);
379 @c 1729 - box (1729);
380 @c boxchar: "-";
381 @c box (sin(x) + cos(y));
382 @c ===end===
383 @example
384 (%i1) box (a^2 + b^2);
385 """""""""
386 " 2 2"
387 (%o1) "b + a "
388 """""""""
389 (%i2) a : 1234;
390 (%o2) 1234
391 (%i3) b : c - d;
392 (%o3) c - d
393 (%i4) box (a^2 + b^2);
394 """"""""""""""""""""
395 " 2 "
396 (%o4) "(c - d) + 1522756"
397 """"""""""""""""""""
398 (%i5) box (a^2 + b^2, term_1);
399 term_1""""""""""""""
400 " 2 "
401 (%o5) "(c - d) + 1522756"
402 """"""""""""""""""""
403 (%i6) 1729 - box (1729);
404 """"""
405 (%o6) 1729 - "1729"
406 """"""
407 (%i7) boxchar: "-";
408 (%o7) -
409 (%i8) box (sin(x) + cos(y));
410 -----------------
411 (%o8) -cos(y) + sin(x)-
412 -----------------
413 @end example
415 @opencatbox
416 @category{Expressions}
417 @closecatbox
418 @end deffn
420 @c -----------------------------------------------------------------------------
421 @anchor{boxchar}
422 @defvr {オプション変数} boxchar
423 デフォルト値: @code{"}
425 @code{boxchar}は、@mref{box}, @mref{dpart}, @mref{lpart}関数において
426 枠を描くのに使われる文字です。
428 式の中の枠すべては、@code{boxchar}の現在値で描かれます;
429 描画文字は枠式に保存されていません。
431 @opencatbox
432 @category{Expressions}
433 @closecatbox
434 @end defvr
436 @c NEEDS CLARIFICATION !!!
438 @c -----------------------------------------------------------------------------
439 @anchor{collapse}
440 @deffn {関数} collapse (@var{expr})
442 共通の（すなわち等しい）部分式の全てを共用と（すなわち、同じセルを使用）させることで、
443 @var{expr}を縮約し、スペースを節約します。
444 (@code{collapse}は、@code{optimize}コマンドによって使われるサブルーチンです。）
445 例えば，@code{collapse}をコールすることは、
446 @mref{save}ファイルに積んだ後役に立つかもしれません。
447 @code{collapse ([@var{expr_1}, ..., @var{expr_n}])}を使うことで、いくつかの式を
448 一緒に縮約できます。
449 同様に、@code{collapse (listarray ('A))}を実行することで、配列@code{A}の要素を縮約できます。
451 @opencatbox
452 @category{Expressions}
453 @closecatbox
454 @end deffn
456 @c NEEDS WORK
458 @c -----------------------------------------------------------------------------
459 @anchor{disolate}
460 @deffn {関数} disolate (@var{expr}, @var{x_1}, @dots{}, @var{x_n})
462 ユーザーに１つ以上の変数を同時にisolate可能にさせることを除いて、
463 @code{isolate (@var{expr}, @var{x})}に似ています。
464 例えば、もし多重積分の中で変数を変えようとしていて、それが２つ以上の積分変数を含んだ変数変換なら、これは役立つかもしれません。
465 この関数は、@file{simplification/disol.mac}から自動ロードされます。
466 @code{demo("disol")$}でデモが入手可能です。
468 @opencatbox
469 @category{Expressions}
470 @closecatbox
471 @end deffn
473 @c -----------------------------------------------------------------------------
474 @anchor{dispform}
475 @deffn {関数} dispform (@var{expr})
476 @deffnx {関数} dispform (@var{expr}, all)
478 @var{expr}の外部表現を返します。
480 @code{dispform(@var{expr})}は、主（トップレベル）演算子に関して外部表現を返します。
481 @code{dispform(@var{expr}, all)}は、@var{expr}の中の演算子すべてに関して
482 外部表現を返します。
484 @mref{part}, @mref{inpart}, @mref{inflag}も参照してください。
486 例:
488 @code{- x}の内部表現は、「-1掛ける@code{x}」ですが、
489 外部表現は、「マイナス@code{x}」です。
491 @c ===beg===
492 @c - x;
493 @c ?format (true, "~S~%", %);
494 @c dispform (- x);
495 @c ?format (true, "~S~%", %);
496 @c ===end===
497 @example
498 (%i1) - x;
499 (%o1) - x
500 (%i2) ?format (true, "~S~%", %);
501 ((MTIMES SIMP) -1 $X)
502 (%o2) false
503 (%i3) dispform (- x);
504 (%o3) - x
505 (%i4) ?format (true, "~S~%", %);
506 ((MMINUS SIMP) $X)
507 (%o4) false
508 @end example
510 @code{sqrt(x)}の内部表現は、「@code{x}の1/2乗」ですが、
511 外部表現は、「@code{x}の平方根」です。
513 @c ===beg===
514 @c sqrt (x);
515 @c ?format (true, "~S~%", %);
516 @c dispform (sqrt (x));
517 @c ?format (true, "~S~%", %);
518 @c ===end===
519 @example
520 (%i1) sqrt (x);
521 (%o1) sqrt(x)
522 (%i2) ?format (true, "~S~%", %);
523 ((MEXPT SIMP) $X ((RAT SIMP) 1 2))
524 (%o2) false
525 (%i3) dispform (sqrt (x));
526 (%o3) sqrt(x)
527 (%i4) ?format (true, "~S~%", %);
528 ((%SQRT SIMP) $X)
529 (%o4) false
530 @end example
532 オプション引数@code{all}の使用。
534 @c ===beg===
535 @c expr : sin (sqrt (x));
536 @c freeof (sqrt, expr);
537 @c freeof (sqrt, dispform (expr));
538 @c freeof (sqrt, dispform (expr, all));
539 @c ===end===
540 @example
541 (%i1) expr : sin (sqrt (x));
542 (%o1) sin(sqrt(x))
543 (%i2) freeof (sqrt, expr);
544 (%o2) true
545 (%i3) freeof (sqrt, dispform (expr));
546 (%o3) true
547 (%i4) freeof (sqrt, dispform (expr, all));
548 (%o4) false
549 @end example
551 @opencatbox
552 @category{Expressions}
553 @closecatbox
554 @end deffn
556 @c NEEDS WORK
558 @c -----------------------------------------------------------------------------
559 @anchor{dpart}
560 @deffn {関数} dpart (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
562 @mref{part}と同じ部分式を選択しますが、
563 その部分式を値として返すだけの代わりに、
564 枠の中に表示されて選択された部分式を持つ式全体を返します。
565 枠は実際に式の一部です。
567 @example
568 (%i1) dpart (x+y/z^2, 1, 2, 1);
569 y
570 (%o1) ---- + x
571 2
572 """
573 "z"
574 """
575 @end example
577 @opencatbox
578 @category{Expressions}
579 @closecatbox
580 @end deffn
582 @c -----------------------------------------------------------------------------
583 @anchor{exptisolate}
584 @defvr {オプション変数} exptisolate
585 デフォルト値: @code{false}
587 @c WHAT DOES THIS MEAN EXACTLY ??
588 @code{exptisolate}が@code{true}の時、
589 @code{isolate (expr, var)}は、
590 @code{var}を含む(@code{%e}のような)アトムの指数を検査します。
592 @c NEED EXAMPLES HERE
593 @opencatbox
594 @category{Expressions}
595 @closecatbox
596 @end defvr
598 @c -----------------------------------------------------------------------------
599 @anchor{exptsubst}
600 @defvr {オプション変数} exptsubst
601 デフォルト値: @code{false}
603 @code{exptsubst}が@code{true}の時、
604 @code{%e^(a x)}の中の@code{%e^x}へ@code{y}を代入するような代入を許します。
606 @c NEED EXAMPLES HERE
607 @opencatbox
608 @category{Exponential and logarithm functions}
609 @category{Expressions}
610 @closecatbox
611 @end defvr
613 @c -----------------------------------------------------------------------------
614 @anchor{freeof}
615 @deffn {関数} freeof (@var{x_1}, @dots{}, @var{x_n}, @var{expr})
617 もし@var{x_1}と等しい@var{expr}の部分式がないか、
618 @var{x_1}が@var{expr}の中でダミー変数としてのみ現れるか、
619 @var{x_1}が@var{expr}の中で任意の演算子の名詞形でも動詞形でもないなら、
620 @code{freeof (@var{x_1}, @var{expr})}は、@code{true}を返します。
621 そうでなければ、@code{false}を返します。
623 @code{freeof (@var{x_1}, ..., @var{x_n}, @var{expr})}は、
624 @code{freeof (@var{x_1}, @var{expr})かつ、
625 ...かつfreeof (@var{x_n}, @var{expr})}と同値です。
627 引数@var{x_1}, @dots{}, @var{x_n} は、
628 関数や変数の名前、添字付き名前、（ダブルクォートでくくられた）演算子、もしくは一般式
629 を取り得ます。
630 @code{freeof}は引数を評価します。
632 @code{freeof}は、そのままは（整理と評価の後）@var{expr}上でのみ演算し、
633 ある同値の表現が違った結果を与えるかどうかを決定しようとはしません。
634 特に、整理は、同値ですが、@var{expr}の原型とは違った要素を含む異なる式を生成するかもしれません。
636 もし式の外部にバインドを持たなければ、変数は、式の中のダミー変数です。
637 @code{freeof}によって認識されたダミー変数は、
638 和や積のインデックス、@mref{limit}の中の極限変数、
639 @mref{integrate}の定積分形の中の積分変数、
640 @mref{laplace}の中のオリジナル変数、
641 @mref{at}式の中の形式変数、
642 @mref{lambda}式の中の引数です。
644 @code{integrate}の不定積分形は、積分変数から自由では@i{ありません}。
646 例:
648 引数は、関数、変数、添字付き名前、演算子、式の名前です。
649 @code{freeof (a, b, expr)}は
650 @code{freeof (a, expr) and freeof (b, expr)}と同値です。
652 @example
653 (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
654 d + c 3
655 (%o1) cos(a ) b z
656 1
657 (%i2) freeof (z, expr);
658 (%o2) false
659 (%i3) freeof (cos, expr);
660 (%o3) false
661 (%i4) freeof (a[1], expr);
662 (%o4) false
663 (%i5) freeof (cos (a[1]), expr);
664 (%o5) false
665 (%i6) freeof (b^(c+d), expr);
666 (%o6) false
667 (%i7) freeof ("^", expr);
668 (%o7) false
669 (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
670 (%o8) true
671 @end example
673 @code{freeof}は引数を評価します。
675 @example
676 (%i1) expr: (a+b)^5$
677 (%i2) c: a$
678 (%i3) freeof (c, expr);
679 (%o3) false
680 @end example
682 @code{freeof}は、同値の式を考慮しません。
683 整理は、同値ですが異なる式を生成します。
685 @example
686 (%i1) expr: (a+b)^5$
687 (%i2) expand (expr);
688 5 4 2 3 3 2 4 5
689 (%o2) b + 5 a b + 10 a b + 10 a b + 5 a b + a
690 (%i3) freeof (a+b, %);
691 (%o3) true
692 (%i4) freeof (a+b, expr);
693 (%o4) false
694 (%i5) exp (x);
695 x
696 (%o5) %e
697 (%i6) freeof (exp, exp (x));
698 (%o6) true
699 @end example
701 和や定積分はダミー変数から自由です。
702 不定積分は積分変数から自由ではありません。
704 @example
705 (%i1) freeof (i, 'sum (f(i), i, 0, n));
706 (%o1) true
707 (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
708 (%o2) true
709 (%i3) freeof (x, 'integrate (x^2, x));
710 (%o3) false
711 @end example
713 @opencatbox
714 @category{Expressions}
715 @closecatbox
716 @end deffn
718 @c -----------------------------------------------------------------------------
719 @anchor{inflag}
720 @defvr {オプション変数} inflag
721 デフォルト値: @code{false}
723 @code{inflag}が@code{true}の時、
724 部分抽出のための関数は、@code{expr}の内部形式を検査します。
726 整理器は式を再順序付けすることに注意してください。
727 例えば、
728 もし@code{inflag}が@code{true}なら、
729 @code{first (x + y)}は、@code{x}を返し、
730 もしif @code{inflag}が@code{false}なら、@code{y}を返します。
731 (@code{first (y + x)}は同じ結果を与えます。)
733 また、@code{inflag}を@code{true}に設定し、@mref{part}や@mref{substpart}をコールすることは、
734 @mref{inpart}や@mref{substinpart}をコールすることと同じです。
736 @code{inflag}の設定に影響される関数は以下の通りです:
737 @mref{part}, @mref{substpart}, @mref{first}, @mref{rest}, @mref{last}, @mref{length}, @mref{for} ... @code{in}構成子,
738 @mref{map}, @mref{fullmap}, @mref{maplist}, @mref{reveal}, @mref{pickapart}。
740 @c NEED EXAMPLES HERE
741 @opencatbox
742 @category{Expressions}
743 @closecatbox
744 @end defvr
746 @c NEEDS WORK
748 @c -----------------------------------------------------------------------------
749 @anchor{inpart}
750 @deffn {関数} inpart (@var{expr}, @var{n_1}, ..., @var{n_k})
752 @code{part}に似ていますが、表示形式ではなく内部表現上で機能し、
753 フォーマットが実行されないのでより速いかもしれません。
754 （内部形式での変数の順序はしばしば表示形式でのそれと異なるので）
755 和や積の中の部分式の順序や、
756 （以下の演算子は式から取り除かれるので）単項マイナス、引き算、割り算を扱う際の部分式の順序
757 に関して注意が必要です。
758 @code{part (x+y, 0)}や@code{inpart (x+y, 0)}は、
759 @code{+}を返しますが、
760 演算子を参照するため、"で囲まれたものになります。
761 例えば、@code{... if inpart (%o9,0) = "+" then ...}.
763 例:
765 @example
766 (%i1) x + y + w*z;
767 (%o1) w z + y + x
768 (%i2) inpart (%, 3, 2);
769 (%o2) z
770 (%i3) part (%th (2), 1, 2);
771 (%o3) z
772 (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
773 g(x + 1)
774 (%o4) limit f(x)
775 x -> 0-
776 (%i5) inpart (%, 1, 2);
777 (%o5) g(x + 1)
778 @end example
780 @opencatbox
781 @category{Expressions}
782 @closecatbox
783 @end deffn
785 @c NEEDS WORK
787 @c -----------------------------------------------------------------------------
788 @anchor{isolate}
789 @deffn {関数} isolate (@var{expr}, @var{x})
790 和であり、中間式ラベル(それらは@code{%t1}, @code{%t2}, ...のようなアトムなシンボルです)
791 で置き換えられた@var{x}を含まない部分式を含む@var{expr}を返します。
792 興味のある変数を含まない部分式の不必要な展開を避けるのに、これはしばしば役立ちます。
793 中間ラベルは部分式にバインドされているので、
794 それらが現れた式を評価することで、それらをすべて元に代入することができます。
796 もし@mref{exptisolate} (デフォルト値: @code{false})が@code{true}なら、
797 @code{isolate}は、@var{x}を含むか、(@code{%e}のような)アトムの指数を検査します。
799 もし@code{isolate_wrt_times}が@code{true}なら、
800 @code{isolate}は積に関してもisolateします。
801 @mref{isolate_wrt_times}を参照してください。
803 サンプルを見るには、@code{example (isolate)}を実行してください。
805 @opencatbox
806 @category{Expressions}
807 @closecatbox
808 @end deffn
810 @c NEEDS WORK
812 @c -----------------------------------------------------------------------------
813 @anchor{isolate_wrt_times}
814 @defvr {オプション変数} isolate_wrt_times
815 デフォルト値: @code{false}
817 @code{isolate_wrt_times}が@code{true}の時,
818 @code{isolate}は、積に関してもisolateします。
819 例えば、スイッチの両方の設定を比較すると、
821 @example
822 (%i1) isolate_wrt_times: true$
823 (%i2) isolate (expand ((a+b+c)^2), c);
825 (%t2) 2 a
828 (%t3) 2 b
831 2 2
832 (%t4) b + 2 a b + a
834 2
835 (%o4) c + %t3 c + %t2 c + %t4
836 (%i4) isolate_wrt_times: false$
837 (%i5) isolate (expand ((a+b+c)^2), c);
838 2
839 (%o5) c + 2 b c + 2 a c + %t4
840 @end example
842 @opencatbox
843 @category{Expressions}
844 @closecatbox
845 @end defvr
847 @c NEEDS EXAMPLES
849 @c -----------------------------------------------------------------------------
850 @anchor{listconstvars}
851 @defvr {オプション変数} listconstvars
852 デフォルト値: @code{false}
854 @code{listconstvars}が@code{true}の時、
855 @mref{listofvars}は、@code{%e}, @code{%pi}, @code{%i}や
856 定数と宣言された任意の変数を、
857 もしそれらが、@code{listofvars}がコールされた式の中で現れたなら、
858 戻り値のリストの中に含みます。
859 デフォルトはこれらを省略します。
861 @opencatbox
862 @category{Expressions}
863 @closecatbox
864 @end defvr
866 @c -----------------------------------------------------------------------------
867 @anchor{listdummyvars}
868 @defvr {オプション変数} listdummyvars
869 デフォルト値: @code{true}
871 @code{listdummyvars}が@code{false}の時、
872 式の中の「ダミー変数」は、@mref{listofvars}が返すリストの中に含まれません。
873 （「ダミー変数」の意味は@mref{freeof}で与えられているものです。
874 「ダミー変数」は、和や積のインデックスや、極限変数、定積分変数のように数学的なものです。）
876 例:
878 @example
879 (%i1) listdummyvars: true$
880 (%i2) listofvars ('sum(f(i), i, 0, n));
881 (%o2) [i, n]
882 (%i3) listdummyvars: false$
883 (%i4) listofvars ('sum(f(i), i, 0, n));
884 (%o4) [n]
885 @end example
887 @opencatbox
888 @category{Expressions}
889 @closecatbox
890 @end defvr
892 @c NEEDS WORK
894 @c -----------------------------------------------------------------------------
895 @anchor{listofvars}
896 @deffn {関数} listofvars (@var{expr})
898 @var{expr}の中の変数のリストを返します。
900 もし@mref{listconstvars}が@code{true}なら、
901 @code{listofvars}は、@code{%e}, @code{%pi}, @code{%i}や
902 定数と宣言された任意の変数を、
903 もしそれらが、@var{expr}の中で現れたなら、
904 戻り値のリストの中に含みます。
905 デフォルトはこれらを省略します。
907 変数のリストのなかの「ダミー変数」を除外したり含めたりするには、オプション変数 @mref{listdummyvars}も参照してください。
909 @example
910 (%i1) listofvars (f (x[1]+y) / g^(2+a));
911 (%o1) [g, a, x , y]
912 1
913 @end example
915 @opencatbox
916 @category{Expressions}
917 @closecatbox
918 @end deffn
920 @c NEEDS WORK
922 @c -----------------------------------------------------------------------------
923 @anchor{lfreeof}
924 @deffn {関数} lfreeof (@var{list}, @var{expr})
926 @var{list}のそれぞれのメンバー@var{m}に関して、
927 @code{freeof (@var{m}, @var{expr})}をコールします。
928 もし@code{freeof}のコールのいずれかが@code{false}を返すなら、
929 @code{false}を返し、そうでなければ、@code{true}を返します。
931 @opencatbox
932 @category{Expressions}
933 @closecatbox
934 @end deffn
936 @c NEEDS WORK
938 @c -----------------------------------------------------------------------------
939 @anchor{lpart}
940 @deffn {関数} lpart (@var{label}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
942 @code{dpart}に似ていますが、ラベルされた枠を使います。
943 ラベルされた枠は、@code{dpart}によって生成されたものに似ていますが、
944 トップラインの中での名前を持ちます。
946 @opencatbox
947 @category{Expressions}
948 @closecatbox
949 @end deffn
951 @c NEEDS CLARIFICATION, EXAMPLES
953 @c -----------------------------------------------------------------------------
954 @anchor{mainvar}
955 @defvr {宣言} mainvar
957 変数を@code{mainvar}に宣言することができます。
958 アトムに関する順序付けスケールは本質的に以下の通りです:
959 数 < 定数 (例えば、@code{%e}, @code{%pi}) < スカラー < 他の変数 < mainvars。
960 例えば、@code{(declare (x, mainvar), expand ((x+y)^4))}を伴う
961 @code{expand ((X+Y)^4)}。
962 （上の特長を使うことを選択したなら注意が必要なことに注意してください。
963 例えば、もし、
964 @code{mainvar}である@code{x}を含む式を、@code{mainvar}でない@code{x}を含む式から引くなら、
965 もし打ち消しが起こるようにするなら、
966 例えば@code{ev (expr, simp)}のような再整理が必要かもしれません。
967 また、@code{mainvar}である@code{x}を含む式を保存するなら、
968 @code{x}もまた保存すべきです。）
970 @opencatbox
971 @category{Declarations and inferences}
972 @category{Expressions}
973 @closecatbox
974 @end defvr
976 @c NEEDS CLARIFICATION, EXAMPLES
978 @c -----------------------------------------------------------------------------
979 @anchor{noun}
980 @defvr {宣言} noun
982 @code{noun}は、@mref{declare}コマンドのオプションの１つです。
983 関数を「名詞」に宣言するのに使います。
984 「名詞」は、自動的には評価されないことを意味します。
986 @opencatbox
987 @category{Nouns and verbs}
988 @closecatbox
989 @end defvr
991 @c NEEDS CLARIFICATION, EXAMPLES
993 @c -----------------------------------------------------------------------------
994 @anchor{noundisp}
995 @defvr {オプション変数} noundisp
996 デフォルト値: @code{false}
998 @code{noundisp}が@code{true}の時、
999 名詞は、単一クォートで表示されます。
1000 このスイッチは、関数定義を表示する時には、常に@code{true}です。
1002 @opencatbox
1003 @category{Display flags and variables}
1004 @category{Nouns and verbs}
1005 @closecatbox
1006 @end defvr
1008 @c NEEDS WORK
1010 @c -----------------------------------------------------------------------------
1011 @anchor{nounify}
1012 @deffn {関数} nounify (@var{f})
1014 関数名@var{f}の名詞形を返します。
1015 もし動詞関数の名前をまるで名詞のように参照したいなら、これが必要とされます。
1016 もしある引数に関して関数が評価されないなら、
1017 いくつかの動詞関数は名詞形を返すことに注意してください。
1018 これは、クォートに関数コールが続く時、返される形式でもあります。
1020 @mref{verbify}も参照してください。
1022 @opencatbox
1023 @category{Nouns and verbs}
1024 @closecatbox
1025 @end deffn
1027 @c NEEDS WORK
1029 @c -----------------------------------------------------------------------------
1030 @anchor{nterms}
1031 @deffn {関数} nterms (@var{expr})
1033 もし完全に展開されて、項の打ち消しや結合が起こらない場合の、@var{expr}が持つ
1034 項の数を返します。
1035 @code{sin (@var{expr})}, @code{sqrt (@var{expr})}, @code{exp (@var{expr})},
1036 などのような式は、
1037 @var{expr}が（もしそれが和なら）
1038 どんなにたくさんの項を持とうと、１項と数えます。
1040 @opencatbox
1041 @category{Expressions}
1042 @closecatbox
1043 @end deffn
1045 @c NEEDS WORK
1047 @c -----------------------------------------------------------------------------
1048 @anchor{op}
1049 @deffn {関数} op (@var{expr})
1051 式@var{expr}のメインの演算子を返します。
1052 @code{op (@var{expr})}は@code{part (@var{expr}, 0)}と同値です。
1054 @code{op}は、
1055 もしメインの演算子が組み込みもしくはユーザー定義の前置、二項もしくはn項中置、後置、マッチフィックスもしくは無項演算子なら、文字列を返します。
1056 そうでなければ、
1057 もし@var{expr}が添字付き関数式なら、
1058 @code{op}は添字付き関数を返します;
1059 この場合、戻り値はアトムではありません。
1060 そうでなければ、
1061 @var{expr}は配列関数もしくは通常の関数式であり、
1062 @code{op}はシンボルを返します。
1064 @code{op}はグローバルフラグ@mref{inflag}の値を見ています。
1066 @code{op}は引数を評価します。
1068 @mref{args}も参照してください。
1070 例:
1072 @c ===beg===
1073 @c stringdisp: true$
1074 @c op (a * b * c);
1075 @c op (a * b + c);
1076 @c op ('sin (a + b));
1077 @c op (a!);
1078 @c op (-a);
1079 @c op ([a, b, c]);
1080 @c op ('(if a > b then c else d));
1081 @c op ('foo (a));
1082 @c prefix (foo);
1083 @c op (foo a);
1084 @c op (F [x, y] (a, b, c));
1085 @c op (G [u, v, w]);
1086 @c ===end===
1087 @example
1088 (%i1) stringdisp: true$
1089 (%i2) op (a * b * c);
1090 (%o2) "*"
1091 (%i3) op (a * b + c);
1092 (%o3) "+"
1093 (%i4) op ('sin (a + b));
1094 (%o4) sin
1095 (%i5) op (a!);
1096 (%o5) "!"
1097 (%i6) op (-a);
1098 (%o6) "-"
1099 (%i7) op ([a, b, c]);
1100 (%o7) "["
1101 (%i8) op ('(if a > b then c else d));
1102 (%o8) "if"
1103 (%i9) op ('foo (a));
1104 (%o9) foo
1105 (%i10) prefix (foo);
1106 (%o10) "foo"
1107 (%i11) op (foo a);
1108 (%o11) "foo"
1109 (%i12) op (F [x, y] (a, b, c));
1110 (%o12) F
1111 x, y
1112 (%i13) op (G [u, v, w]);
1113 (%o13) G
1114 @end example
1116 @opencatbox
1117 @category{Expressions}
1118 @category{Operators}
1119 @closecatbox
1120 @end deffn
1122 @c NEEDS WORK
1124 @c -----------------------------------------------------------------------------
1125 @anchor{operatorp}
1126 @deffn {関数} operatorp (@var{expr}, @var{op})
1127 @deffnx {関数} operatorp (@var{expr}, [@var{op_1}, @dots{}, @var{op_n}])
1129 もし@var{op}が@var{expr}の演算子に等しければ、
1130 @code{operatorp (@var{expr}, @var{op})}は@code{true}を返します。
1132 もしある要素@var{op_1}, ..., @var{op_n}が@var{expr}に等しければ、
1133 @code{operatorp (@var{expr}, [@var{op_1}, @dots{}, @var{op_n}])}は@code{true}を返します。
1135 @opencatbox
1136 @category{Operators}
1137 @category{Predicate functions}
1138 @closecatbox
1139 @end deffn
1141 @c NEEDS CLARIFICATION, EXAMPLES
1143 @c -----------------------------------------------------------------------------
1144 @anchor{option_opsubst}
1145 @defvr {オプション変数} opsubst
1146 デフォルト値: @code{true}
1148 @code{opsubst}が@code{false}の時、
1149 @mref{subst}は、式の中の演算子に代入を試みません。
1150 例えば、
1151 @code{(opsubst: false, subst (x^2, r, r+r[0]))}は機能します。
1153 @opencatbox
1154 @category{Expressions}
1155 @closecatbox
1156 @end defvr
1158 @c NEEDS WORK
1160 @c -----------------------------------------------------------------------------
1161 @anchor{optimize}
1162 @deffn {関数} optimize (@var{expr})
1164 @var{expr}と同じ値と副作用を生成する式を返しますが、
1165 共通の部分式の再計算を避けることによってより効率的に行います。
1166 @code{optimize}は、共通の部分式すべてが共用されるように引数を縮約する副作用も持ちます。
1167 例を見るには、@code{example (optimize)}を実行してください。
1169 @opencatbox
1170 @category{Expressions}
1171 @closecatbox
1172 @end deffn
1175 @c -----------------------------------------------------------------------------
1176 @anchor{optimprefix}
1177 @defvr {オプション変数} optimprefix
1178 デフォルト値: @code{%}
1180 @code{optimprefix}は@mref{optimize}コマンドによって生成されたシンボルのために
1181 使われる前置です。
1183 @opencatbox
1184 @category{Expressions}
1185 @closecatbox
1186 @end defvr
1188 @c -----------------------------------------------------------------------------
1189 @anchor{ordergreat}
1190 @anchor{orderless}
1191 @deffn {関数} ordergreat (@var{v_1}, @dots{}, @var{v_n})
1192 @deffnx {関数} orderless (@var{v_1}, @dots{}, @var{v_n})
1194 @code{ordergreat}は、
1195 @var{v_1}が@var{v_2}に続き、@var{v_2}は、@dots{}, @var{v_n}に続き、
1196 そして@var{v_n}は 引数として言及されなかった他の任意のシンボルに続くというように、
1197 Maximaの式の標準の順序付けを変えます。
1199 @code{orderless}は、
1200 @var{v_1}が@var{v_2}に先行し、@var{v_2}は、@dots{}, @var{v_n}に先行し、
1201 そして@var{v_n}は 引数として言及されなかった他の任意のシンボルに先行するというように、
1202 Maximaの式の標準の順序付けを変えます。
1204 @code{ordergreat}や@code{orderless}によって確立される順序は、
1205 @mref{unorder}によって解消されます。
1206 @code{ordergreat}や@code{orderless}は、
1207 @code{unorder}がコールされるまで、
1208 それぞれ一度だけコールすることができます;
1209 @code{ordergreat}の@code{orderless}の最後のコールだけが効果を持ちます。
1211 @mref{ordergreatp}も参照してください。
1213 @opencatbox
1214 @category{Expressions}
1215 @closecatbox
1216 @end deffn
1218 @c -----------------------------------------------------------------------------
1219 @anchor{ordergreatp}
1220 @anchor{orderlessp}
1221 @deffn {関数} ordergreatp (@var{expr_1}, @var{expr_2})
1222 @deffnx {関数} orderlessp (@var{expr_1}, @var{expr_2})
1224 もしMaximaの式の標準の順序付けの中で、@var{expr_1}が@var{expr_2}に続くなら、
1225 @code{ordergreatp}は、@code{true}を返し、
1226 そうでなければ、@code{false}を返します。
1228 もしMaximaの式の標準の順序付けの中で、@var{expr_1}が@var{expr_2}に先行するなら、
1229 @code{orderlessp}は、@code{true}を返し、
1230 そうでなければ、@code{false}を返します。
1232 Maximaのアトムや式のすべては、@code{ordergreatp}と@code{orderlessp}の下で比較可能です。これらの述語論理が推移的でないような式の孤立した例はあるけれども; それはバグです。
1234 アトム（シンボル、数リテラル、文字列）の標準の順序付けは以下の通りです。
1236 (整数と浮動小数点)は以下に先行
1237 (多倍長浮動小数点)は以下に先行
1238 (宣言された定数)は以下に先行
1239 (文字列)は以下に先行
1240 (宣言されたスカラー)は以下に先行
1241 (@mref{orderless}の最初の引数)は以下に先行
1242 @dots{}は以下に先行
1243 (@code{orderless}の最後の引数)
1244 は以下に先行
1245 (他のシンボル)
1246 は以下に先行
1247 (@mref{ordergreat}の最後の引数)は以下に先行
1248 @dots{}は以下に先行
1249 (@code{ordergreat}の最初の引数)は以下に先行
1250 (宣言されたメイン変数)
1252 アトムでない式に関して、標準の順序付けはアトムの順序付けから演繹されます。
1253 組み込みの@code{+} @code{*} @code{^}演算子に関しては、
1254 順序付けは簡単にはまとめられません。
1255 他の組み込み演算子と他の半数や演算子、式すべてに関しては、
1256 （最初の引数から始めて）それらの引数によって順序付けされ、
1257 それから演算子や関数の名前によって順序付けされます。
1258 添字付き式の場合、
1259 添字付きのシンボルは演算子と、添字は引数と考えられます。
1261 式の標準の順序付けは、関数@mref{ordergreat}と@mref{orderless}と、
1262 @mref{mainvar}, @mref{constant}, @code{scalar}宣言によって変更されます。
1264 @mref{sort}も参照してください。
1266 例:
1268 通常のシンボルや定数の順序付け。
1269 @code{%pi}は数値に従って順序付けされないことに注意してください。
1271 @c ===beg===
1272 @c stringdisp : true;
1273 @c sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
1274 @c ===end===
1275 @example
1276 (%i1) stringdisp : true;
1277 (%o1) true
1278 (%i2) sort([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
1279 (%o2) [3, 3.0, 4, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]
1280 @end example
1282 @code{ordergreat}、@code{orderless}関数の効果。
1284 @c ===beg===
1285 @c sort ([M, H, K, T, E, W, G, A, P, J, S]);
1286 @c ordergreat (S, J);
1287 @c orderless (M, H);
1288 @c sort ([M, H, K, T, E, W, G, A, P, J, S]);
1289 @c ===end===
1290 @example
1291 (%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1292 (%o1) [A, E, G, H, J, K, M, P, S, T, W]
1293 (%i2) ordergreat (S, J);
1294 (%o2) done
1295 (%i3) orderless (M, H);
1296 (%o3) done
1297 (%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1298 (%o4) [M, H, A, E, G, K, P, T, W, J, S]
1299 @end example
1301 @code{mainvar}, @code{constant}, @code{scalar}宣言の効果
1303 @c ===beg===
1304 @c sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1305 @c declare (aa, mainvar);
1306 @c declare ([baz, quux], constant);
1307 @c declare ([A1, B1], scalar);
1308 @c sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1309 @c ===end===
1310 @example
1311 (%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1312 (%o1) [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
1313 (%i2) declare (aa, mainvar);
1314 (%o2) done
1315 (%i3) declare ([baz, quux], constant);
1316 (%o3) done
1317 (%i4) declare ([A1, B1], scalar);
1318 (%o4) done
1319 (%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1320 (%o5) [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]
1321 @end example
1323 アトムでない式の順序付け
1325 @c ===beg===
1326 @c sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n),
1327 @c f(n, 1)]);
1328 @c sort ([foo(1), X[1], X[k], foo(k), 1, k]);
1329 @c ===end===
1330 @example
1331 (%i1) sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n),
1332 f(n, 1)]);
1333 (%o1) [1, 2, f(1), g(1), g(1, 2), f(2), f(2, 1), n, g(n),
1334 f(n, 1)]
1335 (%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
1336 (%o2) [1, foo(1), X , k, foo(k), X ]
1337 1 k
1338 @end example
1340 @opencatbox
1341 @category{Expressions}
1342 @category{Predicate functions}
1343 @closecatbox
1344 @end deffn
1346 @c NEEDS WORK
1348 @c -----------------------------------------------------------------------------
1349 @anchor{part}
1350 @deffn {関数} part (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
1352 @code{expr}の表示形式のパーツを返します。
1353 @code{expr}の最初のパーツ@var{n_1}、それから、パーツ@var{n_2}などなど、
1354 結果は、@code{expr}のパーツ@var{n_1}のパーツ@var{n_2}の, ...パーツ@var{n_k}です。
1355 もし添字が指定されないなら、@code{expr}を返します。
1357 @code{part}はリストの要素や行列の行を得るのに使うことができます。
1359 @c "If the last argument to a part function" => FOLLOWING APPLIES TO OTHER FUNCTIONS ??
1360 @c ATTEMPT TO VERIFY; IF SO, COPY THIS COMMENTARY TO DESCRIPTIONS OF OTHER FUNCTIONS
1361 もし@code{part}関数の最後の引数がインデックスのリストなら、
1362 それぞれがリストのインデックスに対応するいくつかの部分式が抽出されます。
1363 従って、@code{part (x + y + z, [1, 3])}は@code{z+x}です。
1365 @mref{piece}は、@code{part}関数を使ったとき、選択された最後の式を保持します。
1366 それは関数の実行中にセットされ、以下で示すように、関数自身の中で参照されることもあります。
1368 もし@mref{partswitch}が@code{true}に設定されているなら、
1369 式の選択されたパーツが存在しないとき、@code{end}が返されます。
1370 そうでなければ、エラーメッセージが出力されます。
1372 @mref{inpart}, @mref{substpart}, @mref{substinpart}, @mref{dpart}, @mref{lpart}も参照してください。
1374 例:
1376 @c ===beg===
1377 @c part(z+2*y+a,2);
1378 @c part(z+2*y+a,[1,3]);
1379 @c part(z+2*y+a,2,1);
1380 @c ===end===
1381 @example
1382 (%i1) part(z+2*y+a,2);
1383 (%o1) 2 y
1384 (%i2) part(z+2*y+a,[1,3]);
1385 (%o2) z + a
1386 (%i3) part(z+2*y+a,2,1);
1387 (%o3) 2
1388 @end example
1390 @code{example (part)}でさらに例を見ることができます。
1392 @opencatbox
1393 @category{Expressions}
1394 @closecatbox
1395 @end deffn
1397 @c NEEDS WORK
1399 @c -----------------------------------------------------------------------------
1400 @anchor{partition}
1401 @deffn {関数} partition (@var{expr}, @var{x})
1403 ２つの式のリストを返します。
1404 それらは、
1405 (1)（積なら）@var{expr}の因子、（和なら）@var{expr}項、
1406 もしくは、（リストなら）@var{x}を含まないリストと、
1407 (2)@var{x}を含む因子、項、リスト、
1408 です。
1410 例:
1412 @example
1413 (%i1) partition (2*a*x*f(x), x);
1414 (%o1) [2 a, x f(x)]
1415 (%i2) partition (a+b, x);
1416 (%o2) [b + a, 0]
1417 (%i3) partition ([a, b, f(a), c], a);
1418 (%o3) [[b, c], [a, f(a)]]
1419 @end example
1421 @opencatbox
1422 @category{Expressions}
1423 @closecatbox
1424 @end deffn
1426 @c NEEDS EXAMPLE
1428 @c -----------------------------------------------------------------------------
1429 @anchor{partswitch}
1430 @defvr {オプション変数} partswitch
1431 デフォルト値: @code{false}
1433 @code{partswitch}が@code{true}の時、
1434 式の選択された部分が存在しない時、@code{end}が返されます。
1435 そうでない時は、エラーメッセージが出力されます。
1437 @opencatbox
1438 @category{Expressions}
1439 @closecatbox
1440 @end defvr
1442 @c -----------------------------------------------------------------------------
1443 @anchor{pickapart}
1444 @deffn {関数} pickapart (@var{expr}, @var{n})
1446 中間式ラベルを、深さが整数@var{n}での@var{expr}の部分式に割り当てます。
1447 より大きなもしくは小さな深さでの部分式はラベルに割り当てられません。
1448 @code{pickapart}は、元の式@var{expr}と同値の中間式の項による式を返します。
1450 @mref{part}, @mref{dpart}, @mref{lpart}, @mref{inpart},
1451 @mref{reveal}も参照してください。
1453 例:
1455 @example
1456 (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
1457 2
1458 sin(x ) b + a
1459 (%o1) - log(sqrt(x + 1) + 1) + ------- + -----
1460 3 2
1461 (%i2) pickapart (expr, 0);
1462 @group
1463 2
1464 sin(x ) b + a
1465 (%t2) - log(sqrt(x + 1) + 1) + ------- + -----
1466 3 2
1467 @end group
1468 (%o2) %t2
1469 (%i3) pickapart (expr, 1);
1471 (%t3) - log(sqrt(x + 1) + 1)
1474 2
1475 sin(x )
1476 (%t4) -------
1477 3
1480 b + a
1481 (%t5) -----
1482 2
1484 (%o5) %t5 + %t4 + %t3
1485 (%i5) pickapart (expr, 2);
1487 (%t6) log(sqrt(x + 1) + 1)
1490 2
1491 (%t7) sin(x )
1494 (%t8) b + a
1496 %t8 %t7
1497 (%o8) --- + --- - %t6
1498 2 3
1499 (%i8) pickapart (expr, 3);
1501 (%t9) sqrt(x + 1) + 1
1504 2
1505 (%t10) x
1507 b + a sin(%t10)
1508 (%o10) ----- - log(%t9) + ---------
1509 2 3
1510 (%i10) pickapart (expr, 4);
1512 (%t11) sqrt(x + 1)
1513 @group
1514 2
1515 sin(x ) b + a
1516 (%o11) ------- + ----- - log(%t11 + 1)
1517 3 2
1518 @end group
1519 (%i11) pickapart (expr, 5);
1521 (%t12) x + 1
1523 2
1524 sin(x ) b + a
1525 (%o12) ------- + ----- - log(sqrt(%t12) + 1)
1526 3 2
1527 (%i12) pickapart (expr, 6);
1528 2
1529 sin(x ) b + a
1530 (%o12) ------- + ----- - log(sqrt(x + 1) + 1)
1531 3 2
1532 @end example
1534 @opencatbox
1535 @category{Expressions}
1536 @closecatbox
1537 @end deffn
1539 @c NEEDS WORK
1541 @c -----------------------------------------------------------------------------
1542 @anchor{piece}
1543 @defvr {システム変数} piece
1545 @code{part}関数を使った時選択された最後の式を返します。
1546 @c WHAT DOES THIS MEAN EXACTLY ??
1547 関数の実行中に設定され、関数そのものの中で参照されることもあります。
1549 @c NEED "SEE ALSO" TO POINT TO LIST OF ALL RELEVANT FUNCTIONS
1551 @opencatbox
1552 @category{Expressions}
1553 @closecatbox
1554 @end defvr
1556 @c -----------------------------------------------------------------------------
1557 @anchor{psubst}
1558 @deffn {関数} psubst (@var{list}, @var{expr})
1559 @deffnx {関数} psubst (@var{a}, @var{b}, @var{expr})
1561 @code{psubst(@var{a}, @var{b}, @var{expr})}は@code{subst}に似ています。
1562 @code{subst}を参照してください。
1565 @code{subst}とは違って、
1566 もし最初の引数@var{list}が等式のリストなら、
1567 関数@code{psubst}は平行代入します。
1569 並列代入するには、@mref{sublis}も参照してください。
1571 例:
1573 最初の例は、
1574 @code{psubst}を使った平行代入を示します。
1575 二番目の例は、
1576 関数@code{subst}での結果を示します。それは逐次代入します。
1578 @c ===beg===
1579 @c psubst ([a^2=b, b=a], sin(a^2) + sin(b));
1580 @c subst ([a^2=b, b=a], sin(a^2) + sin(b));
1581 @c ===end===
1582 @example
1583 (%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
1584 (%o4) sin(b) + sin(a)
1585 (%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
1586 (%o5) 2 sin(a)
1587 @end example
1589 @opencatbox
1590 @category{Expressions}
1591 @closecatbox
1592 @end deffn
1594 @c -----------------------------------------------------------------------------
1595 @anchor{rembox}
1596 @deffn {関数} rembox (@var{expr}, unlabelled)
1597 @deffnx {関数} rembox (@var{expr}, @var{label})
1598 @deffnx {関数} rembox (@var{expr})
1599 @var{expr}から枠を取り除きます。
1601 @code{rembox (@var{expr}, unlabelled)}は、
1602 @var{expr}からラベルされていない枠すべてを取り除きます。
1604 @code{rembox (@var{expr}, @var{label})}は、
1605 @var{label}を負う枠のみを取り除きます。
1607 @code{rembox (@var{expr})}は、ラベルされているか否か問わず、
1608 枠すべてを取り除きます。
1610 枠は、@mref{box}, @mref{dpart}, @mref{lpart}関数によって描画されます。
1612 例:
1614 @c ===beg===
1615 @c expr: (a*d - b*c)/h^2 + sin(%pi*x);
1616 @c dpart (dpart (expr, 1, 1), 2, 2);
1617 @c expr2: lpart (BAR, lpart (FOO, %, 1), 2);
1618 @c rembox (expr2, unlabelled);
1619 @c rembox (expr2, FOO);
1620 @c rembox (expr2, BAR);
1621 @c rembox (expr2);
1622 @c ===end===
1623 @example
1624 (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
1625 @group
1626 a d - b c
1627 (%o1) sin(%pi x) + ---------
1628 2
1629 h
1630 @end group
1631 (%i2) dpart (dpart (expr, 1, 1), 2, 2);
1632 """"""" a d - b c
1633 (%o2) sin("%pi x") + ---------
1634 """"""" """"
1635 " 2"
1636 "h "
1637 """"
1638 (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
1639 FOO""""""""""" BAR""""""""
1640 " """"""" " "a d - b c"
1641 (%o3) "sin("%pi x")" + "---------"
1642 " """"""" " " """" "
1643 """""""""""""" " " 2" "
1644 " "h " "
1645 " """" "
1646 """""""""""
1647 (%i4) rembox (expr2, unlabelled);
1648 BAR""""""""
1649 FOO""""""""" "a d - b c"
1650 (%o4) "sin(%pi x)" + "---------"
1651 """""""""""" " 2 "
1652 " h "
1653 """""""""""
1654 (%i5) rembox (expr2, FOO);
1655 BAR""""""""
1656 """"""" "a d - b c"
1657 (%o5) sin("%pi x") + "---------"
1658 """"""" " """" "
1659 " " 2" "
1660 " "h " "
1661 " """" "
1662 """""""""""
1663 (%i6) rembox (expr2, BAR);
1664 FOO"""""""""""
1665 " """"""" " a d - b c
1666 (%o6) "sin("%pi x")" + ---------
1667 " """"""" " """"
1668 """""""""""""" " 2"
1669 "h "
1670 """"
1671 (%i7) rembox (expr2);
1672 a d - b c
1673 (%o7) sin(%pi x) + ---------
1674 2
1675 h
1676 @end example
1678 @opencatbox
1679 @category{Expressions}
1680 @closecatbox
1681 @end deffn
1683 @c -----------------------------------------------------------------------------
1684 @anchor{reveal}
1685 @deffn {関数} reveal (@var{expr}, @var{depth})
1687 指定された整数@var{depth}の@var{expr}の部分を
1688 記述的な要約で
1689 置き換えます。
1691 @itemize @bullet
1692 @item
1693 和と差分は、@code{Sum(@var{n})}で置き換えられます。
1694 ここで、@var{n}は、和のオペランドの数です。
1695 @item
1696 積は@code{Product(@var{n})}で置き換えられます。
1697 ここで、@var{n}は、積のオペランドの数です。
1698 @item
1699 指数は、@code{Expt}で置き換えられます。
1700 @item
1701 商は、@code{Quotient}で置き換えられます。
1702 @item
1703 単項マイナスは、@code{Negterm}で置き換えられます。
1704 @item
1705 リストは@code{List(@var{n})}で置き換えられます
1706 ここで、@var{n}はリストの要素の数です。
1707 @end itemize
1709 @var{depth}が@var{expr}の最大深さ以上の時、
1710 @code{reveal (@var{expr}, @var{depth})}は、@var{expr}をそのまま返します。
1712 @code{reveal}は、引数を評価します。
1713 @code{reveal}は、要約された式を返します。
1715 例:
1717 @example
1719 @c ===beg===
1720 @c e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1721 @c reveal (e, 1);
1722 @c reveal (e, 2);
1723 @c reveal (e, 3);
1724 @c reveal (e, 4);
1725 @c reveal (e, 5);
1726 @c reveal (e, 6);
1727 @c ===end===
1728 (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1729 2 2
1730 b - 2 a b + a
1731 (%o1) -------------------------
1732 b + a 2 b 2 a
1733 2 %e + %e + %e
1734 (%i2) reveal (e, 1);
1735 (%o2) Quotient
1736 (%i3) reveal (e, 2);
1737 Sum(3)
1738 (%o3) ------
1739 Sum(3)
1740 (%i4) reveal (e, 3);
1741 @group
1742 Expt + Negterm + Expt
1743 (%o4) ------------------------
1744 Product(2) + Expt + Expt
1745 @end group
1746 (%i5) reveal (e, 4);
1747 2 2
1748 b - Product(3) + a
1749 (%o5) ------------------------------------
1750 Product(2) Product(2)
1751 2 Expt + %e + %e
1752 (%i6) reveal (e, 5);
1753 2 2
1754 b - 2 a b + a
1755 (%o6) --------------------------
1756 Sum(2) 2 b 2 a
1757 2 %e + %e + %e
1758 (%i7) reveal (e, 6);
1759 2 2
1760 b - 2 a b + a
1761 (%o7) -------------------------
1762 b + a 2 b 2 a
1763 2 %e + %e + %e
1764 @end example
1766 @opencatbox
1767 @category{Expressions}
1768 @category{Display functions}
1769 @closecatbox
1770 @end deffn
1772 @c NEEDS EXPANSION, CLARIFICATION, MORE EXAMPLES
1774 @c -----------------------------------------------------------------------------
1775 @anchor{sublis}
1776 @deffn {関数} sublis (@var{list}, @var{expr})
1778 式に対して多重平行代入を行います。
1779 @var{list}は等式のリストです。
1780 等式の左辺はアトムでなければいけません。
1782 変数@code{sublis_apply_lambda}は@code{sublis}の後の式整理を制御します。
1784 平行代入を行うには、@code{psubst}も参照してください。
1786 例:
1788 @c ===beg===
1789 @c sublis ([a=b, b=a], sin(a) + cos(b));
1790 @c ===end===
1791 @example
1792 (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
1793 (%o1) sin(b) + cos(a)
1794 @end example
1796 @opencatbox
1797 @category{Expressions}
1798 @closecatbox
1799 @end deffn
1801 @c -----------------------------------------------------------------------------
1802 @anchor{sublis_apply_lambda}
1803 @defvr {オプション変数} sublis_apply_lambda
1804 デフォルト値: @code{true}
1806 @code{lambda}の代入が@code{sublis}が使われた後の式整理の中で適用されるか
1807 、もしくは、ユーザーが、ものに適用されるように@mref{ev}を実行しなければいけないかを決めます。
1808 @code{true}は適用を意味します。
1810 @opencatbox
1811 @category{Expressions}
1812 @closecatbox
1813 @end defvr
1815 @c -----------------------------------------------------------------------------
1816 @anchor{subnumsimp}
1817 @defvr {オプション変数} subnumsimp
1818 デフォルト値: @code{false}
1820 もし@code{true}なら、シンボル@code{f}が与えられた時だけ、
1821 関数@code{subst}と@code{psubst}は添字付き変数@code{f[x]}に数を代入できます。
1823 @code{subst}も参照してください。
1825 @example
1826 (%i1) subst(100,g,g[x]+2);
1828 subst: cannot substitute 100 for operator g in expression g
1829 x
1830 -- an error. To debug this try: debugmode(true);
1832 (%i2) subst(100,g,g[x]+2),subnumsimp:true;
1833 (%o2) 102
1834 @end example
1836 @opencatbox
1837 @category{Expressions}
1838 @closecatbox
1839 @end defvr
1841 @c NEEDS CLARIFICATION, MORE EXAMPLES
1843 @c -----------------------------------------------------------------------------
1844 @anchor{subst}
1845 @deffn {関数} subst (@var{a}, @var{b}, @var{c})
1847 @var{c}の中の@var{b}に@var{a}を代入します。
1848 @var{b}はアトムもしくは@var{c}の完全な部分式でなければなりません。
1849 例えば、@code{x+y+z}は@code{2*(x+y+z)}の完全な部分式である一方、@code{x+y}は完全な部分式ではありません。
1850 @var{b}がこれらの性質を持たない時は、@mref{substpart}もしくは@mref{ratsubst}が使える時があります（下記参照）。
1851 代わりに、もし@var{b}が@code{e/f}形式なら、@code{subst (a*f, e, c)}が使えますし、
1852 もし@var{b}が@code{e^(1/f)}形式なら、@code{subst (a^f, e, c)}が使えます。
1853 @code{subst}コマンドは@code{x^-y}の中の@code{x^y}も認識するので、
1854 @code{subst (a, sqrt(x), 1/sqrt(x))}は@code{1/a}を出力します。
1855 @var{a}と@var{b}はダブルクォート@code{"}で囲まれた式の演算子でも、関数名でも問題ありません。
1856 導関数形式の独立変数に代入したいなら、@code{at}関数（下記参照）を使うべきです。
1858 @c UMM, REVERSE THIS AND MOVE IT TO substitute ??
1859 @code{subst}は@code{substitute}のエーリアスです。
1861 コマンド@code{subst (@var{eq_1}, @var{expr})}もしくは@code{subst ([@var{eq_1}, ..., @var{eq_k}], @var{expr})}も許されている形式です。
1862 @var{eq_i}はされるべき代入を指示する等式です。
1863 それぞれの等式において、右辺が、式@var{expr}の中の左辺に代入されます。
1864 等式は、@var{expr}に、左から右へ逐次に代入されます。
1865 平行代入するには、関数@code{sublis}と@code{psubst}を参照してください。
1867 @mref{exptsubst}が@code{true}なら、
1868 @code{%e^(a*x)}の中の@code{%e^x}が@code{y}に置き換えられるような代入が許されます。
1870 @c WHAT IS THIS ABOUT ??
1871 @code{opsubst}が@code{false}の時、
1872 @code{subst}は式の演算子への代入を行いません。
1873 例えば、@code{(opsubst: false, subst (X^2, r, r+r[9]))}は意図通り動作します。
1875 例:
1877 @c ===beg===
1878 @c subst (a, x+y, x + (x+y)^2 + y);
1879 @c subst (-%i, %i, a + b*%i);
1880 @c ===end===
1881 @example
1882 (%i1) subst (a, x+y, x + (x+y)^2 + y);
1883 2
1884 (%o1) y + x + a
1885 (%i2) subst (-%i, %i, a + b*%i);
1886 (%o2) a - %i b
1887 @end example
1889 代入は、等式のリストに関して逐次になされます。
1890 これを並列代入と比較してください。
1892 @c ===beg===
1893 @c subst([a=b, b=c], a+b);
1894 @c sublis([a=b, b=c], a+b);
1895 @c ===end===
1896 @example
1897 (%i3) subst([a=b, b=c], a+b);
1898 (%o3) 2 c
1899 (%i4) sublis([a=b, b=c], a+b);
1900 (%o4) c + b
1901 @end example
1903 @noindent
1904 もっと例を見るには、@code{example (subst)}を実行してください。
1906 @opencatbox
1907 @category{Expressions}
1908 @closecatbox
1909 @end deffn
1911 @c NEEDS CLARIFICATION
1912 @anchor{substinpart}
1913 @deffn {関数} substinpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
1915 @mref{substpart}と同様ですが、@code{substinpart}は@var{expr}の内部表現上で
1916 働きます。
1918 例:
1920 @c ===beg===
1921 @c x . 'diff (f(x), x, 2);
1922 @c substinpart (d^2, %, 2);
1923 @c substinpart (f1, f[1](x + 1), 0);
1924 @c ===end===
1925 @example
1926 (%i1) x . 'diff (f(x), x, 2);
1927 2
1928 d
1929 (%o1) x . (--- (f(x)))
1930 2
1931 dx
1932 (%i2) substinpart (d^2, %, 2);
1933 2
1934 (%o2) x . d
1935 (%i3) substinpart (f1, f[1](x + 1), 0);
1936 (%o3) f1(x + 1)
1937 @end example
1939 もし@code{part}関数の最後の引数がインデックスのリストなら、
1940 複数の部分式が選ばれます。それぞれはリストのインデックスに対応します。
1941 例えば、
1943 @c ===beg===
1944 @c part (x + y + z, [1, 3]);
1945 @c ===end===
1946 @example
1947 (%i1) part (x + y + z, [1, 3]);
1948 (%o1) z + x
1949 @end example
1951 @code{part}関数を使った時、@mref{piece}は、最後の式の値を保持します。
1952 関数の実行の間に設定され、以下で示すように関数自身の中で参照されることもあります。
1953 もし@mref{partswitch}が@code{true}に設定されたら、
1954 式の選択された部分が存在しない時には@code{end}が返されます。
1955 そうでなければ、エラーメッセージが出力されます。
1957 @c ===beg===
1958 @c expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
1959 @c part (expr, 2, [1, 3]);
1960 @c sqrt (piece/54);
1961 @c substpart (factor (piece), expr, [1, 2, 3, 5]);
1962 @c expr: 1/x + y/x - 1/z;
1963 @c substpart (xthru (piece), expr, [2, 3]);
1964 @c ===end===
1965 @example
1966 (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
1967 3 2 2 3
1968 (%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1
1969 (%i2) part (expr, 2, [1, 3]);
1970 2
1971 (%o2) 54 y
1972 (%i3) sqrt (piece/54);
1973 (%o3) abs(y)
1974 (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
1975 3
1976 (%o4) (3 y + 2 x) + y + x + 1
1977 (%i5) expr: 1/x + y/x - 1/z;
1978 1 y 1
1979 (%o5) - - + - + -
1980 z x x
1981 (%i6) substpart (xthru (piece), expr, [2, 3]);
1982 y + 1 1
1983 (%o6) ----- - -
1984 x z
1985 @end example
1987 また、
1988 オプション @mref{inflag}を @code{true}に設定し
1989 @mref{part}か @mref{substpart}をコールすることは
1990 @code{inpart}か @code{substinpart}をコールすることと同じです。
1992 @opencatbox
1993 @category{Expressions}
1994 @closecatbox
1995 @end deffn
1997 @c NEEDS CLARIFICATION
1999 @c -----------------------------------------------------------------------------
2000 @anchor{substpart}
2001 @deffn {関数} substpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
2003 @var{x}を、残りの引数を@code{part}に食わせた結果の部分式に代入します。
2004 @var{expr}の新しい値を返します。
2005 @var{x}は@var{expr}の演算子に代入される演算子でも問題ありません。
2006 いくつかの場合、@var{x}はダブルクォート@code{"}で囲まれる必要があります。
2007 （例えば、@code{substpart ("+", a*b, 0)}は@code{b + a}を返します。）
2009 例:
2011 @c ===beg===
2012 @c 1/(x^2 + 2);
2013 @c substpart (3/2, %, 2, 1, 2);
2014 @c a*x + f(b, y);
2015 @c substpart ("+", %, 1, 0);
2016 @c ===end===
2017 @example
2018 (%i1) 1/(x^2 + 2);
2019 1
2020 (%o1) ------
2021 2
2022 x + 2
2023 (%i2) substpart (3/2, %, 2, 1, 2);
2024 1
2025 (%o2) --------
2026 3/2
2027 x + 2
2028 (%i3) a*x + f(b, y);
2029 (%o3) a x + f(b, y)
2030 (%i4) substpart ("+", %, 1, 0);
2031 (%o4) x + f(b, y) + a
2032 @end example
2034 また、オプション@mref{inflag}を@code{true}に設定し、
2035 @mref{part}や@code{substpart}をコールすることは、
2036 @code{inpart}や@mref{substinpart}をコールすることと同じになります。
2038 @opencatbox
2039 @category{Expressions}
2040 @closecatbox
2041 @end deffn
2043 @c -----------------------------------------------------------------------------
2044 @anchor{symbolp}
2045 @deffn {関数} symbolp (@var{expr})
2047 もし@var{expr}がシンボルなら@code{true}、そうでないなら@code{false}を返します。
2048 事実上、@code{symbolp(x)}は、述語論理@code{atom(x) and not numberp(x)}と同値です。
2050 @c FOLLOWING REALLY WANTS TO BE @xref{Identiifers} BUT THAT
2051 @c LEAVES THE UNPLEASANT RESIDUE *Note ...:: IN THE OUTPUT OF describe
2052 @ref{Identifiers}も参照してください。
2054 @opencatbox
2055 @category{Predicate functions}
2056 @closecatbox
2057 @end deffn
2059 @c -----------------------------------------------------------------------------
2060 @anchor{unorder}
2061 @deffn {関数} unorder ()
2063 順序付けコマンド@code{ordergreat}と@code{orderless}の最後の使用で生成されたエーリアシングを使用不可にします。
2064 @code{ordergreat}と@code{orderless}は、
2065 @code{unorder}を呼び出さずに、一回以上使えないかもしれません。
2066 @code{unorder}は、
2067 @code{ordergreat}と@code{orderless}で導入されたエーリアスに
2068 元のシンボルを式に再代入しません。
2069 それ故に、@code{unorder}の実行後、以前の式にエーリアスが現れます。
2071 @code{ordergreat}と@code{orderless}も参照してください。
2073 例s:
2075 @code{ordergreat(a)}はシンボル@code{a}のエーリアスを導入します。
2076 それ故に、
2077 @code{%o2}と@code{%o4}の違いは消えません。
2078 @code{unorder}はシンボル@code{a}を再代入しないし、
2079 出力@code{%o7}にエーリアスが現れます。
2081 @c ===beg===
2082 @c unorder();
2083 @c b*x + a^2;
2084 @c ordergreat (a);
2085 @c b*x + a^2;
2086 @c %th(1) - %th(3);
2087 @c unorder();
2088 @c %th(2);
2089 @c ===end===
2090 @example
2091 (%i1) unorder();
2092 (%o1) []
2093 (%i2) b*x+a^2;
2094 2
2095 (%o2) b x + a
2096 (%i3) ordergreat(a);
2097 (%o3) done
2098 (%i4) b*x+a^2;
2099 2
2100 (%o4) a + b x
2101 (%i5) %th(1)-%th(3);
2102 2 2
2103 (%o5) a - a
2104 (%i6) unorder();
2105 (%o6) [a]
2106 (%i7) %th(2);
2107 2 2
2108 (%o7) _101a - a
2109 @end example
2111 @opencatbox
2112 @category{Expressions}
2113 @closecatbox
2114 @end deffn
2116 @c -----------------------------------------------------------------------------
2117 @anchor{verbify}
2118 @deffn {関数} verbify (@var{f})
2120 関数名@var{f}の動詞形を返します。
2121 @code{verb}, @code{noun}, @code{nounify}も参照してください。
2123 例:
2125 @c ===beg===
2126 @c verbify ('foo);
2127 @c :lisp $%
2128 @c nounify (foo);
2129 @c :lisp $%
2130 @c ===end===
2131 @example
2132 (%i1) verbify ('foo);
2133 (%o1) foo
2134 (%i2) :lisp $%
2135 $FOO
2136 (%i2) nounify (foo);
2137 (%o2) foo
2138 (%i3) :lisp $%
2139 %FOO
2140 @end example
2142 @opencatbox
2143 @category{Nouns and verbs}
2144 @closecatbox
2145 @end deffn