Создает n-мерный массив. Значение n должно быть меньше или равно 5. i-й индекс может принимать целочисленное значение от 0 до dim_i.
array (name, dim_1, ..., dim_n) – создает
массив общего вида.
array (name, type, dim_1, ..., dim_n)
– создает массив, элементы которого имеют определенный тип.
type может быть fixnum для целых чисел ограниченной
точности и flonum для чисел с плавающей точкой.
array ([name_1, ..., name_m], dim_1, ..., dim_n)
– создает m массивов одинаковой размерности.
Если пользователь присваивает значение переменной с индексом
до того, как соответствующий массив объявлен, тогда создается
необъявленный массив. Необъявленные массивы, также известные как
хеш-массивы (т.к. для хранения элементов применяется
хеширование), являются более общими чем объявленные массивы.
Пользователь не определяет их максимальный размер, и они
растут динамически по мере присваивания значений их элементам.
Индексы необъявленных массивов даже не обязаны быть целочисленными.
Однако, за исключением случая когда массив сильно разряжен,
объявленный массив, обычно, более эффективен чем необъявленный.
Функция array может преобразовать необъявленный массив
в объявленный.
Вычисляет значение A [i_1, ..., i_n],
где A – массив, а i_1, ..., i_n целые числа.
Данная функция похожа на apply, только первый аргумент является
массивом а не функцией.
Возвращает информацию о массиве A. Аргумент A может быть объявленным массивом, необъявленным (хеш-) массивом, функцией-массивом или функцией с индексом.
Для объявленного массива arrayinfo возвращает список состоящий из
атома declared, размерности массива и размера каждого из измерений.
Элементы массива, как имеющие значение, так и не имеющие значения,
возвращаются функцией listarray.
Для необъявленных массивов (хеш-массивов) arrayinfo
возвращает список состоящий из атома hashed, числа индексов и
индексов всех элементов, которые имеют значение.
Значения массива возвращаются функцией listarray.
Для функций-массивов
arrayinfo возвращает список состоящий из атома hashed, числа индексов и
индексов всех элементов, которые содержат функциональные значения.
Функциональные значения возвращаются функцией listarray.
Для функций с индексом
arrayinfo возвращает список состоящий из атома hashed, числа индексов и
индексов всех элементов, которые содержат лямбда-выражения.
Лямбда-выражения возвращаются функцией listarray.
Примеры:
arrayinfo и listarray примененные к объявленному массиву.
(%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]
arrayinfo и listarray примененные к необъявленному (хеш) массиву.
(%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) ]
arrayinfo и listarray примененные к функции-массиву.
(%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
arrayinfo и listarray примененные к функции с индексом.
(%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 )]
Возвращает выражение A[i_1, ..., i_n].
Этот результат является не вычисленной ссылкой на элемент
массива.
Функция arraymake похожа на funmake,
за исключеним того, что возвращает не вычисленный элемент массива
вместо от не вычисленного вызова функции.
Примеры:
(%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
Значение по умолчанию: []
Список arrays содержит всех существующих массивов.
Что составляет: массивы, объявленные при помощи array;
хеш-массивы, созданные при помощи неявных определение (присваиванием чего-либо элементу массива);
функции-массивы, определенные с помощью := и define.
Массивы, созданные при помощи make_array, в список не включаются.
См. также
array, arrayapply, arrayinfo, arraymake,
fillarray, listarray, and rearray.
Примеры:
(%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]
Преобразует выражение expr присваивая каждому суммированию или
произведению уникальный индекс. Индекс имеет форму
jnumber. Величина number определяется
значением переменной gensumnum, которое может быть установлено
пользователем. Например gensumnum:0$, инициализирует
эту переменную.
Заполняет массив A элементами из B, являющимся списком или массивом.
Если для массива A в момент создания был задан тип элементов, то он может быть заполнен только элементами данного типа и попытка заполнения элементами другого типа является ошибкой.
Если размерность массивов не совпадает, тогда A заполняется построчно. Если число элементов B недостаточно, то последний элемент используется для заполнения остатка A. Если число элементов B слишком велико, тогда излишние отбрасываются.
fillarray возвращает свой первый аргумент.
Примеры:
Создается массив из 9 элементов и заполняется из списка.
(%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]
Если недостаточно элементов для заполнения массива, то последний элемент повторяется. Если элементов слишком много, то излишние элементы игнорируются.
(%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)}
Многомерные массивы заполняются построчно.
(%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))}
Возвращает список элементов массива A. Аргумент A должен быть объявленным массивом, необъявленным (хеш) массивом, функцией-массивом или функцией с индексами.
Элементы помещаются в список построчно.
Т.е. сначала помещаются элементы по первому индексу, затем по второму и т.д.
Порядок значений индексов тот же, что установлен при помощи orderless.
Для необъявленных массивов, функций-массивов и функций с индексом,
возвращаются элементы соответствующие индексам возвращаемым
функцией arrayinfo.
Для объявленных массивов общего типа (т.е не fixnum или flonum) элементы не имеющие значения
возвращаются как #####.
Не присвоенные элементы объявленных fixnum или flonum массивов
возвращаются как 0 или 0.0 соответственно.
Не присвоенные элементы необъявленных массивов, функций-массивов
и функций с индексом не возвращаются.
Примеры:
listarray и arrayinfo примененные к объявленному массиву.
(%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]]
arrayinfo и listarray примененные к необъявленному (хеш) массиву.
(%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]]
arrayinfo и listarray примененные к функции-массиву.
(%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]]
arrayinfo и listarray примененные к функции с индексом.
(%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]]
Создает и возвращает Lisp-массив. type может быть
any, flonum, fixnum, hashed или
functional.
Массив имеет n индексов, i-й индекс может принимать значение от 0 до dim_i-1.
Преимущество make_array по сравнению с array состоит в
том, что возвращаемый Lisp-массив не имеет имени. И как только ссылка
на него исчезает, занимаемое им место освобождается.
Например, если y: make_array (...), тогда y ссылается
на объект (массив), занимающий место в памяти.
Но после присваивания y: false, y больше не ссылается
на данный массив и занимаемое им место будет освобождено
при сборке мусора.
Примеры:
(%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
Изменяет размерность массива. Новый массив будет заполнен элементами
старого построчно. Если исходный массив слишком мал, тогда
остаток заполняется false, 0.0 или 0,
в зависимости от типа массива. Тип массива не может быть изменен.
Удаляет массив, все ассоциированные с ним функции и освобождает занимаемую им память. Аргументы должны быть: объявленными массивами, необъявленными (хеш) массивами, функциями-массивами или функциями с индексом.
remarray (all) удаляет все элементы в глобальном списке arrays.
Использование remarray может требоваться если
необходимо переопределить значения элементов
необъявленного (хеш) массива.
remarray возвращает список удаленных массивов.
Вычисляет выражение с индексом x[i].
subvar вычисляет свои аргументы.
arraymake (x, [i] составляет выражение x[i],
но не вычисляет его.
Примеры:
(%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
– если true, тогда используются только два типа массивов.
1) Art-q массивы (t в Common Lisp), которые имеют несколько
целочисленных индексов, и могут содержать любые Lisp или Maxima
объекты. Для создания таких массивов используется функция
make_array. Например a:make_array(any,3,4);.
Значение a – массив из 12 элементов. Отсчет индексов
ведется с 0.
2) Hash_table массивы, создающиеся по умолчанию если выполняется
присваивания b[x+1]:y^2 если b еще пока не является
массивом, списком или матрицей (во всех этих случаях должна возникнуть
ошибка т.к. x+1 в общем случае не является допустимым индексом
для art-q массива, списка или матрицы). Индексом такого массива
(также называется ключем) может быть произвольный объект.
Используется только один ключ одновременно, так в b[x+1,u]:y
игнорирует u а соответствие устанавливается по
b[x+1] ==> y^2. Разумеется ключ может быть списком, например
b[[x+1,u]]:y вполне допустимо. Это не совместимо со старыми
хешируемыми массивами, но экономит память.
Преимущество хранения массивов в значении переменной состоит в том,
что в этом случае массивы следуют обычным соглашениям о локальных
переменных. Кроме того Hash_table массивы более эффективны и
используют меньше памяти, чем старые хешируемые массивы. Для
одинакового поведения в интерпретируемом и компилируемом коде
необходимо установить значение translate_fast_arrays равным
true.