Программирование#

Загрузка и прикрепление файлов Sage#

Следующее показывает, как подгружать программы в Sage, записанные в отдельный файл. Создайте файл example.sage со следующим содержанием:

print("Hello World")
print(2^3)

Вы можете прочитать и выполнить example.sage с помощью команды load.

Sage

sage: load("example.sage")
Hello World
8

Python

>>> from sage.all import *
>>> load("example.sage")
Hello World
8

Вы также можете прикрепить файл Sage к запущенной сессии в помощью команды attach:

Sage

sage: attach("example.sage")
Hello World
8

Python

>>> from sage.all import *
>>> attach("example.sage")
Hello World
8

Теперь если вы измените файл example.sage и введете пустую строку в Sage (т.е. нажмите return), то содержимое example.sage будет автоматически перегружено в Sage.

В частности, attach автоматически перегружает файл, как только он изменен, что очень удобно при поиске ошибок в коде, тогда как load загружает файл лишь единожды.

Когда example.sage загружается в Sage, он переводится в Python, а затем выполняется с помощью интерпретатора Python. Затраты на данную операцию минимальны; в основном, это включает в себя перевод целых констант в Integer(), дробных констант в RealNumber(), замену ^ на ** и, например, R.2 на R.gen(2). Переведенная версия example.sage будет содержаться в той же директории, что example.sage, под названием example.sage.py. Данный файл будет содержать следующий код:

print("Hello World")
print(Integer(2)**Integer(3))

Целые контстанты переведены и ^ заменено на **. (В Python ^ означает «исключающее ИЛИ» и ** означает «возведение в степень».)

Данные операции выполняются в sage/misc/interpreter.py.)

Вы имеете возможность вставлять многострочный код с отступами в Sage до тех пор, пока есть новые строки для новых блоков (это необязательно для файлов). Однако, лучшим способом для вставки такого кода является сохранение в файл и использование attach, как описано выше.

Создание компилированного кода#

Скорость — важная составляющая в математических вычислениях. Хотя Python является высокоуровневым языком программирования, некоторые вычисления могут быть выполнены на несколько порядков быстрее в Python при использовании статических типов данных при компилировании. Некоторые компоненты Sage были бы слишком медленными, будь он написан целиком на Python. Для этого Sage поддерживает компилированную «версию» Python, которая называется Cython ([Cyt] и [Pyr]). Cython одновременно похож и на Python, и на C. Большинство конструкций Python, включая представление списков, условные выражения, код наподобие +=, разрешены; вы также можете импортировать код, написанный в других модулях Python. Кроме того, вы можете объявлять произвольные переменные C и напрямую обращаться к библиотекам C. Конечный код будет сконвертирован в C и обработан компилятором C.

Для того, чтобы создать компилируемый код в Sage, объявите файл с расширением .spyx (вместо .sage). Если вы работаете с интерфейсом коммандной строки, вы можете прикреплять и загружать компилируемый код точно так же, как и интерпретируемый (на данный момент, прикрепление и загрузка кода на Cython не поддерживается в интерфейсе Notebook). Само компилирование происходит «за кулисами», не требуя каких-либо действий с вашей стороны. Компилированная библиотека общих объектов содержится в $HOME/.sage/temp/hostname/pid/spyx. Эти файлы будут удалены при выходе из Sage.

Пре-парсировка не применяется к spyx файлам. Например 1/3 превратится в 0 в spyx файле вместо рационального числа $1/3$. Допустим, foo - это функция в библиотеке Sage. Для того, чтобы использовать ее из spyx-файла, импортируйте sage.all и примените sage.all.foo.

import sage.all
def foo(n):
    return sage.all.factorial(n)

Доступ к функциям С из внешних файлов#

Доступ к функциям C из внешних *.c файлов осуществляется довольно просто. Создайте файлы test.c и test.spyx в одной директории со следующим содержанием:

Код на языке С: test.c

int add_one(int n) {
  return n + 1;
}

Код на языке Cython: test.spyx:

