Maxima Manual: Функции и переменные для работы с массивами

Previous: Массивы, Up: Массивы [Contents][Index]

### 22.1 Функции и переменные для работы с массивами

Функция: array (name, dim_1, ..., dim_n)
Функция: array (name, type, dim_1, ..., dim_n)
Функция: array ([name_1, ..., name_m], dim_1, ..., dim_n)

  Создает 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` может преобразовать необъявленный массив в объявленный.

Функция: arrayapply (A, [i_1, ..., i_n])

  Вычисляет значение `A [i_1, ..., i_n]`, где A – массив, а i_1, ..., i_n целые числа.

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

Функция: arrayinfo (A)

  Возвращает информацию о массиве 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     )]

Функция: arraymake (A, [i_1, ..., i_n])

  Возвращает выражение `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

  Значение по умолчанию: `[]`

  Список `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]

Функция: bashindices (expr)

  Преобразует выражение expr присваивая каждому суммированию или произведению уникальный индекс. Индекс имеет форму `jnumber`. Величина number определяется значением переменной `gensumnum`, которое может быть установлено пользователем. Например `gensumnum:0$`, инициализирует эту переменную.

Функция: fillarray (A, B)

  Заполняет массив 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))}

Функция: listarray (A)

  Возвращает список элементов массива 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]]

Функция: make_array (type, dim_1, ..., dim_n)

  Создает и возвращает 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

Функция: rearray (A, dim_1, ..., dim_n)

  Изменяет размерность массива. Новый массив будет заполнен элементами старого построчно. Если исходный массив слишком мал, тогда остаток заполняется `false`, `0.0` или `0`, в зависимости от типа массива. Тип массива не может быть изменен.

Функция: remarray (A_1, ..., A_n)
Функция: remarray (all)

  Удаляет массив, все ассоциированные с ним функции и освобождает занимаемую им память. Аргументы должны быть: объявленными массивами, необъявленными (хеш) массивами, функциями-массивами или функциями с индексом.

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

  Использование `remarray` может требоваться если необходимо переопределить значения элементов необъявленного (хеш) массива.

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

Функция: subvar (x, i)

  Вычисляет выражение с индексом `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

Управляющая переменная: use_fast_arrays

  – если `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`.

Previous: Массивы, Up: Массивы [Contents][Index]