@c Language=Russian
@c Encoding=CP1251
@c File=Arrays.texi
@c OriginalRevision=1.16
@c TranslatedBy: (c) 2005-12 Vadim V. Zhytnikov <vvzhyt@gmail.ru>

@menu
* Функции и переменные для работы с массивами::  
@end menu

@node Функции и переменные для работы с массивами,  , Массивы, Массивы
@section Функции и переменные для работы с массивами

@deffn {Функция} array (@var{name}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Функция} array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})
@deffnx {Функция} array ([@var{name_1}, ..., @var{name_m}], @var{dim_1}, ..., @var{dim_n})

Создает @math{n}-мерный массив.
Значение @math{n} должно быть меньше или равно 5.
@math{i}-й индекс может принимать целочисленное значение от
0 до @var{dim_i}.

@code{array (@var{name}, @var{dim_1}, ..., @var{dim_n})} -- создает
массив общего вида.

@code{array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})}
-- создает массив, элементы которого имеют определенный тип.
@var{type} может быть @code{fixnum} для целых чисел ограниченной
точности и @code{flonum} для чисел с плавающей точкой.

@code{array ([@var{name_1}, ..., @var{name_m}], @var{dim_1}, ..., @var{dim_n})}
-- создает  @math{m} массивов одинаковой размерности.
@c SAME TYPE AS WELL ??

@c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
Если пользователь присваивает значение переменной с индексом
до того, как соответствующий массив объявлен, тогда создается
необъявленный массив.  Необъявленные массивы, также известные как
хеш-массивы (т.к. для хранения элементов применяется
хеширование), являются более общими чем объявленные массивы.
Пользователь не определяет их максимальный размер, и они
растут динамически по мере присваивания значений их элементам.
Индексы необъявленных массивов даже не обязаны быть целочисленными.
Однако, за исключением случая когда массив сильно разряжен,
объявленный массив, обычно, более эффективен чем необъявленный.
Функция @code{array} может преобразовать необъявленный массив
в объявленный.
@c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??

@opencatbox
@category{Массивы}
@closecatbox

@end deffn

@deffn {Функция} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
Вычисляет значение @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
где  @var{A} -- массив, а @var{i_1}, ..., @var{i_n} целые числа.

Данная функция похожа на @code{apply}, только первый аргумент является
массивом а не функцией.

@opencatbox
@category{Выражения} @category{Массивы}
@closecatbox

@end deffn

@deffn {Функция} arrayinfo (@var{A})
Возвращает информацию о массиве @var{A}.
Аргумент @var{A} может быть объявленным массивом, необъявленным (хеш-) массивом,
функцией-массивом или функцией с индексом.

Для объявленного массива @code{arrayinfo} возвращает список состоящий из
атома @code{declared}, размерности массива и размера каждого из измерений.
Элементы массива, как имеющие значение, так и не имеющие значения,
возвращаются функцией @code{listarray}.

Для необъявленных массивов (хеш-массивов) @code{arrayinfo} 
возвращает список состоящий из атома @code{hashed}, числа индексов и 
индексов всех элементов, которые имеют значение.
Значения массива возвращаются функцией @code{listarray}.

Для функций-массивов
@code{arrayinfo} возвращает список состоящий из атома @code{hashed}, числа индексов и
индексов всех элементов, которые содержат функциональные значения.
Функциональные значения возвращаются функцией @code{listarray}.

Для функций с индексом
@code{arrayinfo} возвращает список состоящий из атома @code{hashed}, числа индексов и
индексов всех элементов, которые содержат лямбда-выражения.
Лямбда-выражения возвращаются функцией @code{listarray}.

Примеры:

@code{arrayinfo} и @code{listarray} примененные к объявленному массиву.

@c ===beg===
@c array (aa, 2, 3);
@c aa [2, 3] : %pi;
@c aa [1, 2] : %e;
@c arrayinfo (aa);
@c listarray (aa);
@c ===end===
@example
(%i1) array (aa, 2, 3);
(%o1)                          aa
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
(%i3) aa [1, 2] : %e;
(%o3)                          %e
(%i4) arrayinfo (aa);
(%o4)                 [declared, 2, [2, 3]]
(%i5) listarray (aa);
(%o5) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]
@end example

@code{arrayinfo} и @code{listarray} примененные к необъявленному (хеш) массиву.

@c ===beg===
@c bb [FOO] : (a + b)^2;
@c bb [BAR] : (c - d)^3;
@c arrayinfo (bb);
@c listarray (bb);
@c ===end===
@example
(%i1) bb [FOO] : (a + b)^2;
                                   2