cdef extern from "test.c":
    int add_one(int n)

def test(n):
    return add_one(n)

Выполните:

Sage

sage: attach("test.spyx")
Compiling (...)/test.spyx...
sage: test(10)
11

Python

>>> from sage.all import *
>>> attach("test.spyx")
Compiling (...)/test.spyx...
>>> test(Integer(10))
11

В том случае, если понадобится дополнительная библиотека foo для того, чтобы скомпилировать код на C, полученный из файла Cython, добавьте clib foo в источник Cython кода. Аналогично, дополнительный С файл bar может быть добавлен в компиляцию с объявлением cfile bar.

Самостоятельные скрипты Python/Sage#

Данный самостоятельный скрипт Sage раскладывает на множители целые числа, полиномы и т.д.:

#!/usr/bin/env sage

import sys

if len(sys.argv) != 2:
    print("Usage: %s <n>" % sys.argv[0])
    print("Outputs the prime factorization of n.")
    sys.exit(1)

print(factor(sage_eval(sys.argv[1])))

Для того, чтобы использовать этот скрипт, SAGE_ROOT должен быть в PATH. Если вышеописанный скрипт называется factor, следующее показывает, как его выполнить:

bash $ ./factor 2006
2 * 17 * 59

Типы данных#

Каждый объект в Sage имеет определенный тип. Python включает в себя большой спектр встроенных типов тогда, как библиотеки Sage добавляют еще больше. Встроенные типы данных Python включают в себя символьные строки, списки, кортежи, целые и дробные числа:

Sage

sage: s = "sage"; type(s)
<... 'str'>
sage: s = 'sage'; type(s)      # Вы можете использовать двойные или одинарные кавычки
<... 'str'>
sage: s = [1,2,3,4]; type(s)
<... 'list'>
sage: s = (1,2,3,4); type(s)
<... 'tuple'>
sage: s = int(2006); type(s)
<... 'int'>
sage: s = float(2006); type(s)
<... 'float'>

Python

>>> from sage.all import *
>>> s = "sage"; type(s)
<... 'str'>
>>> s = 'sage'; type(s)      # Вы можете использовать двойные или одинарные кавычки
<... 'str'>
>>> s = [Integer(1),Integer(2),Integer(3),Integer(4)]; type(s)
<... 'list'>
>>> s = (Integer(1),Integer(2),Integer(3),Integer(4)); type(s)
<... 'tuple'>
>>> s = int(Integer(2006)); type(s)
<... 'int'>
>>> s = float(Integer(2006)); type(s)
<... 'float'>

В свою очередь Sage добавляет много других типов данных, например, векторное поле:

Sage

sage: V = VectorSpace(QQ, 1000000); V
Vector space of dimension 1000000 over Rational Field
sage: type(V)
<class 'sage.modules.free_module.FreeModule_ambient_field_with_category'>

Python

>>> from sage.all import *
>>> V = VectorSpace(QQ, Integer(1000000)); V
Vector space of dimension 1000000 over Rational Field
>>> type(V)
<class 'sage.modules.free_module.FreeModule_ambient_field_with_category'>

Только определенные функции могут быть применены к V. В других математических программах функции вызывались бы в «функциональном» виде: foo(V,...). В Sage определенные функции прикреплены к типу (или классу) V и вызываются с помощью объектно-ориентированного синтаксиса, как в Java или C++, например, V.foo(...). Это способствует тому, что именная область видимости не захламляется десятками тысяч функций, и означает, что многие функции с разным содержанием могут быть названы «foo» без проверки типов аргументов. Также, если Вы используете имя функции повторно, эта функция все равно доступна (например, если Вы вызываете что-то наподобие zeta, а затем хотите вычислить значение функции Riemann-Zeta при 0.5, Вы можете напечатать s=.5; s.zeta()).

Sage

sage: zeta = -1
sage: s=.5; s.zeta()
-1.46035450880959

Python

>>> from sage.all import *
>>> zeta = -Integer(1)
>>> s=RealNumber('.5'); s.zeta()
-1.46035450880959

