Programação¶

Carregando e Anexando Arquivos do Sage¶

A seguir ilustramos como carregar no Sage programas escritos em um arquivo separado. Crie um arquivo chamado example.sage com o seguinte conteúdo:

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

Você pode ler e executar o arquivo example.sage usando o comando load.

Sage

sage: load "example.sage"
Hello World
8

Python

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

Você também pode anexar um arquivo em Sage à sessão em execução usando o comando attach.

Sage

sage: attach "example.sage"
Hello World
8

Python

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

Agora se você alterar example.sage e adicionar uma linha em branco (por exemplo), então o conteúdo de example.sage será automaticamente recarregado no Sage.

Em particular, attach automaticamente recarrega um arquivo toda vez que ele for modificado, o que é útil para desenvolver e testar um programa, enquanto load carrega o arquivo apenas uma vez.

Quando o Sage carrega example.sage ele converte esse arquivo para o Python, o qual é então executado pelo interpretador do Python. Essa conversão é mínima; ela essencialmente consiste em encapsular inteiros em Integer(), números float em RealNumber(), substituir ^ por **, e substituir, por exemplo, R.2 por R.gen(2). A versão convertida de example.sage é armazenada no mesmo diretório de example.sage e é chamada example.sage.py. Esse arquivo contém o seguinte código:

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

Inteiros literais são encapsulados e ^ é substituído por **. (Em Python, ^ significa “ou exclusivo” e ** significa “exponenciação”.)

Esse “” está implementado em sage/misc/interpreter.py.)

Você pode colar código tabulado com muitas linhas no Sage desde que existam linhas em branco separando blocos de código (isso não é necessário em arquivos). Todavia, a melhor forma de adicionar tal código a uma sessão do Sage é salvá-lo em um arquivo e usar attach, como descrito anteriormente.

Criando Código Compilado¶

Velocidade é crucial em cálculos matemáticos. Embora o Python seja uma linguagem conveniente de alto nível, certos cálculos podem ser várias vezes mais rápidos do que em Python se eles forem implementados usando tipos estáticos em uma linguagem compilada. Alguns aspectos do Sage seriam muito lentos se eles fossem escritos inteiramente em Python. Para lidar com isso, o Sage suporta uma “versão” compilada do Python chamada Cython ([Cyt] and [Pyr]). O Cython é simultaneamente similar ao Python e ao C. A maior parte das construções em Python, incluindo “list comprehensions”, expressões condicionais, código como += são permitidos; você também pode importar código que você escreveu em outros módulos em Python. Além disso, você pode declarar variáveis em C arbitrárias, e qualquer chamada de bibliotecas em C pode ser feita diretamente. O código resultante é convertido para C e compilado usando um compilador para C.

Para criar o seu próprio código compilado em Sage, nomeie o arquivo com uma extensão .spyx (em vez de .sage). Se você está trabalhando na linha de comando, você pode anexar e carregar código compilado exatamente como se faz com código interpretado (no momento, anexar e carregar código em Cython não é suportado no Notebook). A compilação é realizada implicitamente sem que você tenha que fazer qualquer coisa explicitamente. Veja $SAGE_ROOT/examples/programming/sagex/factorial.spyx para um exemplo de uma implementação compilada para a função fatorial que usa diretamente a biblioteca GMP em C. Experimente o seguinte, usando cd, vá para o diretório $SAGE_ROOT/examples/programming/sagex/, e então faça o seguinte:

Sage

sage: load "factorial.spyx"
***************************************************
                Recompiling factorial.spyx
***************************************************
sage: factorial(50)
30414093201713378043612608166064768844377641568960512000000000000
sage: time n = factorial(10000)
CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s
Wall time: 0.03

Python

>>> from sage.all import *
>>> load "factorial.spyx"
***************************************************
                Recompiling factorial.spyx
***************************************************
>>> factorial(Integer(50))
30414093201713378043612608166064768844377641568960512000000000000
>>> time n = factorial(Integer(10000))
CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s
Wall time: 0.03

Note que o Sage vai recompilar factorial.spyx se você encerrar e reiniciar o Sage. A biblioteca compilada e compartilhada é armazenada em $HOME/.sage/temp/hostname/pid/spyx. Esses arquivos são excluídos quando você encerra o Sage.

Nenhum pré-processamento é aplicado em arquivos spyx, por exemplo, 1/3 vai resultar em 0 em um arquivo spyx em vez do número racional $1/3$. Se foo é uma função da biblioteca Sage, para usá-la em um arquivo spyx importe sage.all e use sage.all.foo.

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

Acessando Funções em C em Arquivos Separados¶

É fácil também acessar funções em C definidas em arquivos *.c separados. Aqui vai um exemplo. Crie os arquivos test.c e test.spyx no mesmo diretório contendo:

Código C puro: test.c

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

Código Cython: test.spyx:

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

def test(n):
    return add_one(n)

Então o seguinte funciona:

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

Se uma biblioteca foo adicional é necessária para compilar código em C gerado a partir de um arquivo em Cython, adicione a linha clib foo no arquivo fonte em Cython. De forma similar, um arquivo em C adicional bar pode ser incluído na compilação declarando cfile bar.

