プログラミング#

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

こうして attach したファイル example.sage に変更を加えてからSageで空行を入力すると( return を押す)，Sageは自動的に example.sage の内容を読み込んで実行する．

attach は結合したファイルに変更が生じると自動的に読込んで実行してくれるので，デバッグの時にはとりわけ便利なコマンドになる．これに対し load の方は，コマンド実行時に一度だけファイルを読込んで実行するだけだ．

example.sage を読込むとSageは内容をPythonプログラムへと変換し，これをPythonインタプリタが実行する．このPythonへの変換は最小限に留められていて，整数リテラルを Integer() で，浮動小数点数リテラルを RealNumber() でラップし， ^ を ** で，また R.2 を R.gen(2) で置換するなどといった程度である．変換された example.sage のコードは， example.sage と同じディレクトリに example.sage.py という名前のファイルとして保存されている．この example.sage.py に入っているコードは:

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

たしかに整数リテラルはラップされ， ^ は ** に置換されている．(Pythonでは ^ は「排他的論理和」， ** は「べき乗」を意味する．)

こうした前処理は sage/misc/interpreter.py として実装されている．

コードブロックが改行で開始されているなら，インデントされた複数行のコードをSageにペーストすることができる(ファイルの読込みについてはブロック開始時の改行も不要だ)．しかしSage上にコードを取り込むには，そのコードをファイルに保存してから，先に説明したように attach するのが一番安全だ．

実行形式の作成#

数学的演算処理では実行速度がとりわけ重要になる． Pythonは使い勝手のよい非常に高水準の言語ではあるが，計算の種類によってはスタティックに型付けされたコンパイラ言語で実行した方が処理速度が数桁も速くなる場合がある． Sageにも，もし完全にPythonのみで実装していたら遅くて使いものにならなかったはずの機能がある．そうした状況を切り抜けるために，SageはCythonと呼ばれるコンパイラ言語版Pythonを利用している([Cyt] と [Pyr])． Cythonは，PythonとCの両方に似ていて，リスト内包表記、条件制御、それに += などを含むPythonの構文の大半を使うことができるし，Pythonで書いておいたモジュールをインポートすることも可能だ．加えて，C言語の変数を自由に宣言し，かつ好きなCライブラリをコード内から直接呼び出すことができる． Cythonで書いたコードはCに変換され，Cコンパイラでコンパイルされることになる．

Sageコードの実行形式を作成するには，ソースファイルの拡張子を(.sage ではなく) .spyx とする．コマンドラインインターフェイスを使っている場合，実行形式をインタプリタ用コードのときと全く同じやり方で attach あるいは load することができる(今のところ，ノートブックインターフェイスではCythonで書いたコードの読込みと結合はできない)．実際のコンパイル処理は，ユーザーが特に何も指定しなくとも裏で実行されている．作成された実行形式の共有ライブラリは $HOME/.sage/temp/hostname/pid/spyx に格納されるが，Sageの終了時に消去される．

Sageはspyxファイルに対しては前処理をしない．だから例えばspyxファイル中の 1/3 は有理数 $1/3$ ではなく0と評価される．Sageライブラリに含まれる関数 foo をspyxファイルで使用したければ， sage.all をインポートしてから sage.all.foo として呼び出す必要がある．

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

他ファイル中のC関数を使う#

別途 *.cファイルで定義されたC関数を使うのも簡単だ．実例を見てみよう．まず，同じディレクトリにファイル test.c と test.spyx を作り，内容はそれぞれ以下の通りであるとする:

純粋にCで書かれたプログラムは 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)

すると，次の手順でCプログラムを取り込むことができる:

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

Cythonソースファイルから生成されたC言語コードをコンパイルするために，さらにライブラリ foo が必要な場合は，元のCythonソースに clib foo という行を加える．同様に、他にもCソースファイル bar が必要ならばCythonソースに取り込みを宣言する行 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の組み込み型としては，string(文字列)，list(リスト)，タプル(tuple)，int(整数)，float(浮動小数点数)などがある．実際に型を表示してみると:

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 を何かの変数名として使った後でも，リーマンのゼータ関数の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] キーを押すだけのことだ．

ディクショナリ#

ディクショナリ(「連想配列」と呼ばれる場合もある)とは，文字列、数値、タプルなどのハッシュ可能なオブジェクトから任意のオブジェクトへの写像のことである． (ハッシュ可能オブジェクトについての詳細は 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には集合(set)型が組込まれている．集合型の主な利点としては，標準的な集合演算が可能になるだけではなく，ある要素が集合に属するかどうかを極めて高速に判定する機能を備えている点があげられる．

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

イテレータ#

イテレータ(iterator)は最近になって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

今度は，素数 $p$ から $4p+1$ の形の素数に関するイテレータを作り，最初の数個を見てみることにする．

Sage

sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
sage: w         # 次の行の 0xb0853d6c はランダムに生成された16進数
<generator object <genexpr> at ...>
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         # 次の行の 0xb0853d6c はランダムに生成された16進数
<generator object <genexpr> at ...>
>>> 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ファイルの読み込みと結合#

実行形式の作成#

他ファイル中のC関数を使う#

スタンドアロンPython/Sageスクリプト#

データ型#

リスト，タプル，シーケンス#

ディクショナリ#

集合#

イテレータ#

ループ，関数，制御文，比較#

プロファイリング#