В некоторых часто встречающихся случаях, обычное функциональное обозначение также способствует удобству из-за того, что математические выражения могут выглядеть запутанно при исаользовании объектно-ориентированного обозначения. Например:

Sage

sage: n = 2; n.sqrt()
sqrt(2)
sage: sqrt(2)
sqrt(2)
sage: V = VectorSpace(QQ,2)
sage: V.basis()
    [
    (1, 0),
    (0, 1)
    ]
sage: basis(V)
    [
    (1, 0),
    (0, 1)
    ]
sage: M = MatrixSpace(GF(7), 2); M
Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7
sage: A = M([1,2,3,4]); A
[1 2]
[3 4]
sage: A.charpoly('x')
x^2 + 2*x + 5
sage: charpoly(A, 'x')
x^2 + 2*x + 5

Python

>>> from sage.all import *
>>> n = Integer(2); n.sqrt()
sqrt(2)
>>> sqrt(Integer(2))
sqrt(2)
>>> V = VectorSpace(QQ,Integer(2))
>>> V.basis()
    [
    (1, 0),
    (0, 1)
    ]
>>> basis(V)
    [
    (1, 0),
    (0, 1)
    ]
>>> M = MatrixSpace(GF(Integer(7)), Integer(2)); M
Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7
>>> A = M([Integer(1),Integer(2),Integer(3),Integer(4)]); A
[1 2]
[3 4]
>>> A.charpoly('x')
x^2 + 2*x + 5
>>> charpoly(A, 'x')
x^2 + 2*x + 5

Для того, чтобы перечислить все члены-функции для $A$, напечатайте A., а затем нажмите кнопку [tab] на Вашей клавиатуре, как описано в разделе Обратный поиск и автодополнение

Словари#

