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

Sage Live

load "example.sage"

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

Sage Live

attach "example.sage"

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

Sage Live

load "factorial.spyx"
factorial(50)
time n = factorial(10000)

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

Sage Live

attach "test.spyx"
test(10)

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

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

Sage Live

d = {1:5, 'sage':17, ZZ:GF(7)}
type(d)
list(d.keys())
d['sage']
d[ZZ]
d[1]

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

Sage Live

list(d.items())

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

Sage Live

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

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}

Sage Live

X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
X   # random
Y   # random
'a' in X
'a' in Y
X.intersection(Y)

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

Sage Live

X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
X   # random
Y   # random
X.intersection(Y)
print(latex(Y))
Set(ZZ)

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

Sage Live

v = (n^2 for n in range(10000000))
next(v)
next(v)
next(v)

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

Sage Live

w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
w         # in the next line, 0xb0853d6c is a random 0x number
next(w)
next(w)
next(w)

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)

Sage Live

[x for x in GF(7)]
W = ((x,y) for x in ZZ for y in ZZ)
next(W)
next(W)
next(W)

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