doc/info/ru/Arrays.texi

   1 @c Language=Russian
   2 @c Encoding=UTF-8
   3 @c File=Arrays.texi
   4 @c OriginalRevision=1.16
   5 @c TranslatedBy: (c) 2005-12 Vadim V. Zhytnikov <vvzhyt@gmail.ru>
   6
   7 @menu
   8 * Функции и переменные для работы с массивами::
   9 @end menu
  10
  11 @node Функции и переменные для работы с массивами,  , Массивы, Массивы
  12 @section Функции и переменные для работы с массивами
  13
  14 @deffn {Функция} array (@var{name}, @var{dim_1}, ..., @var{dim_n})
  15 @deffnx {Функция} array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})
  16 @deffnx {Функция} array ([@var{name_1}, ..., @var{name_m}], @var{dim_1}, ..., @var{dim_n})
  17
  18 Создает @math{n}-мерный массив.
  19 Значение @math{n} должно быть меньше или равно 5.
  20 @math{i}-й индекс может принимать целочисленное значение от
  21 0 до @var{dim_i}.
  22
  23 @code{array (@var{name}, @var{dim_1}, ..., @var{dim_n})} -- создает
  24 массив общего вида.
  25
  26 @code{array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})}
  27 -- создает массив, элементы которого имеют определенный тип.
  28 @var{type} может быть @code{fixnum} для целых чисел ограниченной
  29 точности и @code{flonum} для чисел с плавающей точкой.
  30
  31 @code{array ([@var{name_1}, ..., @var{name_m}], @var{dim_1}, ..., @var{dim_n})}
  32 -- создает  @math{m} массивов одинаковой размерности.
  33 @c SAME TYPE AS WELL ??
  34
  35 @c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
  36 Если пользователь присваивает значение переменной с индексом
  37 до того, как соответствующий массив объявлен, тогда создается
  38 необъявленный массив.  Необъявленные массивы, также известные как
  39 хеш-массивы (т.к. для хранения элементов применяется
  40 хеширование), являются более общими чем объявленные массивы.
  41 Пользователь не определяет их максимальный размер, и они
  42 растут динамически по мере присваивания значений их элементам.
  43 Индексы необъявленных массивов даже не обязаны быть целочисленными.
  44 Однако, за исключением случая когда массив сильно разряжен,
  45 объявленный массив, обычно, более эффективен чем необъявленный.
  46 Функция @code{array} может преобразовать необъявленный массив
  47 в объявленный.
  48 @c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??
  49
  50 @opencatbox{Категории:}
  51 @category{Массивы}
  52 @closecatbox
  53
  54 @end deffn
  55
  56 @deffn {Функция} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
  57 Вычисляет значение @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
  58 где  @var{A} -- массив, а @var{i_1}, ..., @var{i_n} целые числа.
  59
  60 Данная функция похожа на @code{apply}, только первый аргумент является
  61 массивом а не функцией.
  62
  63 @opencatbox{Категории:}
  64 @category{Выражения}
  65 @category{Массивы}
  66 @closecatbox
  67
  68 @end deffn
  69
  70 @deffn {Функция} arrayinfo (@var{A})
  71 Возвращает информацию о массиве @var{A}.
  72 Аргумент @var{A} может быть объявленным массивом, необъявленным (хеш-) массивом,
  73 функцией-массивом или функцией с индексом.
  74
  75 Для объявленного массива @code{arrayinfo} возвращает список состоящий из
  76 атома @code{declared}, размерности массива и размера каждого из измерений.
  77 Элементы массива, как имеющие значение, так и не имеющие значения,
  78 возвращаются функцией @code{listarray}.
  79
  80 Для необъявленных массивов (хеш-массивов) @code{arrayinfo}
  81 возвращает список состоящий из атома @code{hashed}, числа индексов и
  82 индексов всех элементов, которые имеют значение.
  83 Значения массива возвращаются функцией @code{listarray}.
  84
  85 Для функций-массивов
  86 @code{arrayinfo} возвращает список состоящий из атома @code{hashed}, числа индексов и
  87 индексов всех элементов, которые содержат функциональные значения.
  88 Функциональные значения возвращаются функцией @code{listarray}.
  89
  90 Для функций с индексом
  91 @code{arrayinfo} возвращает список состоящий из атома @code{hashed}, числа индексов и
  92 индексов всех элементов, которые содержат лямбда-выражения.
  93 Лямбда-выражения возвращаются функцией @code{listarray}.
  94
  95 Примеры:
  96
  97 @code{arrayinfo} и @code{listarray} примененные к объявленному массиву.
  98
  99 @c ===beg===
 100 @c array (aa, 2, 3);
 101 @c aa [2, 3] : %pi;
 102 @c aa [1, 2] : %e;
 103 @c arrayinfo (aa);
 104 @c listarray (aa);
 105 @c ===end===
 106 @example
 107 (%i1) array (aa, 2, 3);
 108 (%o1)                          aa
 109 (%i2) aa [2, 3] : %pi;
 110 (%o2)                          %pi
 111 (%i3) aa [1, 2] : %e;
 112 (%o3)                          %e
 113 (%i4) arrayinfo (aa);
 114 (%o4)                 [declared, 2, [2, 3]]
 115 (%i5) listarray (aa);
 116 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
 117                                         #####, #####, #####, %pi]
 118 @end example
 119
 120 @code{arrayinfo} и @code{listarray} примененные к необъявленному (хеш) массиву.
 121
 122 @c ===beg===
 123 @c bb [FOO] : (a + b)^2;
 124 @c bb [BAR] : (c - d)^3;
 125 @c arrayinfo (bb);
 126 @c listarray (bb);
 127 @c ===end===
 128 @example
 129 (%i1) bb [FOO] : (a + b)^2;
 130                                    2
 131 (%o1)                       (b + a)
 132 (%i2) bb [BAR] : (c - d)^3;
 133                                    3
 134 (%o2)                       (c - d)
 135 (%i3) arrayinfo (bb);
 136 (%o3)               [hashed, 1, [BAR], [FOO]]
 137 (%i4) listarray (bb);
 138                               3         2
 139 (%o4)                 [(c - d) , (b + a) ]
 140 @end example
 141
 142 @code{arrayinfo} и @code{listarray} примененные к функции-массиву.
 143
 144 @c ===beg===
 145 @c cc [x, y] := y / x;
 146 @c cc [u, v];
 147 @c cc [4, z];
 148 @c arrayinfo (cc);
 149 @c listarray (cc);
 150 @c ===end===
 151 @example
 152 (%i1) cc [x, y] := y / x;
 153                                      y
 154 (%o1)                      cc     := -
 155                              x, y    x
 156 (%i2) cc [u, v];
 157                                 v
 158 (%o2)                           -
 159                                 u
 160 (%i3) cc [4, z];
 161                                 z
 162 (%o3)                           -
 163                                 4
 164 (%i4) arrayinfo (cc);
 165 (%o4)              [hashed, 2, [4, z], [u, v]]
 166 (%i5) listarray (cc);
 167                               z  v
 168 (%o5)                        [-, -]
 169                               4  u
 170 @end example
 171
 172 @code{arrayinfo} и @code{listarray} примененные к функции с индексом.
 173
 174 @c ===beg===
 175 @c dd [x] (y) := y ^ x;
 176 @c dd [a + b];
 177 @c dd [v - u];
 178 @c arrayinfo (dd);
 179 @c listarray (dd);
 180 @c ===end===
 181 @example
 182 (%i1) dd [x] (y) := y ^ x;
 183                                      x
 184 (%o1)                     dd (y) := y
 185                             x
 186 (%i2) dd [a + b];
 187                                     b + a
 188 (%o2)                  lambda([y], y     )
 189 (%i3) dd [v - u];
 190                                     v - u
 191 (%o3)                  lambda([y], y     )
 192 (%i4) arrayinfo (dd);
 193 (%o4)             [hashed, 1, [b + a], [v - u]]
 194 (%i5) listarray (dd);
 195                          b + a                v - u
 196 (%o5)      [lambda([y], y     ), lambda([y], y     )]
 197 @end example
 198
 199 @opencatbox{Категории:}
 200 @category{Массивы}
 201 @closecatbox
 202
 203 @end deffn
 204
 205 @deffn {Функция} arraymake (@var{A}, [@var{i_1}, ..., @var{i_n}])
 206 Возвращает выражение @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
 207 Этот результат является не вычисленной ссылкой на элемент
 208 массива.
 209
 210 Функция @code{arraymake} похожа на @code{funmake},
 211 за исключеним того, что возвращает не вычисленный элемент массива
 212 вместо от не вычисленного вызова функции.
 213
 214 Примеры:
 215 @c ===beg===
 216 @c arraymake (A, [1]);
 217 @c arraymake (A, [k]);
 218 @c arraymake (A, [i, j, 3]);
 219 @c array (A, fixnum, 10);
 220 @c fillarray (A, makelist (i^2, i, 1, 11));
 221 @c arraymake (A, [5]);
 222 @c ''%;
 223 @c L : [a, b, c, d, e];
 224 @c arraymake ('L, [n]);
 225 @c ''%, n = 3;
 226 @c A2 : make_array (fixnum, 10);
 227 @c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 228 @c arraymake ('A2, [8]);
 229 @c ''%;
 230 @c ===end===
 231
 232 @example
 233 (%i1) arraymake (A, [1]);
 234 (%o1)                          A
 235                                 1
 236 (%i2) arraymake (A, [k]);
 237 (%o2)                          A
 238                                 k
 239 (%i3) arraymake (A, [i, j, 3]);
 240 (%o3)                       A
 241                              i, j, 3
 242 (%i4) array (A, fixnum, 10);
 243 (%o4)                           A
 244 (%i5) fillarray (A, makelist (i^2, i, 1, 11));
 245 (%o5)                           A
 246 (%i6) arraymake (A, [5]);
 247 (%o6)                          A
 248                                 5
 249 (%i7) ''%;
 250 (%o7)                          36
 251 (%i8) L : [a, b, c, d, e];
 252 (%o8)                    [a, b, c, d, e]
 253 (%i9) arraymake ('L, [n]);
 254 (%o9)                          L
 255                                 n
 256 (%i10) ''%, n = 3;
 257 (%o10)                          c
 258 (%i11) A2 : make_array (fixnum, 10);
 259 (%o11)          @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 260 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 261 (%o12)          @{Array:  #(1 2 3 4 5 6 7 8 9 10)@}
 262 (%i13) arraymake ('A2, [8]);
 263 (%o13)                         A2
 264                                  8
 265 (%i14) ''%;
 266 (%o14)                          9
 267 @end example
 268
 269 @opencatbox{Категории:}
 270 @category{Выражения}
 271 @category{Массивы}
 272 @closecatbox
 273
 274 @end deffn
 275
 276 @defvr {Системная переменная} arrays
 277 Значение по умолчанию: @code{[]}
 278
 279 Список @code{arrays} содержит всех существующих массивов.
 280 Что составляет: массивы, объявленные при помощи @code{array};
 281 хеш-массивы, созданные при помощи неявных определение (присваиванием чего-либо элементу массива);
 282 функции-массивы, определенные с помощью @code{:=} и @code{define}.
 283 Массивы, созданные при помощи @code{make_array}, в список не включаются.
 284
 285 См. также
 286 @code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake},
 287 @code{fillarray}, @code{listarray}, and @code{rearray}.
 288 @c IS THIS AN EXHAUSTIVE LIST ??
 289
 290 Примеры:
 291
 292 @c ===beg===
 293 @c array (aa, 5, 7);
 294 @c bb [FOO] : (a + b)^2;
 295 @c cc [x] := x/100;
 296 @c dd : make_array ('any, 7);
 297 @c arrays;
 298 @c ===end===
 299 @example
 300 (%i1) array (aa, 5, 7);
 301 (%o1)                          aa
 302 (%i2) bb [FOO] : (a + b)^2;
 303                                    2
 304 (%o2)                       (b + a)
 305 (%i3) cc [x] := x/100;
 306                                    x
 307 (%o3)                      cc  := ---
 308                              x    100
 309 (%i4) dd : make_array ('any, 7);
 310 (%o4)       @{Array:  #(NIL NIL NIL NIL NIL NIL NIL)@}
 311 (%i5) arrays;
 312 (%o5)                     [aa, bb, cc]
 313 @end example
 314
 315 @opencatbox{Категории:}
 316 @category{Массивы}
 317 @category{Глобальные переменные}
 318 @closecatbox
 319
 320 @end defvr
 321
 322 @deffn {Функция} bashindices (@var{expr})
 323 Преобразует выражение @var{expr} присваивая каждому суммированию или
 324 произведению уникальный индекс.  Индекс имеет форму
 325 @code{j@var{number}}.  Величина @var{number} определяется
 326 значением переменной @code{gensumnum}, которое может быть установлено
 327 пользователем.  Например @code{gensumnum:0$}, инициализирует
 328 эту переменную.
 329
 330 @opencatbox{Категории:}
 331 @category{Суммы и произведения}
 332 @closecatbox
 333
 334 @end deffn
 335
 336 @deffn {Функция} fillarray (@var{A}, @var{B})
 337 Заполняет массив @var{A} элементами из @var{B}, являющимся
 338 списком или массивом.
 339
 340 Если для массива @var{A} в момент создания был задан тип элементов,
 341 то он может быть заполнен только элементами данного типа и
 342 попытка заполнения элементами другого типа является ошибкой.
 343
 344 Если размерность массивов не совпадает, тогда @var{A}
 345 заполняется построчно.  Если число элементов @var{B} недостаточно, то
 346 последний элемент используется для заполнения остатка @var{A}.
 347 Если число элементов @var{B} слишком велико, тогда излишние отбрасываются.
 348
 349 @code{fillarray} возвращает свой первый аргумент.
 350
 351 Примеры:
 352
 353 Создается массив из 9 элементов и заполняется из списка.
 354 @c ===beg===
 355 @c array (a1, fixnum, 8);
 356 @c listarray (a1);
 357 @c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 358 @c listarray (a1);
 359 @c ===end===
 360
 361 @example
 362 (%i1) array (a1, fixnum, 8);
 363 (%o1)                          a1
 364 (%i2) listarray (a1);
 365 (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
 366 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 367 (%o3)                          a1
 368 (%i4) listarray (a1);
 369 (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]
 370 @end example
 371
 372 Если недостаточно элементов для заполнения массива,
 373 то последний элемент повторяется.
 374 Если элементов слишком много, то излишние элементы
 375 игнорируются.
 376 @c ===beg===
 377 @c a2 : make_array (fixnum, 8);
 378 @c fillarray (a2, [1, 2, 3, 4, 5]);
 379 @c fillarray (a2, [4]);
 380 @c fillarray (a2, makelist (i, i, 1, 100));
 381 @c ===end===
 382
 383 @example
 384 (%i1) a2 : make_array (fixnum, 8);
 385 (%o1)             @{Array:  #(0 0 0 0 0 0 0 0)@}
 386 (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
 387 (%o2)             @{Array:  #(1 2 3 4 5 5 5 5)@}
 388 (%i3) fillarray (a2, [4]);
 389 (%o3)             @{Array:  #(4 4 4 4 4 4 4 4)@}
 390 (%i4) fillarray (a2, makelist (i, i, 1, 100));
 391 (%o4)             @{Array:  #(1 2 3 4 5 6 7 8)@}
 392 @end example
 393
 394 Многомерные массивы заполняются построчно.
 395 @c ===beg===
 396 @c a3 : make_array (fixnum, 2, 5);
 397 @c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 398 @c a4 : make_array (fixnum, 5, 2);
 399 @c fillarray (a4, a3);
 400 @c ===end===
 401
 402 @example
 403 (%i1) a3 : make_array (fixnum, 2, 5);
 404 (%o1)        @{Array:  #2A((0 0 0 0 0) (0 0 0 0 0))@}
 405 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 406 (%o2)        @{Array:  #2A((1 2 3 4 5) (6 7 8 9 10))@}
 407 (%i3) a4 : make_array (fixnum, 5, 2);
 408 (%o3)     @{Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
 409 (%i4) fillarray (a4, a3);
 410 (%o4)     @{Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
 411 @end example
 412
 413 @opencatbox{Категории:}
 414 @category{Массивы}
 415 @closecatbox
 416
 417 @end deffn
 418
 419 @deffn {Функция} listarray (@var{A})
 420 Возвращает список элементов массива @var{A}.
 421 Аргумент @var{A} должен быть объявленным массивом, необъявленным (хеш) массивом,
 422 функцией-массивом или функцией с индексами.
 423
 424 Элементы помещаются в список построчно.
 425 Т.е. сначала помещаются элементы по первому индексу, затем по второму и т.д.
 426 Порядок значений индексов тот же, что установлен при помощи @code{orderless}.
 427
 428 Для необъявленных массивов, функций-массивов и функций с индексом,
 429 возвращаются элементы соответствующие индексам возвращаемым
 430 функцией @code{arrayinfo}.
 431
 432 Для объявленных массивов общего типа (т.е не @code{fixnum} или @code{flonum}) элементы не имеющие значения
 433 возвращаются как @code{#####}.
 434 Не присвоенные элементы объявленных @code{fixnum} или @code{flonum} массивов
 435 возвращаются как 0 или 0.0 соответственно.
 436 Не присвоенные элементы необъявленных массивов, функций-массивов
 437 и функций с индексом не возвращаются.
 438
 439 Примеры:
 440
 441 @code{listarray} и @code{arrayinfo} примененные к объявленному массиву.
 442
 443 @c ===beg===
 444 @c array (aa, 2, 3);
 445 @c aa [2, 3] : %pi;
 446 @c aa [1, 2] : %e;
 447 @c listarray (aa);
 448 @c arrayinfo (aa);
 449 @c ===end===
 450 @example
 451 (%i1) array (aa, 2, 3);
 452 (%o1)                          aa
 453 (%i2) aa [2, 3] : %pi;
 454 (%o2)                          %pi
 455 (%i3) aa [1, 2] : %e;
 456 (%o3)                          %e
 457 (%i4) listarray (aa);
 458 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
 459                                         #####, #####, #####, %pi]
 460 (%i5) arrayinfo (aa);
 461 (%o5)                 [declared, 2, [2, 3]]
 462 @end example
 463
 464 @code{arrayinfo} и @code{listarray} примененные к необъявленному (хеш) массиву.
 465
 466 @c ===beg===
 467 @c bb [FOO] : (a + b)^2;
 468 @c bb [BAR] : (c - d)^3;
 469 @c listarray (bb);
 470 @c arrayinfo (bb);
 471 @c ===end===
 472 @example
 473 (%i1) bb [FOO] : (a + b)^2;
 474                                    2
 475 (%o1)                       (b + a)
 476 (%i2) bb [BAR] : (c - d)^3;
 477                                    3
 478 (%o2)                       (c - d)
 479 (%i3) listarray (bb);
 480                               3         2
 481 (%o3)                 [(c - d) , (b + a) ]
 482 (%i4) arrayinfo (bb);
 483 (%o4)               [hashed, 1, [BAR], [FOO]]
 484 @end example
 485
 486 @code{arrayinfo} и @code{listarray} примененные к функции-массиву.
 487
 488 @c ===beg===
 489 @c cc [x, y] := y / x;
 490 @c cc [u, v];
 491 @c cc [4, z];
 492 @c listarray (cc);
 493 @c arrayinfo (cc);
 494 @c ===end===
 495 @example
 496 (%i1) cc [x, y] := y / x;
 497                                      y
 498 (%o1)                      cc     := -
 499                              x, y    x
 500 (%i2) cc [u, v];
 501                                 v
 502 (%o2)                           -
 503                                 u
 504 (%i3) cc [4, z];
 505                                 z
 506 (%o3)                           -
 507                                 4
 508 (%i4) listarray (cc);
 509                               z  v
 510 (%o4)                        [-, -]
 511                               4  u
 512 (%i5) arrayinfo (cc);
 513 (%o5)              [hashed, 2, [4, z], [u, v]]
 514 @end example
 515
 516 @code{arrayinfo} и @code{listarray} примененные к функции с индексом.
 517
 518 @c ===beg===
 519 @c dd [x] (y) := y ^ x;
 520 @c dd [a + b];
 521 @c dd [v - u];
 522 @c listarray (dd);
 523 @c arrayinfo (dd);
 524 @c ===end===
 525 @example
 526 (%i1) dd [x] (y) := y ^ x;
 527                                      x
 528 (%o1)                     dd (y) := y
 529                             x
 530 (%i2) dd [a + b];
 531                                     b + a
 532 (%o2)                  lambda([y], y     )
 533 (%i3) dd [v - u];
 534                                     v - u
 535 (%o3)                  lambda([y], y     )
 536 (%i4) listarray (dd);
 537                          b + a                v - u
 538 (%o4)      [lambda([y], y     ), lambda([y], y     )]
 539 (%i5) arrayinfo (dd);
 540 (%o5)             [hashed, 1, [b + a], [v - u]]
 541 @end example
 542
 543 @opencatbox{Категории:}
 544 @category{Массивы}
 545 @closecatbox
 546
 547 @end deffn
 548
 549 @c NEEDS CLARIFICATION
 550 @deffn {Функция} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
 551 Создает и возвращает Lisp-массив.  @var{type} может быть
 552 @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} или
 553 @code{functional}.
 554
 555 Массив имеет @math{n} индексов, @math{i}-й индекс может принимать
 556 значение от 0 до @math{@var{dim_i}-1}.
 557
 558 Преимущество @code{make_array} по сравнению с @code{array} состоит в
 559 том, что возвращаемый Lisp-массив не имеет имени.  И как только ссылка
 560 на него исчезает, занимаемое им место освобождается.
 561 Например, если @code{y: make_array (...)}, тогда @code{y} ссылается
 562 на объект (массив), занимающий место в памяти.
 563 Но после присваивания @code{y: false}, @code{y} больше не ссылается
 564 на данный массив и занимаемое им место будет освобождено
 565 при сборке мусора.
 566
 567 @c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
 568 @c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
 569 @c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
 570 @c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
 571 @c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
 572 @c @code{make_array} in this case is the function to call to calculate array
 573 @c elements, and the rest of the arguments are passed recursively to
 574 @c @code{make_array} to generate the "memory" for the array function object.
 575
 576 Примеры:
 577 @c ===beg===
 578 @c A1 : make_array (fixnum, 10);
 579 @c A1 [8] : 1729;
 580 @c A1;
 581 @c A2 : make_array (flonum, 10);
 582 @c A2 [2] : 2.718281828;
 583 @c A2;
 584 @c A3 : make_array (any, 10);
 585 @c A3 [4] : x - y - z;
 586 @c A3;
 587 @c A4 : make_array (fixnum, 2, 3, 5);
 588 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
 589 @c A4 [0, 2, 1];
 590 @c ===end===
 591
 592 @example
 593 (%i1) A1 : make_array (fixnum, 10);
 594 (%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 595 (%i2) A1 [8] : 1729;
 596 (%o2)                         1729
 597 (%i3) A1;
 598 (%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
 599 (%i4) A2 : make_array (flonum, 10);
 600 (%o4) @{Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 601 (%i5) A2 [2] : 2.718281828;
 602 (%o5)                      2.718281828
 603 (%i6) A2;
 604 (%o6)
 605      @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 606 (%i7) A3 : make_array (any, 10);
 607 (%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
 608 (%i8) A3 [4] : x - y - z;
 609 (%o8)                      - z - y + x
 610 (%i9) A3;
 611 (%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 612  -1 $Y) ((MTIMES SIMP) -1 $Z))
 613   NIL NIL NIL NIL NIL)@}
 614 (%i10) A4 : make_array (fixnum, 2, 3, 5);
 615 (%o10) @{Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
 616 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
 617 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
 618 (%o11) @{Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
 619     ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
 620 (%i12) A4 [0, 2, 1];
 621 (%o12)                         12
 622 @end example
 623
 624 @opencatbox{Категории:}
 625 @category{Массивы}
 626 @closecatbox
 627
 628 @end deffn
 629
 630 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
 631 @deffn {Функция} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
 632 Изменяет размерность массива.  Новый массив будет заполнен элементами
 633 старого построчно.  Если исходный массив слишком мал, тогда
 634 остаток заполняется @code{false}, @code{0.0} или @code{0},
 635 в зависимости от типа массива.  Тип массива не может быть изменен.
 636
 637 @opencatbox{Категории:}
 638 @category{Массивы}
 639 @closecatbox
 640
 641 @end deffn
 642
 643 @deffn {Функция} remarray (@var{A_1}, ..., @var{A_n})
 644 @deffnx {Функция} remarray (all)
 645 Удаляет массив, все ассоциированные с ним функции и
 646 освобождает занимаемую им память.
 647 Аргументы должны быть: объявленными массивами, необъявленными (хеш)
 648 массивами, функциями-массивами или функциями с индексом.
 649
 650 @code{remarray (all)} удаляет все элементы в глобальном списке @code{arrays}.
 651
 652 @c WHAT DOES THIS MEAN EXACTLY ??
 653 Использование @code{remarray} может требоваться если
 654 необходимо переопределить значения элементов
 655 необъявленного (хеш) массива.
 656
 657 @code{remarray} возвращает список удаленных массивов.
 658
 659 @opencatbox{Категории:}
 660 @category{Массивы}
 661 @closecatbox
 662
 663 @end deffn
 664
 665 @deffn {Функция} subvar (@var{x}, @var{i})
 666 Вычисляет выражение с индексом @code{@var{x}[@var{i}]}.
 667
 668 @code{subvar} вычисляет свои аргументы.
 669
 670 @code{arraymake (@var{x}, [@var{i}]} составляет выражение @code{@var{x}[@var{i}]},
 671 но не вычисляет его.
 672
 673 Примеры:
 674
 675 @c ===beg===
 676 @c x : foo $
 677 @c i : 3 $
 678 @c subvar (x, i);
 679 @c foo : [aa, bb, cc, dd, ee]$
 680 @c subvar (x, i);
 681 @c arraymake (x, [i]);
 682 @c ''%;
 683 @c ===end===
 684 @example
 685 (%i1) x : foo $
 686
 687 (%i2) i : 3 $
 688
 689 (%i3) subvar (x, i);
 690 (%o3)                         foo
 691                                  3
 692 (%i4) foo : [aa, bb, cc, dd, ee]$
 693
 694 (%i5) subvar (x, i);
 695 (%o5)                          cc
 696 (%i6) arraymake (x, [i]);
 697 (%o6)                         foo
 698                                  3
 699 (%i7) ''%;
 700 (%o7)                          cc
 701 @end example
 702
 703 @opencatbox{Категории:}
 704 @category{Выражения}
 705 @category{Массивы}
 706 @closecatbox
 707
 708 @end deffn
 709
 710 @c THIS IS REALLY CONFUSING
 711 @defvr {Управляющая переменная} use_fast_arrays
 712 -- если @code{true}, тогда используются только два типа массивов.
 713
 714 1) Art-q массивы (t в Common Lisp), которые имеют несколько
 715 целочисленных индексов, и могут содержать любые Lisp или Maxima
 716 объекты.  Для создания таких массивов используется функция
 717 @code{make_array}.  Например @code{a:make_array(any,3,4);}.
 718 Значение @code{a} -- массив из 12 элементов. Отсчет индексов
 719 ведется с 0.
 720
 721 2) Hash_table массивы, создающиеся по умолчанию если выполняется
 722 присваивания @code{b[x+1]:y^2} если @code{b} еще пока не является
 723 массивом, списком или матрицей (во всех этих случаях должна возникнуть
 724 ошибка т.к. @code{x+1} в общем случае не является допустимым индексом
 725 для art-q массива, списка или матрицы).  Индексом такого массива
 726 (также называется ключем) может быть произвольный объект.
 727 Используется только один ключ одновременно, так в @code{b[x+1,u]:y}
 728 игнорирует @code{u} а соответствие устанавливается по
 729 @code{b[x+1] ==> y^2}.  Разумеется ключ может быть списком, например
 730 @code{b[[x+1,u]]:y} вполне допустимо.  Это не совместимо со старыми
 731 хешируемыми массивами, но экономит память.
 732
 733 Преимущество хранения массивов в значении переменной состоит в том,
 734 что в этом случае массивы следуют обычным соглашениям о локальных
 735 переменных.  Кроме того Hash_table массивы более эффективны и
 736 используют меньше памяти, чем старые хешируемые массивы.  Для
 737 одинакового поведения в интерпретируемом и компилируемом коде
 738 необходимо установить значение @code{translate_fast_arrays} равным
 739 @code{true}.
 740
 741 @opencatbox{Категории:}
 742 @category{Массивы}
 743 @category{Глобальные флаги}
 744 @closecatbox
 745
 746 @end defvr
 747