 
Основные принципы задания констант и действий
над ними видны из следующих примеров:
Пример 1:
gap> 12345/25;
2469/5
gap> -3; 17 - 23;
-3
-6
gap> 3^132;
9550049507968252368931907017744140119199351389743
43129836853841
Пример 2 (операции с подстановками):
gap> (1,2,3);
(1,2,3)
gap> (1,2,3) * (1,2);
(2,3)
gap> (1,2,3)^-1;
(1,3,2)
gap> 2^(1,2,3);
3
gap> (1,2,3)^(1,2);
(1,3,2)
Пример 3 (задание строки):
gap> 'a';
'a'
Порядок присваивания демонстрируется
следующим примером:
Пример 1:
gap> a:= (9 - 7) * (5 + 6);
22
gap> a;
22
gap> a:= 10;
10
gap> a * (a + 1);
110
Примечание 1. После присваивания
присвоенное значение отображается в следующей
строке вывода. Это можно подавить, если завершить
команду двумя знаками «;» вместо одного:
gap> w:= 2;;
Примечание 2. Всякий раз, когда GAP
возвращает значение, печатая его в следующей
после команды строке, это значение присваивается
переменной с именем last :
gap> (9 - 7) * (5 + 6);
22
gap> a:= last;
22
Аналогичным образом определяются переменные
last2 и last3.
GAPсодержит более 4000 стандартных функций. Пример
обращения к нескольким из них приведен ниже:
Пример 1:
gap> Factorial(17);
355687428096000
gap> Gcd(1234, 5678);
2
gap> Print(1234, "\n");
1234
Кроме того, пользователь может вводить
собственные функции. Наиболее просто это
делается так:
Пример 2:
gap> cubed:= x -> x^3;
function ( x ) ... end
gap> cubed(5);
125
Другой способ определения функций и процедур
изложен в пп. 2.14 и 3.12.
Порядок разработки программ на языке GAPописан в
разделе 5.
Список является заключенным в квадратные
скобки набором объектов, разделенных запятыми.
Например, список из первых десяти простых чисел
можно задать следующим образом:
gap> primes:=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29];
[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]
Затем к нему можно добавить следующие два
простых числа:
gap> Append(primes, [31, 37]);
gap> primes;
[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 ]
Если добавляется только один элемент, это можно
сделать и по-другому:
gap> Add(primes, 41);
gap> primes;
[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41 ]
Указать отдельный элемент списка можно по его
номеру в списке:
gap> primes[7];
17
Этот же механизм позволяет присвоить значение
существующему или новому элементу списка
(функция Length определяет длину списка):
gap> Length(primes);
13
gap> primes[14]:= 43;
43
gap> primes;
[ 2, 3, 5, 7,11,13,17,19,23,29,31,37,41,43 ]
При этом значение не обязательно должно
присваиваться следующему элементу списка.
Например, если двадцатым простым числом является
71, мы можем сразу присвоить значение 71 двадцатому
элементу списка primes, пропуская недостающие
элементы. Полученный список будет иметь длину 20:
gap> primes[20]:= 71;
71
gap> primes;
[ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,,,,,, 71 ]
gap> Length(primes);
20
Список должен быть создан перед заданием его
элемента (например, быть пустым списком [ ]):
gap> lll[1]:= 2;
Error, Variable: 'lll' must have a value
gap> lll:= [];;
gap> lll[1]:= 2;
2
Функция Positionвозвращает номер первого элемента
списка, имеющего заданное значение. Если в списке
нет элемента с заданным значением, функция
возвращает false:
gap> Position(primes, 17);
7
gap> Position(primes, 20);
false
Заметим, что при всех приведенных выше
изменениях списка primes длина списка изменялась
автоматически.
Функция IsBound для списков показывает, содержит
ли список элемент с заданным номером (для
записей— содержит ли запись указанное поле):
gap> k:= [ , 2, 3, , 5, , 7, ,
, , 11 ];;
gap> IsBound(k[7]); IsBound(k[4]); IsBound(k[20]);
true
false
false
Список может состоять из объектов различных
типов, например:
gap> lll:= [true, "This is a String",,, 3];
[ true, "This is a String",,, 3 ]
Далее, список может являться частью другого
списка или самого себя:
gap> lll[3]:= [4,5,6];; lll;
[ true, "This is a String", [ 4, 5, 6 ],, 3 ]
gap> lll[4]:= lll;
[ true, "This is a String", [ 4, 5, 6 ], ~, 3 ]
Здесь знак « ~ » в четвертой позиции обозначает
объект, вывод которого на экран (печать)
производится в данный момент.
Строки являются частным случаем списков, и
печатаются без разделителей. Примеры задания
строк и операций над ними:
gap>s1:=['H','a','l','l','o','','w','o','r','l','d','.'];
"Hallo world."
> gap> s2 := "Hallo world.";
"Hallo world."
gap> s1 = s2;
true
gap> s2[7];
'w'
Извлечение и изменение подмножеств списка
производит оператор { }:
gap> sl := lll{ [ 1, 2, 3 ] };
[ true, "This is a String", [ 4, 5, 6 ] ]
gap> sl{ [ 2, 3 ] } := [ "New String", false ];
[ "New String", false ]
gap> sl;
[ true, "New String", false ]
Для изучения способов управления сложными
структурами данных в GAP важно понимать различия
между тождественными и равными объектами. В
данном разделе это различие демонстрируется на
примере списков. Аналогичные примеры могут быть
подобраны и для записей.
Два списка равны (т.е. оператор сравнения =
возвращает true) тогда и только тогда, когда они
имеют одинаковую длину и их соответствующие
элементы равны.
:
gap> numbers:= primes;
[ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,,,,,,71 ]
gap> numbers = primes;
true
Теперь изменим список numbers и снова сравним его с
primes.
gap> primes[3]:= 4;
4
gap> numbers = primes;
true
Оказывается, что списки numbers и primes снова равны, а
распечатав список primes, мы увидим, что primes[3]:=4. Это
объясняется тем, что списки primes иnumbers не только
равны, но и идентичны. Идентификаторы primesи numbers
указывают на один и тот же список, и изменения в
нем происходят при указании любого из его имен.
Присваивание numbers:= primes создает не новый список, а
только товое имя для уже существующего списка.
Если необходимо изменить список, совпадающий
по содержанию с prime s, таким образом, чтобы сам
список primes при этом не изменился, необходимо
создать копию списка primes с помощью функции Copy (в
следующем примере предварительно восстановим
старое значения primes.)
gap> primes[3]:= 5;
5
gap> primes;
[ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,,,,,,71 ]
gap> numbers:= Copy(primes);
[ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,,,,,,71 ]
gap> numbers = primes;
true
gap> numbers[3]:= 4;
4
gap> numbers = primes;
false
Примечание. Единственными объектами,
которые могут быть изменены таким способом,
являются списки и записи, т.к. только эти объекты
в GAP могут состоять из других объектов. Например,
после выполнения следующих команд значения i и j
будут соответственно равны 2 и 1:
gap> i:= 1;; j:= i;; i:= i+1;;
Упражнение. >Объяснить, что происходит
в результате выполнения команд:
gap> l:= [];
> [ ]
gap> l:= [l];
[ [ ] ]
gap> l[1]:= l;
[ ~ ]
Множествами в GAP называются списки
специального вида. Элементы множества
расположены последовательно (т.е. не содржат
пробелов, как, например, список [2,3,5,,,,,,,,31,37,41]),
упорядочены (порядок сортировки GAP определяет
самостоятельно) и встречаются в списке только
один раз. Множества, как и списки, могут содержать
объекты различных типов. Проверить, является ли
объект множеством, можно с помощью функции IsSet.
Для каждого списка существует соответствующее
ему множество, получаемое с помощью функции Set.
Пример:
gap> fruits:=["apple", "strawberry",
"cherry",
>
"plum",
"apple"];;
gap> IsSet(fruits);
false
gap> fruits:= Set(fruits);
[ "apple", "cherry", "plum",
"strawberry" ]
Заметим, что при этом исходный список fruits был
изменен.
Для проверки принадлежности объекта множеству
используется оператор in. Его также можно
использовать для проверки принадлежности к
списку, однако в первом случае проверка
выполняется быстрее, т.к. сортировка позволяет
использовать двоичный поиск вместо
последовательного перебора.
gap> "apple" in fruits;
true
gap> "banana" in fruits;
false
Добавить к множеству новый элемент можно с
помощью функции AddSet (обратите внимание на
порядок следования элементов):
gap> AddSet(fruits, "banana");
gap> fruits;
["apple", "banana", "cherry",
"plum", "strawberry"]
gap> AddSet(fruits, "apple");
gap> fruits; # 'fruits'
не изменилось
["apple", "banana", "cherry",
"plum", "strawberry"]
Пересечение, объединение и разность множеств
определяются с помощью функций Intersection, Union и
Difference. При этом аргументы могут быть обычными
списками, тогда как результат всегда будет
являться множеством.
Пример:
gap> breakfast:= ["tea",
"apple", "egg"];
[ "tea", "apple", "egg" ]
gap> Intersection(breakfast, fruits);
[ "apple" ]
gap> Difference(breakfast,fruits);
[ "egg ", "tea" ]
Те же операции над множествами производят
функции IntersectSet, UniteSet и RemoveSet, но они не возвращают
результат, а заменяют им первый аргумент.
Вектор является списком элементов,
принадлежащих общему полю, не содержащим
пробелов.
gap> v:= [3, 6, 2, 5/2];
[ 3, 6, 2, 5/2 ]
gap> IsVector(v);
true
Векторы умножаются на скаляры из любого поля,
содержащего данное. Умножение двух векторов
равной длины дает их скалярное произведение.
gap> 2 * v;
[ 6, 12, 4, 5 ]
gap> v * 1/3; # это эквивалентно команде
v/3;
[ 1, 2, 2/3, 5/6 ]
gap> v * v;
221/4 # скалярное произведение v на
себя
Матрица —список векторов одинаковой длины, не
содержащий пробелов:
gap> m:= [[1, -1, 1],
> [2, 0, -1],
> [1, 1, 1]];
[ [ 1, -1, 1 ], [ 2, 0, -1 ], [ 1, 1, 1 ] ]
gap> m[2][1];
2
Матрицы можно умножать на скаляры, векторы и
другие матрицы (при соответствии размеров):
gap> m:= [[1, 2, 3, 4],
> [5, 6, 7, 8],
> [9,10,11,12]];
[ [1,2,3,4 ], [5,6,7,8], [9,10,11,12] ]
gap> PrintArray(m);
[ [ 1, 2, 3, 4 ],
[ 5, 6, 7,
8 ],
[ 9, 10, 11, 12 ] ]
gap> [1, 0, 0, 0] * m;
Error, Vector *: vectors must have the same length
gap> [1, 0, 0] * m;
[ 1, 2, 3, 4 ]
gap> m * [1, 0, 0];
Error, Vector *: vectors must have the same length
gap> m * [1, 0, 0, 0];
[ 1, 5, 9 ]
gap> m * [0, 1, 0, 0];
[ 2, 6, 10 ]
Заметим, что умножение вектора на матрицу
приводит к линейной комбинации строк матрицы,
тогда как умножение матрицы на вектор приводит к
линейной комбинации ее столбцов. В последнем
случае вектор рассматривается как
вектор-столбец.
Подматрицы извлекаются или изменяются с
помощью фигурных скобок:
gap> sm := m{ [ 1, 2 ] }{ [ 3, 4 ] };
[ [ 3, 4 ], [ 7, 8 ] ]
gap> sm{ [ 1, 2 ] }{ [2] } := [[1],[-1]]
[ [ 1 ], [ -1 ] ]
gap> sm;
[ [ 3, 1 ], [ 7, -1 ] ]
Первая пара скобок указывает выбранные строки,
вторая - столбцы.
 |
