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 @anchor{make_array}
 551 @deffn {Функция} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
 552 Создает и возвращает Lisp-массив.  @var{type} может быть
 553 @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} или
 554 @code{functional}.
 555
 556 Массив имеет @math{n} индексов, @math{i}-й индекс может принимать
 557 значение от 0 до @math{@var{dim_i}-1}.
 558
 559 Преимущество @code{make_array} по сравнению с @code{array} состоит в
 560 том, что возвращаемый Lisp-массив не имеет имени.  И как только ссылка
 561 на него исчезает, занимаемое им место освобождается.
 562 Например, если @code{y: make_array (...)}, тогда @code{y} ссылается
 563 на объект (массив), занимающий место в памяти.
 564 Но после присваивания @code{y: false}, @code{y} больше не ссылается
 565 на данный массив и занимаемое им место будет освобождено
 566 при сборке мусора.
 567
 568 @c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
 569 @c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
 570 @c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
 571 @c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
 572 @c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
 573 @c @code{make_array} in this case is the function to call to calculate array
 574 @c elements, and the rest of the arguments are passed recursively to
 575 @c @code{make_array} to generate the "memory" for the array function object.
 576
 577 Примеры:
 578 @c ===beg===
 579 @c A1 : make_array (fixnum, 10);
 580 @c A1 [8] : 1729;
 581 @c A1;
 582 @c A2 : make_array (flonum, 10);
 583 @c A2 [2] : 2.718281828;
 584 @c A2;
 585 @c A3 : make_array (any, 10);
 586 @c A3 [4] : x - y - z;
 587 @c A3;
 588 @c A4 : make_array (fixnum, 2, 3, 5);
 589 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
 590 @c A4 [0, 2, 1];
 591 @c ===end===
 592
 593 @example
 594 (%i1) A1 : make_array (fixnum, 10);
 595 (%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 596 (%i2) A1 [8] : 1729;
 597 (%o2)                         1729
 598 (%i3) A1;
 599 (%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
 600 (%i4) A2 : make_array (flonum, 10);
 601 (%o4) @{Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 602 (%i5) A2 [2] : 2.718281828;
 603 (%o5)                      2.718281828
 604 (%i6) A2;
 605 (%o6)
 606      @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 607 (%i7) A3 : make_array (any, 10);
 608 (%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
 609 (%i8) A3 [4] : x - y - z;
 610 (%o8)                      - z - y + x
 611 (%i9) A3;
 612 (%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 613  -1 $Y) ((MTIMES SIMP) -1 $Z))
 614   NIL NIL NIL NIL NIL)@}
 615 (%i10) A4 : make_array (fixnum, 2, 3, 5);
 616 (%o10) @{Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
 617 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
 618 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
 619 (%o11) @{Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
 620     ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
 621 (%i12) A4 [0, 2, 1];
 622 (%o12)                         12
 623 @end example
 624
 625 @opencatbox{Категории:}
 626 @category{Массивы}
 627 @closecatbox
 628
 629 @end deffn
 630
 631 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
 632 @deffn {Функция} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
 633 Изменяет размерность массива.  Новый массив будет заполнен элементами
 634 старого построчно.  Если исходный массив слишком мал, тогда
 635 остаток заполняется @code{false}, @code{0.0} или @code{0},
 636 в зависимости от типа массива.  Тип массива не может быть изменен.
 637
 638 @opencatbox{Категории:}
 639 @category{Массивы}
 640 @closecatbox
 641
 642 @end deffn
 643
 644 @deffn {Функция} remarray (@var{A_1}, ..., @var{A_n})
 645 @deffnx {Функция} remarray (all)
 646 Удаляет массив, все ассоциированные с ним функции и
 647 освобождает занимаемую им память.
 648 Аргументы должны быть: объявленными массивами, необъявленными (хеш)
 649 массивами, функциями-массивами или функциями с индексом.
 650
 651 @code{remarray (all)} удаляет все элементы в глобальном списке @code{arrays}.
 652
 653 @c WHAT DOES THIS MEAN EXACTLY ??
 654 Использование @code{remarray} может требоваться если
 655 необходимо переопределить значения элементов
 656 необъявленного (хеш) массива.
 657
 658 @code{remarray} возвращает список удаленных массивов.
 659
 660 @opencatbox{Категории:}
 661 @category{Массивы}
 662 @closecatbox
 663
 664 @end deffn
 665
 666 @deffn {Функция} subvar (@var{x}, @var{i})
 667 Вычисляет выражение с индексом @code{@var{x}[@var{i}]}.
 668
 669 @code{subvar} вычисляет свои аргументы.
 670
 671 @code{arraymake (@var{x}, [@var{i}]} составляет выражение @code{@var{x}[@var{i}]},
 672 но не вычисляет его.
 673
 674 Примеры:
 675
 676 @c ===beg===
 677 @c x : foo $
 678 @c i : 3 $
 679 @c subvar (x, i);
 680 @c foo : [aa, bb, cc, dd, ee]$
 681 @c subvar (x, i);
 682 @c arraymake (x, [i]);
 683 @c ''%;
 684 @c ===end===
 685 @example
 686 (%i1) x : foo $
 687
 688 (%i2) i : 3 $
 689
 690 (%i3) subvar (x, i);
 691 (%o3)                         foo
 692                                  3
 693 (%i4) foo : [aa, bb, cc, dd, ee]$
 694
 695 (%i5) subvar (x, i);
 696 (%o5)                          cc
 697 (%i6) arraymake (x, [i]);
 698 (%o6)                         foo
 699                                  3
 700 (%i7) ''%;
 701 (%o7)                          cc
 702 @end example
 703
 704 @opencatbox{Категории:}
 705 @category{Выражения}
 706 @category{Массивы}
 707 @closecatbox
 708
 709 @end deffn
 710
 711 @c THIS IS REALLY CONFUSING
 712 @defvr {Управляющая переменная} use_fast_arrays
 713 -- если @code{true}, тогда используются только два типа массивов.
 714
 715 1) Art-q массивы (t в Common Lisp), которые имеют несколько
 716 целочисленных индексов, и могут содержать любые Lisp или Maxima
 717 объекты.  Для создания таких массивов используется функция
 718 @code{make_array}.  Например @code{a:make_array(any,3,4);}.
 719 Значение @code{a} -- массив из 12 элементов. Отсчет индексов
 720 ведется с 0.
 721
 722 2) Hash_table массивы, создающиеся по умолчанию если выполняется
 723 присваивания @code{b[x+1]:y^2} если @code{b} еще пока не является
 724 массивом, списком или матрицей (во всех этих случаях должна возникнуть
 725 ошибка т.к. @code{x+1} в общем случае не является допустимым индексом
 726 для art-q массива, списка или матрицы).  Индексом такого массива
 727 (также называется ключем) может быть произвольный объект.
 728 Используется только один ключ одновременно, так в @code{b[x+1,u]:y}
 729 игнорирует @code{u} а соответствие устанавливается по
 730 @code{b[x+1] ==> y^2}.  Разумеется ключ может быть списком, например
 731 @code{b[[x+1,u]]:y} вполне допустимо.  Это не совместимо со старыми
 732 хешируемыми массивами, но экономит память.
 733
 734 Преимущество хранения массивов в значении переменной состоит в том,
 735 что в этом случае массивы следуют обычным соглашениям о локальных
 736 переменных.  Кроме того Hash_table массивы более эффективны и
 737 используют меньше памяти, чем старые хешируемые массивы.  Для
 738 одинакового поведения в интерпретируемом и компилируемом коде
 739 необходимо установить значение @code{translate_fast_arrays} равным
 740 @code{true}.
 741
 742 @opencatbox{Категории:}
 743 @category{Массивы}
 744 @category{Глобальные флаги}
 745 @closecatbox
 746
 747 @end defvr
 748