| blob | e4ca8a58aab0db3a0fc1b0a039bf81c4e730c1aa |
1 @c -----------------------------------------------------------------------------
2 @page
3 @node Lists, Arrays, Constants, Data Types and Structures
4 @section Lists
5 @c -----------------------------------------------------------------------------
7 @menu
8 * Introduction to Lists::
9 * Functions and Variables for Lists::
10 @end menu
12 @c -----------------------------------------------------------------------------
13 @node Introduction to Lists, Functions and Variables for Lists, Lists, Lists
14 @subsection Introduction to Lists
15 @c -----------------------------------------------------------------------------
17 リストはMaximaとLispにとって基本的な構成要素です。
18 配列、ハッシュテーブル、数以外のデータタイプすべてはLispのリストとして表現されます。
19 これらのLispのリストは
20 式 @code{a+2}を示すために以下の形式を取ります。
22 @example
23 ((MPLUS) $A 2)
24 @end example
26 @noindent
28 Maximaレベルでは中置表記@code{a+2}を見ることになるでしょう。
29 Maximaには、以下のようにプリントされるリストもあります。
31 @example
32 [1, 2, 7, x+y]
33 @end example
35 @noindent
36 これは4要素のリストの場合の例です。
37 内部的には、これは以下の形式のLispのリストに対応します。
39 @example
40 ((MLIST) 1 2 7 ((MPLUS) $X $Y ))
41 @end example
43 @noindent
45 Maxima式のタイプフィールドを意味するフラグはそれ自体リストです。
46 整理器を通った後、上のリストは以下のようになるでしょう。
48 @example
49 ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
50 @end example
52 @noindent
54 @c -----------------------------------------------------------------------------
55 @node Functions and Variables for Lists, , Introduction to Lists, Lists
56 @subsection Functions and Variables for Lists
57 @c -----------------------------------------------------------------------------
59 @c -----------------------------------------------------------------------------
60 @anchor{[}
61 @anchor{]}
62 @defvr {特殊シンボル} [
63 @defvrx {特殊シンボル} ]
64 @ifinfo
65 @fnindex List delimiters
66 @fnindex Subscript operator
67 @end ifinfo
69 先頭が@code{[}で終わりが@code{]}のマークはリストです。
71 @code{[}と@code{]}は、リスト、配列、ハッシュ配列、配列関数の添字もくくります。
73 例:
75 @example
76 (%i1) x: [a, b, c];
77 (%o1) [a, b, c]
78 (%i2) x[3];
79 (%o2) c
80 (%i3) array (y, fixnum, 3);
81 (%o3) y
82 (%i4) y[2]: %pi;
83 (%o4) %pi
84 (%i5) y[2];
85 (%o5) %pi
86 (%i6) z['foo]: 'bar;
87 (%o6) bar
88 (%i7) z['foo];
89 (%o7) bar
90 (%i8) g[k] := 1/(k^2+1);
91 1
92 (%o8) g := ------
93 k 2
94 k + 1
95 (%i9) g[10];
96 1
97 (%o9) ---
98 101
99 @end example
101 @opencatbox
102 @category{Lists}
103 @category{Operators}
104 @closecatbox
105 @end defvr
107 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
108 @c NEEDS CLARIFICATION AND EXAMPLES
110 @c -----------------------------------------------------------------------------
111 @anchor{append}
112 @deffn {関数} append (@var{list_1}, @dots{}, @var{list_n})
113 @var{list_1}の要素のあとに
114 @var{list_2}の要素が続き、@dots{}
115 という１つのリストを返します。
116 @code{append}は一般式上でも機能します。
117 例えば、 @code{append (f(a,b), f(c,d,e));}は
118 @code{f(a,b,c,d,e)}をもたらします。
120 例を見るには、 @code{example(append);}を実行してください。
122 @opencatbox
123 @category{Lists}
124 @category{Expressions}
125 @closecatbox
126 @end deffn
128 @c NEEDS CLARIFICATION AND EXAMPLES
130 @c -----------------------------------------------------------------------------
131 @anchor{assoc}
132 @deffn {関数} assoc (@var{key}, @var{list}, @var{default})
133 @deffnx {関数} assoc (@var{key}, @var{list})
135 この関数は
136 形式 @code{[x,y,z,...]}の入力 @var{list}の左辺の中で @var{key}を探します。
137 ここで @var{list}の要素のそれぞれは二項演算子と２つの要素の式です。
138 例えば、 @code{x=1}, @code{2^3}, @code{[a,b]}など。
139 最初のオペランドに対して @var{key}がチェックされます。
140 もし @code{key}が見つかったら、
141 @code{assoc}は二番目のオペランドを返します。
142 もし @code{key}が見つからなかったら、
143 @var{default}値を返します。
144 @var{default}はオプションで、省略すると @code{false}に設定されます。
146 @opencatbox
147 @category{Lists}
148 @category{Expressions}
149 @closecatbox
150 @end deffn
152 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
153 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
155 @c -----------------------------------------------------------------------------
156 @anchor{cons}
157 @deffn {関数} cons (@var{expr}, @var{list})
159 最初の要素として要素 @var{expr}で構成され、
160 @var{list}の要素が続く新しいリストを返します。
161 @code{cons}は他の式上でも機能します。
162 例えば、 @code{cons(x, f(a,b,c));} -> @code{f(x,a,b,c)}。
164 @opencatbox
165 @category{Lists}
166 @category{Expressions}
167 @closecatbox
168 @end deffn
170 @c -----------------------------------------------------------------------------
171 @anchor{copylist}
172 @deffn {関数} copylist (@var{list})
174 リスト @var{list}のコピーを返します。
176 @opencatbox
177 @category{Lists}
178 @closecatbox
179 @end deffn
181 @c -----------------------------------------------------------------------------
182 @anchor{create_list}
183 @deffn {関数} create_list (@var{form}, @var{x_1}, @var{list_1}, @dots{}, @var{x_n}, @var{list_n})
185 @var{list_1}の要素それぞれにバインドされた @var{x_1}で、
186 また、それぞれのバインドに対して、
187 @var{x_2}を @var{list_2}の要素それぞれにバインドして、...
188 それらのバインドを使って @var{form}を評価することによって
189 リストを生成します。
190 結果の要素の数はそれぞれのリストの要素の数の積です。
191 それぞれの変数 @var{x_i}は実際に、シンボルでなければいけません。ーそれは評価されません。
192 リスト引数は繰り返しの始めに一度だけ評価されます。
194 @example
195 (%i1) create_list(x^i,i,[1,3,7]);
196 3 7
197 (%o1) [x, x , x ]
198 @end example
200 @noindent
201 二重の繰り返しで:
203 @example
204 (%i1) create_list([i,j],i,[a,b],j,[e,f,h]);
205 (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
206 @end example
208 @var{list_i}の代わりに、
209 それぞれが数に評価される２つの引数を供給することもできます。
210 これらは繰り返しの下限と上限になります。
212 @example
213 (%i1) create_list([i,j],i,[1,2,3],j,1,i);
214 (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
215 @end example
217 @code{j}変数の範囲やリストは @code{i}の現在値に依存することができることに注意してください。
219 @opencatbox
220 @category{Lists}
221 @closecatbox
222 @end deffn
224 @c -----------------------------------------------------------------------------
225 @anchor{delete}
226 @deffn {関数} delete (@var{expr_1}, @var{expr_2})
227 @deffnx {関数} delete (@var{expr_1}, @var{expr_2}, @var{n})
229 @code{delete(@var{expr_1}, @var{expr_2})}は、
230 @var{expr_2}から
231 そのトップレベル演算子の引数のうち、
232 @var{expr_1}と("="で決定される意味で)同じ引数を取り除きます。
233 "="は、同値ではなく、形式的な同一をテストすることに注意してください。
234 部分式の引数には影響しないことにも注意してください。
236 @var{expr_1}はアトムか、非アトムの式を取り得ます。
237 @var{expr_2}は任意の非アトムの式を取り得ます。
238 @code{delete}は新しい式を返します;
239 @var{expr_2}を変更しません。
241 @code{delete(@var{expr_1}, @var{expr_2}, @var{n})}は、
243 @var{expr_2}から
244 そのトップレベル演算子の引数のうち、
245 @var{expr_1}と同じ最初の
246 @var{n}個の引数を取り除きます。
247 もしそんな引数が @var{n}個より少ないなら、
248 該当するすべての引数が取り除かれます。
250 例:
252 リストから要素を削除。
254 @c ===beg===
255 @c delete (y, [w, x, y, z, z, y, x, w]);
256 @c ===end===
257 @example
258 (%i1) delete (y, [w, x, y, z, z, y, x, w]);
259 (%o1) [w, x, z, z, x, w]
260 @end example
262 和から項を削除。
264 @c ===beg===
265 @c delete (sin(x), x + sin(x) + y);
266 @c ===end===
267 @example
268 (%i1) delete (sin(x), x + sin(x) + y);
269 (%o1) y + x
270 @end example
272 積から因子を削除。
274 @c ===beg===
275 @c delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
276 @c ===end===
277 @example
278 (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
279 (%o1) (u - w) (u - y) (u - z)
280 @end example
282 任意の式から引数を削除。
284 @c ===beg===
285 @c delete (a, foo (a, b, c, d, a));
286 @c ===end===
287 @example
288 (%i1) delete (a, foo (a, b, c, d, a));
289 (%o1) foo(b, c, d)
290 @end example
292 削除する引数の数を制限。
294 @c ===beg===
295 @c delete (a, foo (a, b, a, c, d, a), 2);
296 @c ===end===
297 @example
298 (%i1) delete (a, foo (a, b, a, c, d, a), 2);
299 (%o1) foo(b, c, d, a)
300 @end example
302 引数が @var{expr_1}と同じかどうかは"="で決定されます。
303 @code{equal}ですが、"="でない引数は取り除かれません。
305 @c ===beg===
306 @c [is(equal (0, 0)), is(equal(0, 0.0)), is(equal(0, 0b0))];
307 @c [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
308 @c delete (0, [0, 0.0, 0b0]);
309 @c is (equal ((x + y)*(x - y), x^2 - y^2));
310 @c is ((x + y)*(x - y) = x^2 - y^2);
311 @c delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
312 @c ===end===
313 @example
314 (%i1) [is(equal(0, 0)), is(equal(0, 0.0)), is(equal(0, 0b0))];
316 `rat' replaced 0.0 by 0/1 = 0.0
317 `rat' replaced 0.0B0 by 0/1 = 0.0B0
318 (%o1) [true, true, true]
319 (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
320 (%o2) [true, false, false]
321 (%i3) delete (0, [0, 0.0, 0b0]);
322 (%o3) [0.0, 0.0b0]
323 (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
324 (%o4) true
325 (%i5) is ((x + y)*(x - y) = x^2 - y^2);
326 (%o5) false
327 (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
328 2 2
329 (%o6) [x - y ]
330 @end example
332 @opencatbox
333 @category{Lists}
334 @category{Expressions}
335 @closecatbox
336 @end deffn
338 @c -----------------------------------------------------------------------------
339 @anchor{eighth}
340 @deffn {関数} eighth (@var{expr})
342 式またはリスト @var{expr}の8番目の項を返します。
343 詳細は @code{first}を参照してください。
345 @opencatbox
346 @category{Lists}
347 @category{Expressions}
348 @closecatbox
349 @end deffn
351 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
352 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
354 @c -----------------------------------------------------------------------------
355 @anchor{endcons}
356 @deffn {関数} endcons (@var{expr}, @var{list})
358 @var{expr}が続く @code{list}の要素から成る新しいリストを返します。
359 @code{endcons}は一般式上でも機能します。
360 例えば、
361 @code{endcons(x, f(a,b,c));} -> @code{f(a,b,c,x)}。
363 @opencatbox
364 @category{Lists}
365 @category{Expressions}
366 @closecatbox
367 @end deffn
369 @c -----------------------------------------------------------------------------
370 @anchor{fifth}
371 @deffn {関数} fifth (@var{expr})
373 式またはリスト @var{expr}の5番目の項を返します。
374 詳細は @mref{first}を参照してください。
376 @opencatbox
377 @category{Lists}
378 @category{Expressions}
379 @closecatbox
380 @end deffn
382 @c NEEDS CLARIFICATION AND EXAMPLES
384 @c -----------------------------------------------------------------------------
385 @anchor{first}
386 @deffn {関数} first (@var{expr})
388 リストの最初の要素、行列の最初の行、和の最初の項などに帰着する、
389 @var{expr}の最初の部分を返します。
390 @code{first}とその関連関数 @code{rest}と @code{last}は、
391 入力時にタイプした形式ではなく、 @var{expr}の表示形式上で機能することに注意してください。
392 しかしながら、もし変数 @code{inflag}が @code{true}に設定されているなら、
393 これらの関数は @var{expr}の内部形式を見ます。
394 整理器は式を再配置することに注意してください。
395 例えば、
396 @code{first(x+y)}は、
397 もし @code{inflag}が @code{true}なら @code{x}で、
398 もし @code{inflag}が @code{false}なら @code{y} です。
399 (@code{first(y+x)}は同じ結果を与えます。)
400 関数 @code{second} .. @code{tenth}は
401 入力引数の二番目から十番目の部分をもたらします。
403 @opencatbox
404 @category{Lists}
405 @category{Expressions}
406 @closecatbox
407 @end deffn
409 @c -----------------------------------------------------------------------------
410 @anchor{fourth}
411 @deffn {関数} fourth (@var{expr})
413 式またはリスト @var{expr}の4番目の項を返します。
414 詳細は @mref{first}を参照してください。
416 @opencatbox
417 @category{Lists}
418 @category{Expressions}
419 @closecatbox
420 @end deffn
422 @c -----------------------------------------------------------------------------
423 @anchor{join}
424 @deffn {関数} join (@var{l}, @var{m})
426 リスト@var{l}と@var{m}の要素を交互に含む新しいリストを生成します。
427 結果は、要素 @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}を持ちます。
428 リスト @var{l}と @var{m}は、任意のタイプの要素を含めます。
430 もしリストの長さが違ったら、
431 @code{join}は長いリストの要素を無視します。
433 もし @var{l}か @var{m}がリストでなかったら、
434 Maximaは文句を言います。
436 例:
438 @c ===beg===
439 @c L1: [a, sin(b), c!, d - 1];
440 @c join (L1, [1, 2, 3, 4]);
441 @c join (L1, [aa, bb, cc, dd, ee, ff]);
442 @c ===end===
443 @example
444 (%i1) L1: [a, sin(b), c!, d - 1];
445 (%o1) [a, sin(b), c!, d - 1]
446 (%i2) join (L1, [1, 2, 3, 4]);
447 (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4]
448 (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
449 (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]
450 @end example
452 @opencatbox
453 @category{Lists}
454 @closecatbox
455 @end deffn
457 @c NEEDS EXAMPLES
458 @c HOW IS "LAST" PART DETERMINED ??
460 @c -----------------------------------------------------------------------------
461 @anchor{last}
462 @deffn {関数} last (@var{expr})
463 @var{expr}最後の(項、行、要素など）部分を返します。
465 @opencatbox
466 @category{Lists}
467 @category{Expressions}
468 @closecatbox
469 @end deffn
471 @c NEEDS CLARIFICATION AND EXAMPLES
473 @c -----------------------------------------------------------------------------
474 @anchor{length}
475 @deffn {関数} length (@var{expr})
477 (デフォルトでは) @var{expr}の外部(表示)形式の部分の数を返します。
478 リストに関しては、これは要素の数を返し、
479 行列に関しては行数であり、
480 和に関しては項数です。
481 (@mref{dispform}を参照してください。)
483 @code{length}コマンドは @mref{inflag}スイッチに影響されます。
484 だから例えば、 @code{length(a/(b*c));}は、
485 (@mref{exptdispflag}が @code{true}と仮定して)
486 もし @code{inflag}が @code{false}なら2を与えますが、
487 もし @code{inflag}が @code{true}なら3を与えます。
488 (内部表現は本質的には @code{a*b^-1*c^-1}です。)
490 @opencatbox
491 @category{Lists}
492 @category{Expressions}
493 @closecatbox
494 @end deffn
496 @c -----------------------------------------------------------------------------
497 @anchor{listarith}
498 @defvr {オプション変数} listarith
499 デフォルト値: @code{true} - もし @code{false}なら、
500 リストを伴う任意の算術演算が抑制されるようになります;
501 @code{true}の時、リスト-行列演算では、
502 リストが行列に変換されるようになり、いつも行列の結果をもたらすよう連鎖します。
503 しかしながら、リスト-リスト演算はリストを返します。
505 @opencatbox
506 @category{Lists}
507 @category{Global flags}
508 @closecatbox
510 @end defvr
512 @c -----------------------------------------------------------------------------
513 @deffn {関数} listp (@var{expr})
515 もし @var{expr}がリストなら @code{true}、
516 そうでなければ @code{false}を返します。
518 @opencatbox
519 @category{Lists}
520 @category{Predicate functions}
521 @closecatbox
522 @end deffn
524 @c -----------------------------------------------------------------------------
525 @anchor{makelist}
526 @deffn {関数} makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
527 @deffnx {関数} makelist (@var{expr}, @var{x}, @var{list})
529 要素それぞれが @var{expr}から生成されたリストを構成し、返します。
531 @code{makelist (@var{expr}, @var{i}, @var{i_0}, @var{i_1})}は、
532 @var{i_0}から @var{i_1}に等しい @code{j}に対して
533 @code{j}番目の要素が @code{ev (@var{expr}, @var{i}=j)}に等しい
534 リストを返します。
536 @code{makelist (@var{expr}, @var{x}, @var{list})}は、
537 1から @code{length (@var{list})}に等しい @code{j}に対して、
538 @code{j}番目の要素が @code{ev (@var{expr}, @var{x}=@var{list}[j])}に等しい
539 リストを返します。
541 例:
543 @c ===beg===
544 @c makelist(concat(x,i),i,1,6);
545 @c makelist(x=y,y,[a,b,c]);
546 @c ===end===
547 @example
548 (%i1) makelist(concat(x,i),i,1,6);
549 (%o1) [x1, x2, x3, x4, x5, x6]
550 (%i2) makelist(x=y,y,[a,b,c]);
551 (%o2) [x = a, x = b, x = c]
553 @end example
555 @opencatbox
556 @category{Lists}
557 @closecatbox
558 @end deffn
560 @c -----------------------------------------------------------------------------
561 @anchor{member}
562 @deffn {関数} member (@var{expr_1}, @var{expr_2})
564 もし
565 @code{args(@var{expr_2})}の中のある要素@var{a}に対して
566 @code{is(@var{expr_1} = @var{a})}なら
567 @code{true}を返し、
568 そうでなければ @code{false}を返します。
570 @code{expr_2}は通常リストです。
571 その場合、 @code{args(@var{expr_2}) = @var{expr_2}}かつ
572 @code{expr_2}の中のある要素 @var{a}に対して、
573 @code{is(@var{expr_1} = @var{a})}であることがテストです。
575 @code{member}は
576 @code{expr_2}の引数の部分を検査しません。
577 だから、
578 たとえ @code{expr_1}が @code{expr_2}のある引数の部分であっても
579 @code{false}を返すかもしれません。
581 @mref{elementp}も参照してください。
583 例:
585 @c ===beg===
586 @c member (8, [8, 8.0, 8b0]);
587 @c member (8, [8.0, 8b0]);
588 @c member (b, [a, b, c]);
589 @c member (b, [[a, b], [b, c]]);
590 @c member ([b, c], [[a, b], [b, c]]);
591 @c F (1, 1/2, 1/4, 1/8);
592 @c member (1/8, %);
593 @c member ("ab", ["aa", "ab", sin(1), a + b]);
594 @c ===end===
595 @example
596 (%i1) member (8, [8, 8.0, 8b0]);
597 (%o1) true
598 (%i2) member (8, [8.0, 8b0]);
599 (%o2) false
600 (%i3) member (b, [a, b, c]);
601 (%o3) true
602 (%i4) member (b, [[a, b], [b, c]]);
603 (%o4) false
604 (%i5) member ([b, c], [[a, b], [b, c]]);
605 (%o5) true
606 (%i6) F (1, 1/2, 1/4, 1/8);
607 1 1 1
608 (%o6) F(1, -, -, -)
609 2 4 8
610 (%i7) member (1/8, %);
611 (%o7) true
612 (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
613 (%o8) true
614 @end example
616 @opencatbox
617 @category{Lists}
618 @category{Expressions}
619 @category{Predicate functions}
620 @closecatbox
621 @end deffn
623 @c -----------------------------------------------------------------------------
624 @anchor{ninth}
625 @deffn {関数} ninth (@var{expr})
627 式またはリスト @var{expr}の9番目の項を返します。
628 詳細は @code{first}を参照してください。
630 @opencatbox
631 @category{Lists}
632 @category{Expressions}
633 @closecatbox
634 @end deffn
636 @c -----------------------------------------------------------------------------
637 @anchor{pop}
638 @deffn {関数} pop (@var{list})
640 @code{pop}は、リスト @var{list}から最初の要素を取り除き、この要素を返します。
641 @var{list}はリストそのものではなく、リストにバインドされたシンボルでなければいけません。
643 もし引数 @var{list}がリストにバインドされていないかリストが空なら、
644 Maximaはエラーメッセージを生成します。
646 例には @mref{push}も参照してください。
648 @code{load("basic")}はこの関数をロードします。
650 @opencatbox
651 @category{Lists}
652 @category{Expressions}
653 @closecatbox
654 @end deffn
656 @c -----------------------------------------------------------------------------
657 @anchor{push}
658 @deffn {関数} push (@var{item}, @var{list})
660 @code{push}は項目 @var{item}をリスト @var{list}の先頭に追加し、
661 新しいリストのコピーを返します。
662 @var{list}はリストそのものではなく、リストにバインドされたシンボルでなければいけません。
663 @var{item}は任意のMaximaシンボルや式が使えます。
665 もし引数 @var{list}がリストにバインドされていないかリストが空なら、
666 Maximaはエラーメッセージを生成します。
668 リストから最初の項目を取り除くには @mref{pop}も参照してください。
670 @code{load("basic")}はこの関数をロードします。
672 例:
674 @c ===beg===
675 @c ll:[];
676 @c push(x,ll);
677 @c push(x^2+y,ll);
678 @c a:push("string",ll);
679 @c pop(ll);
680 @c pop(ll);
681 @c pop(ll);
682 @c ll;
683 @c a;
684 @c ===end===
685 @example
686 (%i1) ll:[];
687 (%o1) []
688 (%i2) push(x,ll);
689 (%o2) [x]
690 (%i3) push(x^2+y,ll);
691 2
692 (%o3) [y + x , x]
693 (%i4) a:push("string",ll);
694 2
695 (%o4) [string, y + x , x]
696 (%i5) pop(ll);
697 (%o5) string
698 (%i6) pop(ll);
699 2
700 (%o6) y + x
701 (%i7) pop(ll);
702 (%o7) x
703 (%i8) ll;
704 (%o8) []
705 (%i9) a;
706 2
707 (%o9) [string, y + x , x]
708 @end example
710 @opencatbox
711 @category{Lists}
712 @category{Expressions}
713 @closecatbox
714 @end deffn
716 @c NEEDS EXAMPLES
718 @c -----------------------------------------------------------------------------
719 @anchor{rest}
720 @deffn {関数} rest (@var{expr}, @var{n})
721 @deffnx {関数} rest (@var{expr})
723 もし @var{n}が正なら、
724 頭の @var{n}個の要素を取り除いた
725 @var{expr}を返し、
726 もし @var{n}が負なら、
727 お尻の @code{- @var{n}}個の要素を取り除いた
728 @var{expr}を返します。
729 もし @var{n}が1なら、省略できます。
730 @var{expr}は、リスト、行列、他の式を取り得ます。
732 @opencatbox
733 @category{Lists}
734 @category{Expressions}
735 @closecatbox
736 @end deffn
738 @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS
739 @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
741 @c -----------------------------------------------------------------------------
742 @anchor{reverse}
743 @deffn {関数} reverse (@var{list})
745 @var{list} のメンバーの順序を逆にします。
746 (メンバー自身は変えません。)
747 @code{reverse}は、一般式でも機能します。
748 例えば、 @code{reverse(a=b);}は @code{b=a}を与えます。
750 @opencatbox
751 @category{Lists}
752 @category{Expressions}
753 @closecatbox
754 @end deffn
756 @c -----------------------------------------------------------------------------
757 @anchor{second}
758 @deffn {関数} second (@var{expr})
760 式またはリスト @var{expr}の二番目の項を返します。
761 詳細は @mref{first}を参照してください。
763 @opencatbox
764 @category{Lists}
765 @category{Expressions}
766 @closecatbox
767 @end deffn
769 @c -----------------------------------------------------------------------------
770 @anchor{seventh}
771 @deffn {関数} seventh (@var{expr})
773 式またはリスト @var{expr}の7番目の項を返します。
774 詳細は @mref{first}を参照してください。
776 @opencatbox
777 @category{Lists}
778 @category{Expressions}
779 @closecatbox
780 @end deffn
782 @c -----------------------------------------------------------------------------
783 @anchor{sixth}
784 @deffn {関数} sixth (@var{expr})
786 式またはリスト @var{expr}の6番目の項を返します。
787 詳細は @mref{first}を参照してください。
789 @opencatbox
790 @category{Lists}
791 @category{Expressions}
792 @closecatbox
793 @end deffn
795 @c -----------------------------------------------------------------------------
796 @anchor{sort}
797 @deffn {関数} sort (@var{L}, @var{P})
798 @deffnx {関数} sort (@var{L})
800 任意の隣り合う要素について@code{@var{P} (@var{L}[k], @var{L}[k + 1])}が@code{true}
801 になるように
802 ２つの引数の述語論理@code{P}に従ってリスト@var{L}をソートします。
803 述語論理は関数や２値中値演算子の名前として、@code{lambda}式として指定されるかもしれません。
804 もし演算子名として指定されたなら、名前は「ダブルクォート」でくくられます。
806 ソートされたリストは新しいオブジェクトとして返されます;
807 @var{L}は変更されません。
808 戻り値を構成するために、
809 @code{sort}は、@var{L}の要素の浅いコピーを実行します。
810 @c DUNNO IF WE NEED TO GO INTO THE IMPLICATIONS OF SHALLOW COPY HERE ...
812 @c MIGHT CONSIDER A REF FOR TOTAL ORDER HERE
813 もし述語論理@var{P}が@var{L}の要素の総順序でなければ、
814 @code{sort}は、エラーなしに実行を完了するかもしれませんが、結果は未定義です。
815 もし述語論理が@code{true}もしくは@code{false}以外の何かに評価されるなら、
816 @code{sort}はエラーを出力します。
818 @code{sort (@var{L})}は @code{sort (@var{L}, orderlessp)}と同値です。
819 すなわち、デフォルトソート順序は昇順です。@mref{orderlessp}で決められているように。
821 述語論理@code{ordergreatp}はリストを降順にソートします。
822 述語論理@code{ordermagnitudep}はMaxima数や数値を持つ定数シンボル、
823 定数に評価されることができる式を大きさによってソートします。
824 リスト@var{L}の他のすべての要素は@code{orderlessp}によってソートされます。
825 述語論理@code{"<"}も大きさによる順序付けを許しますが、
826 もしリスト@var{L}の要素が@code{"<"}の下で比較可能でないなら完全には並べません。
828 例:
830 @c ===beg===
831 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
832 @c 19 - 3 * x]);
833 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x],
834 @c ordergreatp);
835 @c sort ([%pi, 3, 4, %e, %gamma]);
836 @c sort ([%pi, 3, 4, %e, %gamma], "<");
837 @c my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
838 @c sort (my_list);
839 @c sort (my_list, lambda ([a, b], orderlessp (reverse (a),
840 @c reverse (b))));
841 @c ===end===
842 @example
843 (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
844 19 - 3 * x]);
845 5
846 (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
847 2
848 (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
849 ordergreatp);
850 5
851 (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
852 2
853 (%i3) sort ([%pi, 3, 4, %e, %gamma]);
854 (%o3) [3, 4, %e, %gamma, %pi]
855 (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
856 (%o4) [%gamma, %e, 3, %pi, 4]
857 (%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
858 (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
859 (%i6) sort (my_list);
860 (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
861 @group
862 (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
863 reverse (b))));
864 @end group
865 (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
866 @end example
868 Maxima数と定数、定数式を大きさ順に並べ、他のすべての要素を降順で並べます:
870 @c ===beg===
871 @c sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
872 @c ordermagnitudep);
873 @c ===end===
874 @example
875 (%i8) sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
876 ordermagnitudep);
877 (%o8) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
878 %i + 1, 2 x]
879 @end example
881 @opencatbox
882 @category{Lists}
883 @closecatbox
884 @end deffn
886 @c -----------------------------------------------------------------------------
887 @anchor{sublist}
888 @deffn {関数} sublist (@var{list}, @var{p})
890 述語論理@code{p}が@code{true}を返す@var{list}の要素のリストを返します。
892 例:
894 @c ===beg===
895 @c L: [1, 2, 3, 4, 5, 6];
896 @c sublist (L, evenp);
897 @c ===end===
898 @example
899 (%i1) L: [1, 2, 3, 4, 5, 6];
900 (%o1) [1, 2, 3, 4, 5, 6]
901 (%i2) sublist (L, evenp);
902 (%o2) [2, 4, 6]
903 @end example
905 @opencatbox
906 @category{Lists}
907 @closecatbox
908 @end deffn
910 @c -----------------------------------------------------------------------------
911 @anchor{sublist_indices}
912 @deffn {関数} sublist_indices (@var{L}, @var{P})
914 述語論理 @code{maybe(@var{P}(x))}が @code{true}を返す、
915 リスト @var{L}の要素 @code{x}のインデックスを返します;
916 これは @code{false}はもちろん @code{unknown}も除外します。
917 @var{P}は関数名かラムダ式を取り得ます。
918 @var{L}はリストリテラルでなければいけません。
920 例:
922 @c ===beg===
923 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
924 @c lambda ([x], x='b));
925 @c sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
926 @c sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
927 @c identity);
928 @c assume (x < -1);
929 @c map (maybe, [x > 0, x < 0, x < -2]);
930 @c sublist_indices ([x > 0, x < 0, x < -2], identity);
931 @c ===end===
932 @example
933 (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
934 lambda ([x], x='b));
935 (%o1) [2, 3, 7, 9]
936 (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
937 (%o2) [1, 2, 3, 4, 7, 9]
938 (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
939 identity);
940 (%o3) [1, 4, 5]
941 (%i4) assume (x < -1);
942 (%o4) [x < - 1]
943 (%i5) map (maybe, [x > 0, x < 0, x < -2]);
944 (%o5) [false, true, unknown]
945 (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
946 (%o6) [2]
947 @end example
949 @opencatbox
950 @category{Lists}
951 @closecatbox
952 @end deffn
954 @c -----------------------------------------------------------------------------
955 @anchor{unique}
956 @deffn {関数} unique (@var{L})
958 リスト @var{L}の重複しない要素を返します。
960 @var{L}の要素すべてが重複しない時、
961 @code{unique}は、
962 @var{L}自身ではなく、
963 @var{L}の浅いコピーを返します。
965 もし @var{L}がリストでないなら、
966 @code{unique}は@var{L}を返します。
968 例:
970 @c ===beg===
971 @c unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
972 @c ===end===
973 @example
974 (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
975 (%o1) [1, 2, %e, %pi, [1], b + a]
976 @end example
977 @end deffn
979 @c -----------------------------------------------------------------------------
980 @anchor{tenth}
981 @deffn {関数} tenth (@var{expr})
983 式またはリスト @var{expr}の10番目の項を返します。
984 詳細は @code{first}を参照してください。
987 @opencatbox
988 @category{Lists}
989 @category{Expressions}
990 @closecatbox
991 @end deffn
993 @c -----------------------------------------------------------------------------
994 @anchor{third}
995 @deffn {関数} third (@var{expr})
997 式またはリスト @var{expr}の三番目の項を返します。
998 詳細は @code{first}を参照してください。
1000 @opencatbox
1001 @category{Lists}
1002 @category{Expressions}
1003 @closecatbox
1004 @end deffn