Scripts Independentes em Python/Sage¶

O seguinte script em Sage fatora inteiros, polinômios, etc:

#!/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])))

Para usar esse script, sua SAGE_ROOT precisa estar na sua variável PATH. Se o script acima for chamado factor, aqui está um exemplo de como usá-lo:

bash $ ./factor 2006
2 * 17 * 59

Tipo de Dados¶

Cada objeto em Sage possui um tipo bem definido. O Python possui diversos tipos de dados, e a biblioteca do Sage adiciona ainda mais. Os tipos de dados de Python incluem strings, listas, tuplas, inteiros e floats, como ilustrado:

Sage

sage: s = "sage"; type(s)
<... 'str'>
sage: s = 'sage'; type(s)      # you can use either single or double quotes
<... '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)      # you can use either single or double quotes
<... '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'>

Além disso, o Sage acrescenta vários outros tipos. Por exemplo, espaços vetoriais:

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'>

Apenas certas funções podem ser aplicadas sobre V. Em outros softwares de matemática, essas seriam chamadas usando a notação “funcional” foo(V,...). Em Sage, algumas funções estão anexadas ao tipo (ou classe) de V, e são chamadas usando uma sintaxe orientada a objetos como em Java ou C++, por exemplo, V.foo(). Isso ajuda a manter o espaço de variáveis global sem milhares de funções, e permite que várias funções diferentes com comportamento diferente possam ser chamadas foo, sem a necessidade de usar um mecanismo de identificação de tipos (ou casos) para decidir qual chamar. Além disso, se você reutilizar o nome de uma função, essa função continua ainda disponível (por exemplo, se você chamar algo zeta, e então quiser calcular o valor da função zeta de Riemann em 0.5, você continua podendo digitar 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

Em alguns casos muito comuns, a notação funcional usual é também suportada por conveniência e porque expressões matemáticas podem parecer confusas usando a notação orientada a objetos. Aqui vão alguns exemplos.

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

Para listar todas as funções para $A$, use completamento tab. Simplesmente digite A., então tecle [tab] no seu teclado, como descrito em Busca Reversa e Completamento Tab.

Dicionários¶

Um dicionário (também chamado as vezes de lista associativa ou “hash table”) é um mapeamento de objetos em objetos arbitrários. (Exemplos de objetos que admitem uma lista associativa são strings e números; veja a documentação Python em https://docs.python.org/3/tutorial/index.html para detalhes).

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

A terceira chave (key) ilustra como os índices de um dicionário podem ser complicados, por exemplo, um anel de inteiros.

Você pode transformar o dicionário acima em uma lista com os mesmos dados:

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)]

É comum iterar sobre os pares em um dicionário:

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]

Um dicionário não possui ordem, como o exemplo acima mostra.

Conjuntos¶

O Python possui um tipo de conjuntos (set) nativo. O principal recurso que ele oferece é a rápida verificação se um objeto está ou não em um conjunto, juntamente com as operações comuns em conjuntos.

Sage

sage: X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
sage: X   # random
{1, 19, 'a'}
sage: Y   # random
{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
{1, 19, 'a'}
>>> Y   # random
{2/3, 1}
>>> 'a' in X
True
>>> 'a' in Y
False
>>> X.intersection(Y)
{1}

O Sage também possui o seu próprio tipo de dados para conjuntos que é (em alguns casos) implementado usando o tipo nativo do Python, mas possuir algumas funcionalidades adicionais. Crie um conjunto em Sage usando Set(...). Por exemplo,

Sage

sage: X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
sage: X   # random
{'a', 1, 19}
sage: Y   # random
{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
{'a', 1, 19}
>>> Y   # random
{1, 2/3}
>>> X.intersection(Y)
{1}
>>> print(latex(Y))
\left\{1, \frac{2}{3}\right\}
>>> Set(ZZ)
Set of elements of Integer Ring

Iteradores¶

Iteradores foram adicionados recentemente ao Python e são particularmente úteis em aplicações matemáticas. Aqui estão vários exemplos; veja [PyT] para mais detalhes. Vamos criar um iterador sobre o quadrados dos números inteiros até $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

Criamos agora um iterador sobre os primos da forma $4p+1$ com $p$ também primo, e observamos os primeiros valores.

Sage

sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
sage: w         # in the next line, 0xb0853d6c is a random 0x number
<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         # in the next line, 0xb0853d6c is a random 0x number
<generator object at 0xb0853d6c>
>>> next(w)
13
>>> next(w)
29
>>> next(w)
53

Certos anéis, por exemplo, corpos finitos e os inteiros possuem iteradores associados a eles:

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)

Programação¶

Carregando e Anexando Arquivos do Sage¶

Criando Código Compilado¶

Acessando Funções em C em Arquivos Separados¶

Scripts Independentes em Python/Sage¶

Tipo de Dados¶

Listas, Tuplas e Sequências¶

Dicionários¶

Conjuntos¶

Iteradores¶

Laços, Funções, Enunciados de Controle e Comparações¶

Otimização (Profiling)¶