(%o1)                       (b + a)
(%i2) bb [BAR] : (c - d)^3;
                                   3
(%o2)                       (c - d)
(%i3) arrayinfo (bb);
(%o3)               [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb);
                              3         2
(%o4)                 [(c - d) , (b + a) ]
@end example

@code{arrayinfo} и @code{listarray} примененные к функции-массиву.

@c ===beg===
@c cc [x, y] := y / x;
@c cc [u, v];
@c cc [4, z];
@c arrayinfo (cc);
@c listarray (cc);
@c ===end===
@example
(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
(%i4) arrayinfo (cc);
(%o4)              [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc);
                              z  v
(%o5)                        [-, -]
                              4  u
@end example

@code{arrayinfo} и @code{listarray} примененные к функции с индексом.

@c ===beg===
@c dd [x] (y) := y ^ x;
@c dd [a + b];
@c dd [v - u];
@c arrayinfo (dd);
@c listarray (dd);
@c ===end===
@example
(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
(%i4) arrayinfo (dd);
(%o4)             [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd);
                         b + a                v - u
(%o5)      [lambda([y], y     ), lambda([y], y     )]
@end example

@opencatbox
@category{Массивы}
@closecatbox

@end deffn

@deffn {Функция} arraymake (@var{A}, [@var{i_1}, ..., @var{i_n}])
Возвращает выражение @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
Этот результат является не вычисленной ссылкой на элемент
массива.

Функция @code{arraymake} похожа на @code{funmake},
за исключеним того, что возвращает не вычисленный элемент массива
вместо от не вычисленного вызова функции.

Примеры:
@c ===beg===
@c arraymake (A, [1]);
@c arraymake (A, [k]);
@c arraymake (A, [i, j, 3]);
@c array (A, fixnum, 10);
@c fillarray (A, makelist (i^2, i, 1, 11));
@c arraymake (A, [5]);
@c ''%;
@c L : [a, b, c, d, e];
@c arraymake ('L, [n]);
@c ''%, n = 3;
@c A2 : make_array (fixnum, 10);
@c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
@c arraymake ('A2, [8]);
@c ''%;
@c ===end===

@example
(%i1) arraymake (A, [1]);
(%o1)                          A
                                1
(%i2) arraymake (A, [k]);
(%o2)                          A
                                k
(%i3) arraymake (A, [i, j, 3]);
(%o3)                       A
                             i, j, 3
(%i4) array (A, fixnum, 10);
(%o4)                           A
(%i5) fillarray (A, makelist (i^2, i, 1, 11));
(%o5)                           A
(%i6) arraymake (A, [5]); 
(%o6)                          A
                                5
(%i7) ''%;
(%o7)                          36
(%i8) L : [a, b, c, d, e];
(%o8)                    [a, b, c, d, e]
(%i9) arraymake ('L, [n]);
(%o9)                          L
                                n
(%i10) ''%, n = 3;
(%o10)                          c
(%i11) A2 : make_array (fixnum, 10);
(%o11)          @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o12)          @{Array:  #(1 2 3 4 5 6 7 8 9 10)@}
(%i13) arraymake ('A2, [8]);
(%o13)                         A2
                                 8
(%i14) ''%;
(%o14)                          9
@end example

@opencatbox
@category{Выражения} @category{Массивы}
@closecatbox

@end deffn

@defvr {Системная переменная} arrays
Значение по умолчанию: @code{[]}

Список @code{arrays} содержит всех существующих массивов.
Что составляет: массивы, объявленные при помощи @code{array};
хеш-массивы, созданные при помощи неявных определение (присваиванием чего-либо элементу массива);
функции-массивы, определенные с помощью @code{:=} и @code{define}.
Массивы, созданные при помощи @code{make_array}, в список не включаются.

См. также
@code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake}, 
@code{fillarray}, @code{listarray}, and @code{rearray}.
@c IS THIS AN EXHAUSTIVE LIST ??

Примеры:

@c ===beg===
@c array (aa, 5, 7);
@c bb [FOO] : (a + b)^2;
@c cc [x] := x/100;
@c dd : make_array ('any, 7);
@c arrays;
@c ===end===
@example
(%i1) array (aa, 5, 7);
(%o1)                          aa
(%i2) bb [FOO] : (a + b)^2;
                                   2
(%o2)                       (b + a)
(%i3) cc [x] := x/100;
                                   x
(%o3)                      cc  := ---
                             x    100
(%i4) dd : make_array ('any, 7);
(%o4)       @{Array:  #(NIL NIL NIL NIL NIL NIL NIL)@}
(%i5) arrays;
(%o5)                     [aa, bb, cc]
@end example

@opencatbox
@category{Массивы} @category{Глобальные переменные} 
@closecatbox

@end defvr

@deffn {Функция} bashindices (@var{expr})
Преобразует выражение @var{expr} присваивая каждому суммированию или
произведению уникальный индекс.  Индекс имеет форму
@code{j@var{number}}.  Величина @var{number} определяется
значением переменной @code{gensumnum}, которое может быть установлено
пользователем.  Например @code{gensumnum:0$}, инициализирует
эту переменную.

@opencatbox
@category{Суммы и произведения} 
@closecatbox

@end deffn

@deffn {Функция} fillarray (@var{A}, @var{B})
Заполняет массив @var{A} элементами из @var{B}, являющимся
списком или массивом.

Если для массива @var{A} в момент создания был задан тип элементов,
то он может быть заполнен только элементами данного типа и
попытка заполнения элементами другого типа является ошибкой.

Если размерность массивов не совпадает, тогда @var{A}
заполняется построчно.  Если число элементов @var{B} недостаточно, то
последний элемент используется для заполнения остатка @var{A}.
Если число элементов @var{B} слишком велико, тогда излишние отбрасываются.

@code{fillarray} возвращает свой первый аргумент.

Примеры:

Создается массив из 9 элементов и заполняется из списка.
@c ===beg===
@c array (a1, fixnum, 8);
@c listarray (a1);
@c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
@c listarray (a1);
@c ===end===

@example
(%i1) array (a1, fixnum, 8);
(%o1)                          a1
(%i2) listarray (a1);
(%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
(%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
(%o3)                          a1
(%i4) listarray (a1);
(%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]
@end example

Если недостаточно элементов для заполнения массива,
то последний элемент повторяется.
Если элементов слишком много, то излишние элементы
игнорируются.
@c ===beg===
@c a2 : make_array (fixnum, 8);
@c fillarray (a2, [1, 2, 3, 4, 5]);
@c fillarray (a2, [4]);
@c fillarray (a2, makelist (i, i, 1, 100));
@c ===end===

@example
(%i1) a2 : make_array (fixnum, 8);
(%o1)             @{Array:  #(0 0 0 0 0 0 0 0)@}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]);
(%o2)             @{Array:  #(1 2 3 4 5 5 5 5)@}
(%i3) fillarray (a2, [4]);
(%o3)             @{Array:  #(4 4 4 4 4 4 4 4)@}
(%i4) fillarray (a2, makelist (i, i, 1, 100));
(%o4)             @{Array:  #(1 2 3 4 5 6 7 8)@}
@end example

Многомерные массивы заполняются построчно.
@c ===beg===
@c a3 : make_array (fixnum, 2, 5);
@c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
@c a4 : make_array (fixnum, 5, 2);
@c fillarray (a4, a3);
@c ===end===

@example
(%i1) a3 : make_array (fixnum, 2, 5);
(%o1)        @{Array:  #2A((0 0 0 0 0) (0 0 0 0 0))@}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
(%o2)        @{Array:  #2A((1 2 3 4 5) (6 7 8 9 10))@}
(%i3) a4 : make_array (fixnum, 5, 2);
(%o3)     @{Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
(%i4) fillarray (a4, a3);
(%o4)     @{Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
@end example

@opencatbox
@category{Массивы} 
@closecatbox

@end deffn

@deffn {Функция} listarray (@var{A})
Возвращает список элементов массива @var{A}.
Аргумент @var{A} должен быть объявленным массивом, необъявленным (хеш) массивом,
функцией-массивом или функцией с индексами.

Элементы помещаются в список построчно.
Т.е. сначала помещаются элементы по первому индексу, затем по второму и т.д.
Порядок значений индексов тот же, что установлен при помощи @code{orderless}.

Для необъявленных массивов, функций-массивов и функций с индексом,
возвращаются элементы соответствующие индексам возвращаемым
функцией @code{arrayinfo}.

Для объявленных массивов общего типа (т.е не @code{fixnum} или @code{flonum}) элементы не имеющие значения
возвращаются как @code{#####}.
Не присвоенные элементы объявленных @code{fixnum} или @code{flonum} массивов
возвращаются как 0 или 0.0 соответственно.
Не присвоенные элементы необъявленных массивов, функций-массивов
и функций с индексом не возвращаются.

Примеры:

@code{listarray} и @code{arrayinfo} примененные к объявленному массиву.

@c ===beg===
@c array (aa, 2, 3);
@c aa [2, 3] : %pi;
@c aa [1, 2] : %e;
@c listarray (aa);
@c arrayinfo (aa);
@c ===end===
@example
(%i1) array (aa, 2, 3);
(%o1)                          aa
(%i2) aa [2, 3] : %pi;
(%o2)                          %pi
(%i3) aa [1, 2] : %e;
(%o3)                          %e
(%i4) listarray (aa);
(%o4) [#####, #####, #####, #####, #####, #####, %e, #####, 
                                        #####, #####, #####, %pi]
(%i5) arrayinfo (aa);
(%o5)                 [declared, 2, [2, 3]]
@end example

@code{arrayinfo} и @code{listarray} примененные к необъявленному (хеш) массиву.

@c ===beg===
@c bb [FOO] : (a + b)^2;
@c bb [BAR] : (c - d)^3;
@c listarray (bb);
@c arrayinfo (bb);
@c ===end===
@example
(%i1) bb [FOO] : (a + b)^2;
                                   2
(%o1)                       (b + a)
(%i2) bb [BAR] : (c - d)^3;
                                   3
(%o2)                       (c - d)
(%i3) listarray (bb);
                              3         2
(%o3)                 [(c - d) , (b + a) ]
(%i4) arrayinfo (bb);
(%o4)               [hashed, 1, [BAR], [FOO]]
@end example

@code{arrayinfo} и @code{listarray} примененные к функции-массиву.

@c ===beg===
@c cc [x, y] := y / x;
@c cc [u, v];
@c cc [4, z];
@c listarray (cc);
@c arrayinfo (cc);
@c ===end===
@example
(%i1) cc [x, y] := y / x;
                                     y
(%o1)                      cc     := -
                             x, y    x
(%i2) cc [u, v];
                                v
(%o2)                           -
                                u
(%i3) cc [4, z];
                                z
(%o3)                           -
                                4
(%i4) listarray (cc);
                              z  v
(%o4)                        [-, -]
                              4  u
(%i5) arrayinfo (cc);
(%o5)              [hashed, 2, [4, z], [u, v]]
@end example

@code{arrayinfo} и @code{listarray} примененные к функции с индексом.

@c ===beg===
@c dd [x] (y) := y ^ x;
@c dd [a + b];
@c dd [v - u];
@c listarray (dd);
@c arrayinfo (dd);
@c ===end===
@example
(%i1) dd [x] (y) := y ^ x;
                                     x
(%o1)                     dd (y) := y
                            x
(%i2) dd [a + b];
                                    b + a
(%o2)                  lambda([y], y     )
(%i3) dd [v - u];
                                    v - u
(%o3)                  lambda([y], y     )
(%i4) listarray (dd);
                         b + a                v - u
(%o4)      [lambda([y], y     ), lambda([y], y     )]
(%i5) arrayinfo (dd);
(%o5)             [hashed, 1, [b + a], [v - u]]
@end example

@opencatbox
@category{Массивы} 
@closecatbox

@end deffn

@c NEEDS CLARIFICATION
@deffn {Функция} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
Создает и возвращает Lisp-массив.  @var{type} может быть
@code{any}, @code{flonum}, @code{fixnum}, @code{hashed} или
@code{functional}.

Массив имеет @math{n} индексов, @math{i}-й индекс может принимать
значение от 0 до @math{@var{dim_i}-1}.

Преимущество @code{make_array} по сравнению с @code{array} состоит в
том, что возвращаемый Lisp-массив не имеет имени.  И как только ссылка
на него исчезает, занимаемое им место освобождается.
Например, если @code{y: make_array (...)}, тогда @code{y} ссылается
на объект (массив), занимающий место в памяти.
Но после присваивания @code{y: false}, @code{y} больше не ссылается
на данный массив и занимаемое им место будет освобождено
при сборке мусора.

@c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
@c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
@c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
@c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
@c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
@c @code{make_array} in this case is the function to call to calculate array
@c elements, and the rest of the arguments are passed recursively to
@c @code{make_array} to generate the "memory" for the array function object.

Примеры:
@c ===beg===
@c A1 : make_array (fixnum, 10);
@c A1 [8] : 1729;
@c A1;
@c A2 : make_array (flonum, 10);
@c A2 [2] : 2.718281828;
@c A2;
@c A3 : make_array (any, 10);
@c A3 [4] : x - y - z;
@c A3;
@c A4 : make_array (fixnum, 2, 3, 5);
@c fillarray (A4, makelist (i, i, 1, 2*3*5));
@c A4 [0, 2, 1];
@c ===end===

@example
(%i1) A1 : make_array (fixnum, 10);
(%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
(%i2) A1 [8] : 1729;
(%o2)                         1729
(%i3) A1;
(%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
(%i4) A2 : make_array (flonum, 10);
(%o4) @{Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
(%i5) A2 [2] : 2.718281828;
(%o5)                      2.718281828
(%i6) A2;
(%o6) 
     @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
(%i7) A3 : make_array (any, 10);
(%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
(%i8) A3 [4] : x - y - z;
(%o8)                      - z - y + x
(%i9) A3;
(%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 -1 $Y) ((MTIMES SIMP) -1 $Z))
  NIL NIL NIL NIL NIL)@}
(%i10) A4 : make_array (fixnum, 2, 3, 5);
(%o10) @{Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
(%o11) @{Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
    ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
(%i12) A4 [0, 2, 1];
(%o12)                         12
@end example

@opencatbox
@category{Массивы} 
@closecatbox

@end deffn

@c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
@deffn {Функция} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
Изменяет размерность массива.  Новый массив будет заполнен элементами
старого построчно.  Если исходный массив слишком мал, тогда
остаток заполняется @code{false}, @code{0.0} или @code{0},
в зависимости от типа массива.  Тип массива не может быть изменен.

@opencatbox
@category{Массивы} 
@closecatbox

@end deffn

@deffn {Функция} remarray (@var{A_1}, ..., @var{A_n})
@deffnx {Функция} remarray (all)
Удаляет массив, все ассоциированные с ним функции и
освобождает занимаемую им память.
Аргументы должны быть: объявленными массивами, необъявленными (хеш)
массивами, функциями-массивами или функциями с индексом.

@code{remarray (all)} удаляет все элементы в глобальном списке @code{arrays}.

@c WHAT DOES THIS MEAN EXACTLY ??
Использование @code{remarray} может требоваться если
необходимо переопределить значения элементов
необъявленного (хеш) массива.

@code{remarray} возвращает список удаленных массивов.

@opencatbox
@category{Массивы} 
@closecatbox

@end deffn

@deffn {Функция} subvar (@var{x}, @var{i})
Вычисляет выражение с индексом @code{@var{x}[@var{i}]}.

@code{subvar} вычисляет свои аргументы.

@code{arraymake (@var{x}, [@var{i}]} составляет выражение @code{@var{x}[@var{i}]},
но не вычисляет его.

Примеры:

@c ===beg===
@c x : foo $
@c i : 3 $
@c subvar (x, i);
@c foo : [aa, bb, cc, dd, ee]$
@c subvar (x, i);
@c arraymake (x, [i]);
@c ''%;
@c ===end===
@example
(%i1) x : foo $

(%i2) i : 3 $

(%i3) subvar (x, i);
(%o3)                         foo
                                 3
(%i4) foo : [aa, bb, cc, dd, ee]$

(%i5) subvar (x, i);
(%o5)                          cc
(%i6) arraymake (x, [i]);
(%o6)                         foo
                                 3
(%i7) ''%;
(%o7)                          cc
@end example

@opencatbox
@category{Выражения} @category{Массивы} 
@closecatbox

@end deffn

@c THIS IS REALLY CONFUSING
@defvr {Управляющая переменная} use_fast_arrays
-- если @code{true}, тогда используются только два типа массивов.

1) Art-q массивы (t в Common Lisp), которые имеют несколько
целочисленных индексов, и могут содержать любые Lisp или Maxima
объекты.  Для создания таких массивов используется функция
@code{make_array}.  Например @code{a:make_array(any,3,4);}.
Значение @code{a} -- массив из 12 элементов. Отсчет индексов
ведется с 0.

2) Hash_table массивы, создающиеся по умолчанию если выполняется
присваивания @code{b[x+1]:y^2} если @code{b} еще пока не является
массивом, списком или матрицей (во всех этих случаях должна возникнуть
ошибка т.к. @code{x+1} в общем случае не является допустимым индексом
для art-q массива, списка или матрицы).  Индексом такого массива
(также называется ключем) может быть произвольный объект.
Используется только один ключ одновременно, так в @code{b[x+1,u]:y}
игнорирует @code{u} а соответствие устанавливается по
@code{b[x+1] ==> y^2}.  Разумеется ключ может быть списком, например
@code{b[[x+1,u]]:y} вполне допустимо.  Это не совместимо со старыми
хешируемыми массивами, но экономит память.

Преимущество хранения массивов в значении переменной состоит в том,
что в этом случае массивы следуют обычным соглашениям о локальных
переменных.  Кроме того Hash_table массивы более эффективны и
используют меньше памяти, чем старые хешируемые массивы.  Для
одинакового поведения в интерпретируемом и компилируемом коде
необходимо установить значение @code{translate_fast_arrays} равным
@code{true}.

@opencatbox
@category{Массивы} @category{Глобальные флаги} 
@closecatbox

@end defvr