Словарь (также именуемый ассоциативным массивом) - это сопоставление „хэшируемых“ объектов (как строки, числа и кортежи из них; см. документацию Python: http://docs.python.org/tut/node7.html и http://docs.python.org/lib/typesmapping.html) произвольным объектам.

Sage

sage: d = {1:5, 'sage':17, ZZ:GF(7)}
sage: type(d)
<... 'dict'>
sage: list(d.keys())
[1, 'sage', Integer Ring]
sage: d['sage']
17
sage: d[ZZ]
Finite Field of size 7
sage: d[1]
5

Python

>>> from sage.all import *
>>> d = {Integer(1):Integer(5), 'sage':Integer(17), ZZ:GF(Integer(7))}
>>> type(d)
<... 'dict'>
>>> list(d.keys())
[1, 'sage', Integer Ring]
>>> d['sage']
17
>>> d[ZZ]
Finite Field of size 7
>>> d[Integer(1)]
5

Третий ключ показывает, что индексы словаря могу быть сложными, как, например, кольцо целых чисел.

Можно превратить вышеописанный словарь в список с тем же содержимым:

Sage

sage: list(d.items())
[(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]

Python

>>> from sage.all import *
>>> list(d.items())
[(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]

Часто используемой практикой является произведение итераций по парам в словаре:

Sage

sage: d = {2:4, 3:9, 4:16}
sage: [a*b for a, b in d.items()]
[8, 27, 64]

Python

>>> from sage.all import *
>>> d = {Integer(2):Integer(4), Integer(3):Integer(9), Integer(4):Integer(16)}
>>> [a*b for a, b in d.items()]
[8, 27, 64]

Как показывает последний пример, словарь не упорядочен.

Множества#

В Python есть встроенный тип множество. Главным преимуществом этого типа является быстрый просмотр, проверка того, принадлежит ли элемент множеству, а также обычные операции из теории множеств.

Sage

sage: X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
sage: X   # random sort order
{1, 19, 'a'}
sage: X == set(['a', 1, 1, 19])
True
sage: Y
{2/3, 1}
sage: 'a' in X
True
sage: 'a' in Y
False
sage: X.intersection(Y)
{1}

Python

>>> from sage.all import *
>>> X = set([Integer(1),Integer(19),'a']);   Y = set([Integer(1),Integer(1),Integer(1), Integer(2)/Integer(3)])
>>> X   # random sort order
{1, 19, 'a'}
>>> X == set(['a', Integer(1), Integer(1), Integer(19)])
True
>>> Y
{2/3, 1}
>>> 'a' in X
True
>>> 'a' in Y
False
>>> X.intersection(Y)
{1}

В Sage также имеется свой тип данных множество, который (в некоторых случаях) осуществлен с использованием встроенного типа множество Python, но включает в себя функциональность, связанную с Sage. Создайте множество Sage с помощью Set(...). Например,

Sage

sage: X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
sage: X   # random sort order
{'a', 1, 19}
sage: X == Set(['a', 1, 1, 19])
True
sage: Y
{1, 2/3}
sage: X.intersection(Y)
{1}
sage: print(latex(Y))
\left\{1, \frac{2}{3}\right\}
sage: Set(ZZ)
Set of elements of Integer Ring

Python

>>> from sage.all import *
>>> X = Set([Integer(1),Integer(19),'a']);   Y = Set([Integer(1),Integer(1),Integer(1), Integer(2)/Integer(3)])
>>> X   # random sort order
{'a', 1, 19}
>>> X == Set(['a', Integer(1), Integer(1), Integer(19)])
True
>>> Y
{1, 2/3}
>>> X.intersection(Y)
{1}
>>> print(latex(Y))
\left\{1, \frac{2}{3}\right\}
>>> Set(ZZ)
Set of elements of Integer Ring

Итераторы#

Итераторы - это сравнительно недавнее добавление в Python, которое является очень полезным в математических приложениях. Несколько примеров использования итераторов приведены ниже; подробнее см. [PyT]. Здесь создается итератор для квадратов неотрицательных чисел до $10000000$.

Sage

sage: v = (n^2 for n in range(10000000))
sage: next(v)
0
sage: next(v)
1
sage: next(v)
4

Python

>>> from sage.all import *
>>> v = (n**Integer(2) for n in range(Integer(10000000)))
>>> next(v)
0
>>> next(v)
1
>>> next(v)
4

Следующий пример - создание итераторов из простых чисел вида $4p+1$ с простым $p$ и просмотр нескольких первых значений:

Sage

sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
sage: w         # random output на следующей строке 0xb0853d6c может быть другим шестнадцатиричным числом
<generator object at 0xb0853d6c>
sage: next(w)
13
sage: next(w)
29
sage: next(w)
53

Python

>>> from sage.all import *
>>> w = (Integer(4)*p + Integer(1) for p in Primes() if is_prime(Integer(4)*p+Integer(1)))
>>> w         # random output на следующей строке 0xb0853d6c может быть другим шестнадцатиричным числом
<generator object at 0xb0853d6c>
>>> next(w)
13
>>> next(w)
29
>>> next(w)
53

Определенные кольца, как и конечные поля и целые числа, имеют итераторы:

Sage

sage: [x for x in GF(7)]
[0, 1, 2, 3, 4, 5, 6]
sage: W = ((x,y) for x in ZZ for y in ZZ)
sage: next(W)
(0, 0)
sage: next(W)
(0, 1)
sage: next(W)
(0, -1)

Python

>>> from sage.all import *
>>> [x for x in GF(Integer(7))]
[0, 1, 2, 3, 4, 5, 6]
>>> W = ((x,y) for x in ZZ for y in ZZ)
>>> next(W)
(0, 0)
>>> next(W)
(0, 1)
>>> next(W)
(0, -1)

Программирование#

Загрузка и прикрепление файлов Sage#

Создание компилированного кода#

Доступ к функциям С из внешних файлов#

Самостоятельные скрипты Python/Sage#

Типы данных#

Списки, кортежи и последовательности#

Словари#

Множества#

Итераторы#

Циклы, функции, управляющие конструкции и сравнения#

Профилирование#