doc/info/ja/Arrays.texi

   1 @c -----------------------------------------------------------------------------
   2 @page
   3 @node Arrays, Structures, Lists, Data Types and Structures
   4 @section Arrays
   5 @c -----------------------------------------------------------------------------
   6
   7 @menu
   8 * Functions and Variables for Arrays::
   9 @end menu
  10
  11 @c -----------------------------------------------------------------------------
  12 @node Functions and Variables for Arrays,  , Arrays, Arrays
  13 @section Functions and Variables for Arrays
  14 @c -----------------------------------------------------------------------------
  15
  16 @c -----------------------------------------------------------------------------
  17 @anchor{array}
  18 @deffn  {関数} array (@var{name}, @var{dim_1}, @dots{}, @var{dim_n})
  19 @deffnx {関数} array (@var{name}, @var{type}, @var{dim_1}, @dots{}, @var{dim_n})
  20 @deffnx {関数} array ([@var{name_1}, @dots{}, @var{name_m}], @var{dim_1}, @dots{}, @var{dim_n})
  21
  22 @math{n}次元の配列を生成します。
  23 @math{n}は5以下を取り得ます。
  24 @math{i}番目の次元のための添字は0から@var{dim_i}まで動く整数です。
  25
  26 @code{array (@var{name}, @var{dim_1}, ..., @var{dim_n})}は
  27 一般的な配列を生成します。
  28
  29 @code{array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})}は
  30 指定されたタイプの要素を持つ配列を生成します。
  31 @var{type}には
  32 制限されたサイズの整数には@code{fixnum}が使え、
  33 また、浮動小数点には@code{flonum}が使えます。
  34
  35 @code{array ([@var{name_1}, ..., @var{name_m}], @var{dim_1}, ..., @var{dim_n})}
  36 は同じ次元の@math{m}個の配列を生成します。
  37 @c SAME TYPE AS WELL ??
  38
  39 @c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
  40 もしユーザーが対応する配列を宣言する前に添字付き変数に割り当てたら、
  41 未宣言配列が生成されます。
  42 (ハッシュコーディングが添字上でされるので)別名ハッシュド配列と知られる未宣言配列は、
  43 宣言配列よりもっと一般的です。
  44 ユーザーは最大サイズを宣言せず、さらなる要素が値に割り当てられる時、ハッシュすることで
  45 それらは動的に成長します。
  46 未宣言配列の添字は数である必要すらありません。
  47 しかしながら、
  48 配列がむしろ疎でないなら、
  49 未宣言のまま放っておくより、可能な時に宣言した方がおそらく効率的です。
  50 @code{array}関数は未宣言配列を宣言配列に変換するのに使うことができます。
  51 @c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??
  52
  53 @opencatbox
  54 @category{Arrays}
  55 @closecatbox
  56 @end deffn
  57
  58 @c -----------------------------------------------------------------------------
  59 @anchor{arrayapply}
  60 @deffn {関数} arrayapply (@var{A}, [@var{i_1}, @dots{} @var{i_n}])
  61 @code{@var{A} [@var{i_1}, ..., @var{i_n}]}を評価します。
  62 ここで、@var{A}は配列、@var{i_1}, @dots{}, @var{i_n}は整数です。
  63
  64 これは、最初の引数が関数の代わりに配列だということを除いて、
  65 @mref{apply}を連想させます。
  66
  67 @opencatbox
  68 @category{Expressions}
  69 @category{Arrays}
  70 @closecatbox
  71 @end deffn
  72
  73 @c -----------------------------------------------------------------------------
  74 @anchor{arrayinfo}
  75 @deffn {関数} arrayinfo (@var{A})
  76
  77 配列@var{A}に関する情報を返します。
  78 引数@var{A}は、宣言配列、未宣言(ハッシュド)配列、配列関数、または添字付き関数を取り得ます。
  79
  80 宣言配列では、
  81 @code{arrayinfo}は、
  82 アトム@code{declared}と、次元数、それぞれの次元のサイズを含むリストを返します。
  83 配列の要素は、バインドされたものもそうでないものも、@code{listarray}で返されます。
  84
  85 未宣言配列(ハッシュド配列)では、
  86 @code{arrayinfo}は、
  87 アトム@code{hashed}と、添字の数、値を持つすべての要素の添字を含むリストを返します。
  88 値は @code{listarray}で返されます。
  89
  90 配列関数では、
  91 @code{arrayinfo}は、
  92 アトム@code{hashed}と、添字の数、
  93 記憶された関数値がある添字の値すべてを含むリストを返します。
  94 記憶された関数値は、@code{listarray}で返されます。
  95
  96 添字付き関数では、、
  97 @code{arrayinfo}は、
  98  returns a list comprising the
  99 アトム@code{hashed}と、添字の数、
 100 ラムダ式がある添字の値すべてを含むリストを返します。
 101 ラムダ式は @code{listarray}で返されます。
 102
 103 @mref{listarray}も参照してください。
 104
 105 例:
 106
 107 宣言配列に適用された@code{arrayinfo}と@code{listarray}。
 108
 109 @c ===beg===
 110 @c array (aa, 2, 3);
 111 @c aa [2, 3] : %pi;
 112 @c aa [1, 2] : %e;
 113 @c arrayinfo (aa);
 114 @c listarray (aa);
 115 @c ===end===
 116 @example
 117 @group
 118 (%i1) array (aa, 2, 3);
 119 (%o1)                          aa
 120 @end group
 121 @group
 122 (%i2) aa [2, 3] : %pi;
 123 (%o2)                          %pi
 124 @end group
 125 @group
 126 (%i3) aa [1, 2] : %e;
 127 (%o3)                          %e
 128 @end group
 129 @group
 130 (%i4) arrayinfo (aa);
 131 (%o4)                 [declared, 2, [2, 3]]
 132 @end group
 133 @group
 134 (%i5) listarray (aa);
 135 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
 136                                         #####, #####, #####, %pi]
 137 @end group
 138 @end example
 139
 140 未宣言(ハッシュド)配列に適用された@code{arrayinfo}と@code{listarray}。
 141
 142 @c ===beg===
 143 @c bb [FOO] : (a + b)^2;
 144 @c bb [BAR] : (c - d)^3;
 145 @c arrayinfo (bb);
 146 @c listarray (bb);
 147 @c ===end===
 148 @example
 149 @group
 150 (%i1) bb [FOO] : (a + b)^2;
 151                                    2
 152 (%o1)                       (b + a)
 153 @end group
 154 @group
 155 (%i2) bb [BAR] : (c - d)^3;
 156                                    3
 157 (%o2)                       (c - d)
 158 @end group
 159 @group
 160 (%i3) arrayinfo (bb);
 161 (%o3)               [hashed, 1, [BAR], [FOO]]
 162 @end group
 163 @group
 164 (%i4) listarray (bb);
 165                               3         2
 166 (%o4)                 [(c - d) , (b + a) ]
 167 @end group
 168 @end example
 169
 170 配列関数に適用された@code{arrayinfo}と@code{listarray}。
 171
 172 @c ===beg===
 173 @c cc [x, y] := y / x;
 174 @c cc [u, v];
 175 @c cc [4, z];
 176 @c arrayinfo (cc);
 177 @c listarray (cc);
 178 @c ===end===
 179 @example
 180 @group
 181 (%i1) cc [x, y] := y / x;
 182                                      y
 183 (%o1)                      cc     := -
 184                              x, y    x
 185 @end group
 186 @group
 187 (%i2) cc [u, v];
 188                                 v
 189 (%o2)                           -
 190                                 u
 191 @end group
 192 @group
 193 (%i3) cc [4, z];
 194                                 z
 195 (%o3)                           -
 196                                 4
 197 @end group
 198 @group
 199 (%i4) arrayinfo (cc);
 200 (%o4)              [hashed, 2, [4, z], [u, v]]
 201 @end group
 202 @group
 203 (%i5) listarray (cc);
 204                               z  v
 205 (%o5)                        [-, -]
 206                               4  u
 207 @end group
 208 @end example
 209
 210 添字付き関数に適用された@code{arrayinfo}と@code{listarray}。
 211
 212 @c ===beg===
 213 @c dd [x] (y) := y ^ x;
 214 @c dd [a + b];
 215 @c dd [v - u];
 216 @c arrayinfo (dd);
 217 @c listarray (dd);
 218 @c ===end===
 219 @example
 220 @group
 221 (%i1) dd [x] (y) := y ^ x;
 222                                      x
 223 (%o1)                     dd (y) := y
 224                             x
 225 @end group
 226 @group
 227 (%i2) dd [a + b];
 228                                     b + a
 229 (%o2)                  lambda([y], y     )
 230 @end group
 231 @group
 232 (%i3) dd [v - u];
 233                                     v - u
 234 (%o3)                  lambda([y], y     )
 235 @end group
 236 @group
 237 (%i4) arrayinfo (dd);
 238 (%o4)             [hashed, 1, [b + a], [v - u]]
 239 @end group
 240 @group
 241 (%i5) listarray (dd);
 242                          b + a                v - u
 243 (%o5)      [lambda([y], y     ), lambda([y], y     )]
 244 @end group
 245 @end example
 246
 247 @opencatbox
 248 @category{Arrays}
 249 @closecatbox
 250 @end deffn
 251
 252 @c -----------------------------------------------------------------------------
 253 @anchor{arraymake}
 254 @deffn {関数} arraymake (@var{A}, [@var{i_1}, @dots{}, @var{i_n}])
 255 式@code{@var{A}[@var{i_1}, ..., @var{i_n}]}を返します。
 256 結果は未評価の配列参照です。
 257
 258 @code{arraymake}は、
 259 戻り値は、未評価関数コールの代わりに未評価の配列参照だということを除いて、
 260 @mref{funmake}を連想させます。
 261
 262 例:
 263 @c ===beg===
 264 @c arraymake (A, [1]);
 265 @c arraymake (A, [k]);
 266 @c arraymake (A, [i, j, 3]);
 267 @c array (A, fixnum, 10);
 268 @c fillarray (A, makelist (i^2, i, 1, 11));
 269 @c arraymake (A, [5]);
 270 @c ''%;
 271 @c L : [a, b, c, d, e];
 272 @c arraymake ('L, [n]);
 273 @c ''%, n = 3;
 274 @c A2 : make_array (fixnum, 10);
 275 @c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 276 @c arraymake ('A2, [8]);
 277 @c ''%;
 278 @c ===end===
 279 @example
 280 @group
 281 (%i1) arraymake (A, [1]);
 282 (%o1)                          A
 283                                 1
 284 @end group
 285 @group
 286 (%i2) arraymake (A, [k]);
 287 (%o2)                          A
 288                                 k
 289 @end group
 290 @group
 291 (%i3) arraymake (A, [i, j, 3]);
 292 (%o3)                       A
 293                              i, j, 3
 294 @end group
 295 @group
 296 (%i4) array (A, fixnum, 10);
 297 (%o4)                           A
 298 @end group
 299 @group
 300 (%i5) fillarray (A, makelist (i^2, i, 1, 11));
 301 (%o5)                           A
 302 @end group
 303 @group
 304 (%i6) arraymake (A, [5]);
 305 (%o6)                          A
 306                                 5
 307 @end group
 308 @group
 309 (%i7) ''%;
 310 (%o7)                          36
 311 @end group
 312 @group
 313 (%i8) L : [a, b, c, d, e];
 314 (%o8)                    [a, b, c, d, e]
 315 @end group
 316 @group
 317 (%i9) arraymake ('L, [n]);
 318 (%o9)                          L
 319                                 n
 320 @end group
 321 @group
 322 (%i10) ''%, n = 3;
 323 (%o10)                          c
 324 @end group
 325 @group
 326 (%i11) A2 : make_array (fixnum, 10);
 327 (%o11)          @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 328 @end group
 329 @group
 330 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 331 (%o12)          @{Array:  #(1 2 3 4 5 6 7 8 9 10)@}
 332 @end group
 333 @group
 334 (%i13) arraymake ('A2, [8]);
 335 (%o13)                         A2
 336                                  8
 337 @end group
 338 @group
 339 (%i14) ''%;
 340 (%o14)                          9
 341 @end group
 342 @end example
 343
 344 @opencatbox
 345 @category{Expressions}
 346 @category{Arrays}
 347 @closecatbox
 348 @end deffn
 349
 350 @c -----------------------------------------------------------------------------
 351 @anchor{arrays}
 352 @defvr {システム変数} arrays
 353 デフォルト値: @code{[]}
 354
 355 @code{arrays}は割り当てられた配列のリストです。
 356 これらは、@code{array}で宣言された配列、
 357 (なにかw配列要素に割り当てられた)陰の定義で構成されたハッシュド配列、
 358 @code{:=}と@code{define}で定義された配列関数を含みます。
 359 @mref{make_array}で定義された配列は含まれません。
 360
 361 @mref{array}, @mref{arrayapply}, @mref{arrayinfo}, @mref{arraymake},
 362 @mref{fillarray}, @mref{listarray}, @mref{rearray}も参照してください。
 363 @c IS THIS AN EXHAUSTIVE LIST ??
 364
 365 例:
 366
 367 @c ===beg===
 368 @c array (aa, 5, 7);
 369 @c bb [FOO] : (a + b)^2;
 370 @c cc [x] := x/100;
 371 @c dd : make_array ('any, 7);
 372 @c arrays;
 373 @c ===end===
 374 @example
 375 @group
 376 (%i1) array (aa, 5, 7);
 377 (%o1)                          aa
 378 @end group
 379 @group
 380 (%i2) bb [FOO] : (a + b)^2;
 381                                    2
 382 (%o2)                       (b + a)
 383 @end group
 384 @group
 385 (%i3) cc [x] := x/100;
 386                                    x
 387 (%o3)                      cc  := ---
 388                              x    100
 389 @end group
 390 @group
 391 (%i4) dd : make_array ('any, 7);
 392 (%o4)       @{Array:  #(NIL NIL NIL NIL NIL NIL NIL)@}
 393 @end group
 394 @group
 395 (%i5) arrays;
 396 (%o5)                     [aa, bb, cc]
 397 @end group
 398 @end example
 399
 400 @opencatbox
 401 @category{Arrays}
 402 @category{Global variables}
 403 @closecatbox
 404 @end defvr
 405
 406 @c -----------------------------------------------------------------------------
 407 @anchor{fillarray}
 408 @deffn {関数} fillarray (@var{A}, @var{B})
 409
 410 配列@var{A}を@var{B}から埋めます。
 411 ここで、@var{B}はリストか配列です。
 412
 413 もし生成時に特定のタイプが@var{A}のために宣言されたら、
 414 その同じタイプの要素でだけ埋めることができます;
 415 もし違ったタイプの要素をコピーする試みがなされたらエラーです。
 416
 417 もし配列@var{A}と@var{B}の次元が違ったら、
 418 @var{A}は行優先順で埋められます。
 419 もし@var{B}の中の要素が十分でないなら、
 420 @var{A}の残りを埋めるのに最後の要素が使われます。
 421 もし多すぎるなら、残りは無視されます。
 422
 423 @code{fillarray}は最初の引数を返します。
 424
 425 例:
 426
 427 9個の要素の配列を生成し、リストから埋めます。
 428 @c ===beg===
 429 @c array (a1, fixnum, 8);
 430 @c listarray (a1);
 431 @c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 432 @c listarray (a1);
 433 @c ===end===
 434 @example
 435 @group
 436 (%i1) array (a1, fixnum, 8);
 437 (%o1)                          a1
 438 @end group
 439 @group
 440 (%i2) listarray (a1);
 441 (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
 442 @end group
 443 @group
 444 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 445 (%o3)                          a1
 446 @end group
 447 @group
 448 (%i4) listarray (a1);
 449 (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]
 450 @end group
 451 @end example
 452
 453 配列を埋めるのに要素が足らない時、
 454 最後の要素が繰り返されます。
 455 要素が多すぎる時、余分の要素は無視されます。
 456 @c ===beg===
 457 @c a2 : make_array (fixnum, 8);
 458 @c fillarray (a2, [1, 2, 3, 4, 5]);
 459 @c fillarray (a2, [4]);
 460 @c fillarray (a2, makelist (i, i, 1, 100));
 461 @c ===end===
 462 @example
 463 @group
 464 (%i1) a2 : make_array (fixnum, 8);
 465 (%o1)             @{Array:  #(0 0 0 0 0 0 0 0)@}
 466 @end group
 467 @group
 468 (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
 469 (%o2)             @{Array:  #(1 2 3 4 5 5 5 5)@}
 470 @end group
 471 @group
 472 (%i3) fillarray (a2, [4]);
 473 (%o3)             @{Array:  #(4 4 4 4 4 4 4 4)@}
 474 @end group
 475 @group
 476 (%i4) fillarray (a2, makelist (i, i, 1, 100));
 477 (%o4)             @{Array:  #(1 2 3 4 5 6 7 8)@}
 478 @end group
 479 @end example
 480
 481 多次元配列は行優先順に埋められます。
 482
 483 @c ===beg===
 484 @c a3 : make_array (fixnum, 2, 5);
 485 @c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 486 @c a4 : make_array (fixnum, 5, 2);
 487 @c fillarray (a4, a3);
 488 @c ===end===
 489 @example
 490 @group
 491 (%i1) a3 : make_array (fixnum, 2, 5);
 492 (%o1)        @{Array:  #2A((0 0 0 0 0) (0 0 0 0 0))@}
 493 @end group
 494 @group
 495 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 496 (%o2)        @{Array:  #2A((1 2 3 4 5) (6 7 8 9 10))@}
 497 @end group
 498 @group
 499 (%i3) a4 : make_array (fixnum, 5, 2);
 500 (%o3)     @{Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
 501 @end group
 502 @group
 503 (%i4) fillarray (a4, a3);
 504 (%o4)     @{Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
 505 @end group
 506 @end example
 507
 508 @opencatbox
 509 @category{Arrays}
 510 @closecatbox
 511 @end deffn
 512
 513 @c -----------------------------------------------------------------------------
 514 @anchor{listarray}
 515 @deffn {関数} listarray (@var{A})
 516
 517 配列@var{A}の要素のリストを返します。
 518 引数@var{A}は、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。
 519
 520 要素は行優先順にリストされます。
 521 すなわち、要素は、最初のインデックスに従って振り分けられ、次に二番目のインデックスに従って、などなど。
 522 インデックス値の振り分け順は、
 523 @mref{orderless}が確立する順と同じです。
 524
 525 未宣言配列や、配列関数、添字付き関数では、
 526 要素は@mref{arrayinfo}が返すインデックス値に対応します。
 527
 528 宣言された一般配列のバインドされていない要素(すなわち、@code{fixnum}でも@code{flonum}でもない要素)は、 @code{#####}として返されます。
 529 宣言された@code{fixnum}配列または@code{flonum}配列のバイドされていない要素は、
 530 それぞれ0または0.0として返されます。
 531 未宣言配列、配列関数、添字付き関数のバインドされていない要素は返されません。
 532
 533 例:
 534
 535 宣言配列に適用された@code{listarray}と@code{arrayinfo}。
 536
 537 @c ===beg===
 538 @c array (aa, 2, 3);
 539 @c aa [2, 3] : %pi;
 540 @c aa [1, 2] : %e;
 541 @c listarray (aa);
 542 @c arrayinfo (aa);
 543 @c ===end===
 544 @example
 545 @group
 546 (%i1) array (aa, 2, 3);
 547 (%o1)                          aa
 548 @end group
 549 @group
 550 (%i2) aa [2, 3] : %pi;
 551 (%o2)                          %pi
 552 @end group
 553 @group
 554 (%i3) aa [1, 2] : %e;
 555 (%o3)                          %e
 556 @end group
 557 @group
 558 (%i4) listarray (aa);
 559 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
 560                                         #####, #####, #####, %pi]
 561 @end group
 562 @group
 563 (%i5) arrayinfo (aa);
 564 (%o5)                 [declared, 2, [2, 3]]
 565 @end group
 566 @end example
 567
 568 未宣言(ハッシュド)配列に適用された@code{listarray}と@code{arrayinfo}。
 569
 570 @c ===beg===
 571 @c bb [FOO] : (a + b)^2;
 572 @c bb [BAR] : (c - d)^3;
 573 @c listarray (bb);
 574 @c arrayinfo (bb);
 575 @c ===end===
 576 @example
 577 @group
 578 (%i1) bb [FOO] : (a + b)^2;
 579                                    2
 580 (%o1)                       (b + a)
 581 @end group
 582 @group
 583 (%i2) bb [BAR] : (c - d)^3;
 584                                    3
 585 (%o2)                       (c - d)
 586 @end group
 587 @group
 588 (%i3) listarray (bb);
 589                               3         2
 590 (%o3)                 [(c - d) , (b + a) ]
 591 @end group
 592 @group
 593 (%i4) arrayinfo (bb);
 594 (%o4)               [hashed, 1, [BAR], [FOO]]
 595 @end group
 596 @end example
 597
 598 配列関数に適用された@code{listarray}と@code{arrayinfo}。
 599
 600 @c ===beg===
 601 @c cc [x, y] := y / x;
 602 @c cc [u, v];
 603 @c cc [4, z];
 604 @c listarray (cc);
 605 @c arrayinfo (cc);
 606 @c ===end===
 607 @example
 608 @group
 609 (%i1) cc [x, y] := y / x;
 610                                      y
 611 (%o1)                      cc     := -
 612                              x, y    x
 613 @end group
 614 @group
 615 (%i2) cc [u, v];
 616                                 v
 617 (%o2)                           -
 618                                 u
 619 @end group
 620 @group
 621 (%i3) cc [4, z];
 622                                 z
 623 (%o3)                           -
 624                                 4
 625 @end group
 626 @group
 627 (%i4) listarray (cc);
 628                               z  v
 629 (%o4)                        [-, -]
 630                               4  u
 631 @end group
 632 @group
 633 (%i5) arrayinfo (cc);
 634 (%o5)              [hashed, 2, [4, z], [u, v]]
 635 @end group
 636 @end example
 637
 638 添字付き関数に適用された@code{listarray}と@code{arrayinfo}。
 639
 640 @c ===beg===
 641 @c dd [x] (y) := y ^ x;
 642 @c dd [a + b];
 643 @c dd [v - u];
 644 @c listarray (dd);
 645 @c arrayinfo (dd);
 646 @c ===end===
 647 @example
 648 @group
 649 (%i1) dd [x] (y) := y ^ x;
 650                                      x
 651 (%o1)                     dd (y) := y
 652                             x
 653 @end group
 654 @group
 655 (%i2) dd [a + b];
 656                                     b + a
 657 (%o2)                  lambda([y], y     )
 658 @end group
 659 @group
 660 (%i3) dd [v - u];
 661                                     v - u
 662 (%o3)                  lambda([y], y     )
 663 @end group
 664 @group
 665 (%i4) listarray (dd);
 666                          b + a                v - u
 667 (%o4)      [lambda([y], y     ), lambda([y], y     )]
 668 @end group
 669 @group
 670 (%i5) arrayinfo (dd);
 671 (%o5)             [hashed, 1, [b + a], [v - u]]
 672 @end group
 673 @end example
 674
 675 @opencatbox
 676 @category{Arrays}
 677 @closecatbox
 678 @end deffn
 679
 680 @c NEEDS CLARIFICATION
 681
 682 @c -----------------------------------------------------------------------------
 683 @anchor{make_array}
 684 @deffn {関数} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
 685
 686 Lisp配列を生成し、返します。
 687 @var{type}は、@code{any}, @code{flonum}, @code{fixnum}, @code{hashed},
 688 @code{functional}を取り得ます。
 689 @math{n}個のインデックスがあり、
 690 @math{i}番目のインデックスは0から@math{@var{dim_i} - 1}まで動きます。
 691
 692 @code{make_array}の@mref{array}に対する利点は、
 693 戻り値が名前を持たないことであり、
 694 一旦、それへのポインタが消えると、それも消えます。
 695 例えば、もし@code{y: make_array (...)}なら、
 696 @code{y}は領域を取るオブジェクトを指しますが、
 697 @code{y: false}の後、@code{y}はそのオブジェクトをもはや指さないので、
 698 オブジェクトはガーベッジコレクトされることができます。
 699
 700 @c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
 701 @c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
 702 @c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
 703 @c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
 704 @c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
 705 @c @code{make_array} in this case is the function to call to calculate array
 706 @c elements, and the rest of the arguments are passed recursively to
 707 @c @code{make_array} to generate the "memory" for the array function object.
 708
 709 例:
 710
 711 @c ===beg===
 712 @c A1 : make_array (fixnum, 10);
 713 @c A1 [8] : 1729;
 714 @c A1;
 715 @c A2 : make_array (flonum, 10);
 716 @c A2 [2] : 2.718281828;
 717 @c A2;
 718 @c A3 : make_array (any, 10);
 719 @c A3 [4] : x - y - z;
 720 @c A3;
 721 @c A4 : make_array (fixnum, 2, 3, 5);
 722 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
 723 @c A4 [0, 2, 1];
 724 @c ===end===
 725 @example
 726 @group
 727 (%i1) A1 : make_array (fixnum, 10);
 728 (%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 729 @end group
 730 @group
 731 (%i2) A1 [8] : 1729;
 732 (%o2)                         1729
 733 @end group
 734 @group
 735 (%i3) A1;
 736 (%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
 737 @end group
 738 @group
 739 (%i4) A2 : make_array (flonum, 10);
 740 (%o4) @{Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 741 @end group
 742 @group
 743 (%i5) A2 [2] : 2.718281828;
 744 (%o5)                      2.718281828
 745 @end group
 746 @group
 747 (%i6) A2;
 748 (%o6)
 749      @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 750 @end group
 751 @group
 752 (%i7) A3 : make_array (any, 10);
 753 (%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
 754 @end group
 755 @group
 756 (%i8) A3 [4] : x - y - z;
 757 (%o8)                      - z - y + x
 758 @end group
 759 @group
 760 (%i9) A3;
 761 (%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 762  -1 $Y) ((MTIMES SIMP) -1 $Z))
 763   NIL NIL NIL NIL NIL)@}
 764 @end group
 765 @group
 766 (%i10) A4 : make_array (fixnum, 2, 3, 5);
 767 (%o10) @{Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
 768 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
 769 @end group
 770 @group
 771 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
 772 (%o11) @{Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
 773     ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
 774 @end group
 775 @group
 776 (%i12) A4 [0, 2, 1];
 777 (%o12)                         12
 778 @end group
 779 @end example
 780
 781 @opencatbox
 782 @category{Arrays}
 783 @closecatbox
 784 @end deffn
 785
 786 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
 787 @c -----------------------------------------------------------------------------
 788 @anchor{rearray}
 789 @deffn {関数} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
 790
 791 配列の次元を変えます。
 792 新しい配列は
 793 行優先順に古いものの配列で埋められます。
 794 もし古い配列が小さすぎるなら、
 795 残りの要素は、
 796 配列のタイプに依って、
 797 @code{false}, @code{0.0}または@code{0}で埋められます。
 798 配列のタイプは変えられません。
 799
 800 @opencatbox
 801 @category{Arrays}
 802 @closecatbox
 803 @end deffn
 804
 805 @c -----------------------------------------------------------------------------
 806 @anchor{remarray}
 807 @deffn {関数} remarray (@var{A_1}, ..., @var{A_n})
 808 @deffnx {関数} remarray (all)
 809
 810 配列と関数に関連づけられた配列を削除し、占められた領域を開放します。
 811 引数は、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。
 812
 813 @code{remarray (all)}は、
 814 グローバルリスト@mref{arrays}の中の項目すべてを削除します。
 815
 816 @c WHAT DOES THIS MEAN EXACTLY ??
 817 もしハッシュド配列の中の値を再定義することが望ましいなら、この関数を使うことが必要になるかもしれません。
 818
 819 @code{remarray}は削除された配列のリストを返します。
 820
 821 @code{remarray}はクォートします。
 822
 823 @opencatbox
 824 @category{Arrays}
 825 @closecatbox
 826 @end deffn
 827
 828 @c -----------------------------------------------------------------------------
 829 @anchor{subvar}
 830 @deffn {関数} subvar (@var{x}, @var{i})
 831
 832 添字付き式@code{@var{x}[@var{i}]}を評価します。
 833
 834 @code{subvar}は引数を評価します。
 835
 836 @code{arraymake (@var{x}, [@var{i}]}は
 837 式@code{@var{x}[@var{i}]}を構成しますが、
 838 それを評価はしません。
 839
 840 例:
 841
 842 @c ===beg===
 843 @c x : foo $
 844 @c i : 3 $
 845 @c subvar (x, i);
 846 @c foo : [aa, bb, cc, dd, ee]$
 847 @c subvar (x, i);
 848 @c arraymake (x, [i]);
 849 @c ''%;
 850 @c ===end===
 851 @example
 852 (%i1) x : foo $
 853 (%i2) i : 3 $
 854 @group
 855 (%i3) subvar (x, i);
 856 (%o3)                         foo
 857                                  3
 858 @end group
 859 (%i4) foo : [aa, bb, cc, dd, ee]$
 860 @group
 861 (%i5) subvar (x, i);
 862 (%o5)                          cc
 863 @end group
 864 @group
 865 (%i6) arraymake (x, [i]);
 866 (%o6)                         foo
 867                                  3
 868 @end group
 869 @group
 870 (%i7) ''%;
 871 (%o7)                          cc
 872 @end group
 873 @end example
 874
 875 @opencatbox
 876 @category{Expressions}
 877 @category{Arrays}
 878 @closecatbox
 879 @end deffn
 880
 881 @c NEEDS EXPANSION AND EXAMPLES
 882
 883 @c -----------------------------------------------------------------------------
 884 @anchor{subvarp}
 885 @deffn {関数} subvarp (@var{expr})
 886
 887 もし@var{expr}が例えば@code{a[i]}のように添字された変数なら、@code{true}を返します。
 888
 889 @opencatbox
 890 @category{Predicate functions}
 891 @closecatbox
 892 @end deffn
 893
 894 @c THIS IS REALLY CONFUSING
 895
 896 @c -----------------------------------------------------------------------------
 897 @anchor{use_fast_arrays}
 898 @defvr {オプション変数} use_fast_arrays
 899
 900 もし@code{true}なら、配列の２つのタイプだけが認識されます:
 901
 902 @enumerate
 903 @item
 904 整数でインデックスされたいくつかの次元を持つができ、
 905 情報入力としてLispまたはMaximaオブジェクトを保てるart-q配列(Common Lispでのt)。
 906 そんな配列を構成するには、
 907 @code{a:make_array(any,3,4);}を入力してください。
 908 @code{a}は、12個の枠を持つ配列を値として持ち、インデックスはゼロベースです
 909
 910 @item
 911 もし@code{b[x+1]:y^2}を実行したら、生成された配列のデフォルト値でハッシュテーブル配列
 912 (@code{b}はまだ配列でもリストでも行列でもありません --
 913 もしこれらの１つなら、@code{x+1}は、art-q配列やリスト、行列の有効な添字ではないので
 914 、エラーが起こります。)
 915 (キーとしても知られている)インデックスは、任意のオブジェクトを取り得ます。
 916 一度の１つのキーだけを取ります((@code{b[x+1,u]:y}は@code{u}を無視します。)。
 917 参照は、@code{b[x+1] ==> y^2}によってされます。
 918 もちろん、キーは、例えば、
 919 @code{b[[x+1,u]]:y}が有効なように
 920 リストを取り得ます。
 921 これは古いMaximaハッシュ配列と非互換ですが、コンシングを保ちます。
 922 @end enumerate
 923
 924 配列をシンボルの値として記憶することの利点は、
 925 関数のローカル変数についての普通の慣例が配列にも適用することです。
 926 ハッシュテーブルタイプは、
 927 Maximaハッシャの古いタイプよりも
 928 少ないコンシングを使い、もっと効率的です。
 929 翻訳され、コンパイルされたコードに関する一貫した振る舞いを得るためには、
 930 @code{translate_fast_arrays}を@code{true}に設定してください。
 931
 932 @opencatbox
 933 @category{Arrays}
 934 @category{Global flags}
 935 @closecatbox
 936 @end defvr