<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Obtendo ajuda — Tutorial Sage v5.9</title>
<link rel="stylesheet" href="_static/sage.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '5.9',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/translations.js"></script>
<link rel="shortcut icon" href="_static/favicon.ico"/>
<link rel="top" title="Tutorial Sage v5.9" href="index.html" />
<link rel="up" title="Um passeio guiado" href="tour.html" />
<link rel="next" title="Álgebra Elementar e Cálculo" href="tour_algebra.html" />
<link rel="prev" title="Atribuição, Igualdade, e Aritmética" href="tour_assignment.html" />
<link rel="icon" href="_static/sageicon.png" type="image/x-icon" />
</head>
<body>
<div class="related">
<h3>Navegação</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Índice Geral"
accesskey="I">índice</a></li>
<li class="right" >
<a href="py-modindex.html" title="Índice de Módulos do Python"
>módulos</a> |</li>
<li class="right" >
<a href="tour_algebra.html" title="Álgebra Elementar e Cálculo"
accesskey="N">próximo</a> |</li>
<li class="right" >
<a href="tour_assignment.html" title="Atribuição, Igualdade, e Aritmética"
accesskey="P">anterior</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Tutorial Sage v5.9</a> »</li>
<li><a href="tour.html" accesskey="U">Um passeio guiado</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="obtendo-ajuda">
<span id="chapter-help"></span><h1>Obtendo ajuda<a class="headerlink" href="#obtendo-ajuda" title="Link permanente para este título">¶</a></h1>
<p>O Sage possui vasta documentação, acessível digitando o nome de uma
função ou constante (por exemplo), seguido pelo ponto de interrogação:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: tan?</span>
<span class="go">Type: <class 'sage.calculus.calculus.Function_tan'></span>
<span class="go">Definition: tan( [noargspec] )</span>
<span class="go">Docstring:</span>
<span class="go"> The tangent function</span>
<span class="go"> EXAMPLES:</span>
<span class="go"> sage: tan(pi)</span>
<span class="go"> 0</span>
<span class="go"> sage: tan(3.1415)</span>
<span class="go"> -0.0000926535900581913</span>
<span class="go"> sage: tan(3.1415/4)</span>
<span class="go"> 0.999953674278156</span>
<span class="go"> sage: tan(pi/4)</span>
<span class="go"> 1</span>
<span class="go"> sage: tan(1/2)</span>
<span class="go"> tan(1/2)</span>
<span class="go"> sage: RR(tan(1/2))</span>
<span class="go"> 0.546302489843790</span>
<span class="go">sage: log2?</span>
<span class="go">Type: <class 'sage.functions.constants.Log2'></span>
<span class="go">Definition: log2( [noargspec] )</span>
<span class="go">Docstring:</span>
<span class="go"> The natural logarithm of the real number 2.</span>
<span class="go"> EXAMPLES:</span>
<span class="go"> sage: log2</span>
<span class="go"> log2</span>
<span class="go"> sage: float(log2)</span>
<span class="go"> 0.69314718055994529</span>
<span class="go"> sage: RR(log2)</span>
<span class="go"> 0.693147180559945</span>
<span class="go"> sage: R = RealField(200); R</span>
<span class="go"> Real Field with 200 bits of precision</span>
<span class="go"> sage: R(log2)</span>
<span class="go"> 0.69314718055994530941723212145817656807550013436025525412068</span>
<span class="go"> sage: l = (1-log2)/(1+log2); l</span>
<span class="go"> (1 - log(2))/(log(2) + 1)</span>
<span class="go"> sage: R(l)</span>
<span class="go"> 0.18123221829928249948761381864650311423330609774776013488056</span>
<span class="go"> sage: maxima(log2)</span>
<span class="go"> log(2)</span>
<span class="go"> sage: maxima(log2).float()</span>
<span class="go"> .6931471805599453</span>
<span class="go"> sage: gp(log2)</span>
<span class="go"> 0.6931471805599453094172321215 # 32-bit</span>
<span class="go"> 0.69314718055994530941723212145817656807 # 64-bit</span>
<span class="go">sage: sudoku?</span>
<span class="go">File: sage/local/lib/python2.5/site-packages/sage/games/sudoku.py</span>
<span class="go">Type: <type 'function'></span>
<span class="go">Definition: sudoku(A)</span>
<span class="go">Docstring:</span>
<span class="go"> Solve the 9x9 Sudoku puzzle defined by the matrix A.</span>
<span class="go"> EXAMPLE:</span>
<span class="go"> sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0,</span>
<span class="go"> 0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0,</span>
<span class="go"> 0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0, 0,3,0, 0,0,2,</span>
<span class="go"> 0,0,0, 4,9,0, 0,5,0, 0,0,3])</span>
<span class="go"> sage: A</span>
<span class="go"> [5 0 0 0 8 0 0 4 9]</span>
<span class="go"> [0 0 0 5 0 0 0 3 0]</span>
<span class="go"> [0 6 7 3 0 0 0 0 1]</span>
<span class="go"> [1 5 0 0 0 0 0 0 0]</span>
<span class="go"> [0 0 0 2 0 8 0 0 0]</span>
<span class="go"> [0 0 0 0 0 0 0 1 8]</span>
<span class="go"> [7 0 0 0 0 4 1 5 0]</span>
<span class="go"> [0 3 0 0 0 2 0 0 0]</span>
<span class="go"> [4 9 0 0 5 0 0 0 3]</span>
<span class="go"> sage: sudoku(A)</span>
<span class="go"> [5 1 3 6 8 7 2 4 9]</span>
<span class="go"> [8 4 9 5 2 1 6 3 7]</span>
<span class="go"> [2 6 7 3 4 9 5 8 1]</span>
<span class="go"> [1 5 8 4 6 3 9 7 2]</span>
<span class="go"> [9 7 4 2 1 8 3 6 5]</span>
<span class="go"> [3 2 6 7 9 5 4 1 8]</span>
<span class="go"> [7 8 2 9 3 4 1 5 6]</span>
<span class="go"> [6 3 5 1 7 2 8 9 4]</span>
<span class="go"> [4 9 1 8 5 6 7 2 3]</span>
</pre></div>
</div>
<p>O Sage também fornece completamento tab: digite as primeiras letras de
uma função e então pressione a tecla tab. Por exemplo, se você digitar
<tt class="docutils literal"><span class="pre">ta</span></tt> seguido de <tt class="docutils literal"><span class="pre">TAB</span></tt>, o Sage vai imprimir <tt class="docutils literal"><span class="pre">tachyon,</span> <span class="pre">tan,</span> <span class="pre">tanh,</span>
<span class="pre">taylor</span></tt>. Essa é uma boa forma de encontrar nomes de funções e outras
estruturas no Sage.</p>
</div>
<div class="section" id="funcoes-tabulacao-e-contagem">
<span id="section-functions"></span><h1>Funções, Tabulação, e Contagem<a class="headerlink" href="#funcoes-tabulacao-e-contagem" title="Link permanente para este título">¶</a></h1>
<p>Para definir uma nova função no Sage, use o comando <tt class="docutils literal"><span class="pre">def</span></tt> e dois
pontos após a lista de nomes das variáveis. Por exemplo:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: def is_even(n):</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">n</span><span class="o">%</span><span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span>
<span class="gp">...</span>
<span class="go">sage: is_even(2)</span>
<span class="go">True</span>
<span class="go">sage: is_even(3)</span>
<span class="go">False</span>
</pre></div>
</div>
<p>Observação: Dependendo da versão do tutorial que você está lendo,
você pode ver três pontos <tt class="docutils literal"><span class="pre">...</span></tt> na segunda linha desse exemplo. Não
digite esses pontos; eles são apenas para enfatizar que o código está
tabulado. Se for esse o caso, pressione [Enter] uma vez após o fim do
bloco de código para inserir uma linha em branco e concluir a
definição da função.</p>
<p>Você não especifica o tipo de dado de nenhum dos argumentos da função.
É possível especificar argumentos múltiplos, cada um dos quais pode
ter um valor opcional padrão. Por exemplo, a função abaixo usa o valor
padrão <tt class="docutils literal"><span class="pre">divisor=2</span></tt> se <tt class="docutils literal"><span class="pre">divisor</span></tt> não é especificado.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: def is_divisible_by(number, divisor=2):</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">number</span><span class="o">%</span><span class="n">divisor</span> <span class="o">==</span> <span class="mi">0</span>
<span class="go">sage: is_divisible_by(6,2)</span>
<span class="go">True</span>
<span class="go">sage: is_divisible_by(6)</span>
<span class="go">True</span>
<span class="go">sage: is_divisible_by(6, 5)</span>
<span class="go">False</span>
</pre></div>
</div>
<p>Você também pode especificar explicitamente um ou mais argumentos
quando evocar uma função; se você especificar os argumentos
explicitamente, você pode fazê-lo em qualquer ordem:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: is_divisible_by(6, divisor=5)</span>
<span class="go">False</span>
<span class="go">sage: is_divisible_by(divisor=2, number=6)</span>
<span class="go">True</span>
</pre></div>
</div>
<p>Em Python, blocos de código não são indicados por colchetes ou blocos
de início e fim, como em outras linguagens. Em vez disso, blocos de
código são indicados por tabulação, que devem estar alinhadas
exatamente. Por exemplo, o seguinte código possui um erro de sintaxe
porque o comando <tt class="docutils literal"><span class="pre">return</span></tt> não possui a mesma tabulação da linha que
inicia o seu bloco de código.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: def even(n):</span>
<span class="gp">... </span> <span class="n">v</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">... </span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="n">n</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">if</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="gp">... </span> <span class="n">v</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">v</span>
<span class="go">Syntax Error:</span>
<span class="go"> return v</span>
</pre></div>
</div>
<p>Se você corrigir a tabulação, a função fica correta:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: def even(n):</span>
<span class="gp">... </span> <span class="n">v</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">... </span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="n">n</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">if</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="gp">... </span> <span class="n">v</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">v</span>
<span class="go">sage: even(10)</span>
<span class="go">[4, 6, 8]</span>
</pre></div>
</div>
<p>Não é necessário inserir ponto-e-vírgula no final da linha. Todavia,
você pode inserir múltiplos comandos em uma mesma linha separados por
ponto-e-vírgula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: a = 5; b = a + 3; c = b^2; c</span>
<span class="go">64</span>
</pre></div>
</div>
<p>Se você quiser que uma única linha de comando seja escrita em mais de
uma linha, use a barra invertida para quebrar a linha:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 2 + \</span>
<span class="gp">... </span> <span class="mi">3</span>
<span class="go">5</span>
</pre></div>
</div>
<p>Em Sage, a contagem é feita iterando sobre um intervalo de inteiros.
Por exemplo, a primeira linha abaixo é equivalente a <tt class="docutils literal"><span class="pre">for(i=0;</span> <span class="pre">i<3;</span>
<span class="pre">i++)</span></tt> em C++ ou Java:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(3):</span>
<span class="gp">... </span> <span class="k">print</span> <span class="n">i</span>
<span class="go">0</span>
<span class="go">1</span>
<span class="go">2</span>
</pre></div>
</div>
<p>A primeira linha abaixo é equivalente a <tt class="docutils literal"><span class="pre">for(i=2;</span> <span class="pre">i<5;</span> <span class="pre">i++)</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(2,5):</span>
<span class="gp">... </span> <span class="k">print</span> <span class="n">i</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">4</span>
</pre></div>
</div>
<p>O Terceiro argumento controla o passo. O comando abaixo é equivalente
a <tt class="docutils literal"><span class="pre">for(i=1;</span> <span class="pre">i<6;</span> <span class="pre">i+=2)</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(1,6,2):</span>
<span class="gp">... </span> <span class="k">print</span> <span class="n">i</span>
<span class="go">1</span>
<span class="go">3</span>
<span class="go">5</span>
</pre></div>
</div>
<p>Frequentemente deseja-se criar uma tabela para visualizar resultados
calculados com o Sage. Uma forma fácil de fazer isso é utilizando
formatação de strings. Abaixo, criamos três colunas cada uma com
largura exatamente 6, e fazemos uma tabela com quadrados e cubos de
alguns números.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: for i in range(5):</span>
<span class="gp">... </span> <span class="k">print</span> <span class="s">'</span><span class="si">%6s</span><span class="s"> </span><span class="si">%6s</span><span class="s"> </span><span class="si">%6s</span><span class="s">'</span><span class="o">%</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">i</span><span class="o">^</span><span class="mi">2</span><span class="p">,</span> <span class="n">i</span><span class="o">^</span><span class="mi">3</span><span class="p">)</span>
<span class="go"> 0 0 0</span>
<span class="go"> 1 1 1</span>
<span class="go"> 2 4 8</span>
<span class="go"> 3 9 27</span>
<span class="go"> 4 16 64</span>
</pre></div>
</div>
<p>A estrutura de dados mais básica em Sage é a lista, que é – como o
nome sugere – simplesmente uma lista de objetos arbitrários. Por
exemplo, o comando <tt class="docutils literal"><span class="pre">range</span></tt> que usamos acima cria uma lista:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: range(2,10)</span>
<span class="go">[2, 3, 4, 5, 6, 7, 8, 9]</span>
</pre></div>
</div>
<p>Abaixo segue uma lista mais complicada:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v = [1, "hello", 2/3, sin(x^3)]</span>
<span class="go">sage: v</span>
<span class="go">[1, 'hello', 2/3, sin(x^3)]</span>
</pre></div>
</div>
<p>Listas são indexadas começando do 0, como em várias linguagens de
programação.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: v[0]</span>
<span class="go">1</span>
<span class="go">sage: v[3]</span>
<span class="go">sin(x^3)</span>
</pre></div>
</div>
<p>Use <tt class="docutils literal"><span class="pre">len(v)</span></tt> para obter o comprimento de <tt class="docutils literal"><span class="pre">v</span></tt>, use
<tt class="docutils literal"><span class="pre">v.append(obj)</span></tt> para inserir um novo objeto no final de <tt class="docutils literal"><span class="pre">v</span></tt>, e use
<tt class="docutils literal"><span class="pre">del</span> <span class="pre">v[i]</span></tt> para remover o <img class="math" src="_images/math/34857b3ba74ce5cd8607f3ebd23e9015908ada71.png" alt="i"/>-ésimo elemento de <tt class="docutils literal"><span class="pre">v</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: len(v)</span>
<span class="go">4</span>
<span class="go">sage: v.append(1.5)</span>
<span class="go">sage: v</span>
<span class="go">[1, 'hello', 2/3, sin(x^3), 1.50000000000000]</span>
<span class="go">sage: del v[1]</span>
<span class="go">sage: v</span>
<span class="go">[1, 2/3, sin(x^3), 1.50000000000000]</span>
</pre></div>
</div>
<p>Outra importante estrutura de dados é o dicionário (ou lista
associativa). Ele funciona como uma lista, exceto que pode ser
indexado por vários tipos de objeto (os índices devem ser imutáveis):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: d = {'hi':-2, 3/8:pi, e:pi}</span>
<span class="go">sage: d['hi']</span>
<span class="go">-2</span>
<span class="go">sage: d[e]</span>
<span class="go">pi</span>
</pre></div>
</div>
<p>Você pode também definir novos tipos de dados usando classes.
Encapsular objetos matemáticos usando classes é uma técnica poderosa
que pode ajudar a simplificar e organizar os seus programas em Sage.
Abaixo, definimos uma nova classe que representa a lista de inteiros
pares positivos até <em>n</em>; essa classe é derivada do tipo <tt class="docutils literal"><span class="pre">list</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: class Evens(list):</span>
<span class="gp">... </span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="gp">... </span> <span class="bp">self</span><span class="o">.</span><span class="n">n</span> <span class="o">=</span> <span class="n">n</span>
<span class="gp">... </span> <span class="nb">list</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
<span class="gp">... </span> <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">return</span> <span class="s">"Even positive numbers up to n."</span>
</pre></div>
</div>
<p>O método <tt class="docutils literal"><span class="pre">__init__</span></tt> é evocado para inicializar o objeto quando ele é
criado; o método <tt class="docutils literal"><span class="pre">__repr__</span></tt> imprime o objeto. Nós evocamos o
construtor <tt class="docutils literal"><span class="pre">__init__</span></tt> do tipo <tt class="docutils literal"><span class="pre">list</span></tt> na segunda linha do método
<tt class="docutils literal"><span class="pre">__init__</span></tt>. Criamos um objeto da classe <tt class="docutils literal"><span class="pre">Evens</span></tt> da seguinte forma:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: e = Evens(10)</span>
<span class="go">sage: e</span>
<span class="go">Even positive numbers up to n.</span>
</pre></div>
</div>
<p>Note que <tt class="docutils literal"><span class="pre">e</span></tt> imprime usando o método <tt class="docutils literal"><span class="pre">__repr__</span></tt> que nós
definimos. Para ver a lista de números, use a função <tt class="docutils literal"><span class="pre">list</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: list(e)</span>
<span class="go">[2, 4, 6, 8, 10]</span>
</pre></div>
</div>
<p>Podemos também acessar o atributo <tt class="docutils literal"><span class="pre">n</span></tt> ou tratar <tt class="docutils literal"><span class="pre">e</span></tt> como uma
lista.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: e.n</span>
<span class="go">10</span>
<span class="go">sage: e[2]</span>
<span class="go">6</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Tabela de Conteúdo</a></h3>
<ul>
<li><a class="reference internal" href="#">Obtendo ajuda</a></li>
<li><a class="reference internal" href="#funcoes-tabulacao-e-contagem">Funções, Tabulação, e Contagem</a></li>
</ul>
<h4>Tópico anterior</h4>
<p class="topless"><a href="tour_assignment.html"
title="capítulo anterior">Atribuição, Igualdade, e Aritmética</a></p>
<h4>Próximo tópico</h4>
<p class="topless"><a href="tour_algebra.html"
title="próximo capítulo">Álgebra Elementar e Cálculo</a></p>
<h3>Esta Página</h3>
<ul class="this-page-menu">
<li><a href="_sources/tour_help.txt"
rel="nofollow">Exibir Fonte</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Pesquisa rápida</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<!-- The shading of the "Go" button should be consistent -->
<!-- with the colour of the header and footer. See the file -->
<!-- doc/common/themes/sage/theme.conf for colours used by -->
<!-- the Sage theme. -->
<input type="submit" style="background-color: #B8B9F6" value="Ir" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Digite os termos da busca ou o nome de um módulo, classe ou função.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navegação</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Índice Geral"
>índice</a></li>
<li class="right" >
<a href="py-modindex.html" title="Índice de Módulos do Python"
>módulos</a> |</li>
<li class="right" >
<a href="tour_algebra.html" title="Álgebra Elementar e Cálculo"
>próximo</a> |</li>
<li class="right" >
<a href="tour_assignment.html" title="Atribuição, Igualdade, e Aritmética"
>anterior</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Tutorial Sage v5.9</a> »</li>
<li><a href="tour.html" >Um passeio guiado</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2005--2011, The Sage Development Team.
Criado com <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<script type="text/javascript">
/*global jQuery, window */
/* Sphinx sidebar toggle. Putting this code at the end of the body
* enables the toggle for the live, static, and offline docs. Note:
* sage.misc.html.math_parse() eats jQuery's dollar-sign shortcut. */
var jq = jQuery;
jq(document).ready(function () {
var bar, bod, bg, fg, key, tog, wid_old, wid_new, resize, get_state, set_state;
bod = jq('div.bodywrapper');
bar = jq('div.sphinxsidebar');
tog = jq('<div class="sphinxsidebartoggle"></div>');
/* Delayed resize helper. Not perfect but good enough. */
resize = function () {
setTimeout(function () {
tog.height(bod.height());
}, 100);
};
jq(window).resize(function () {
resize();
});
/* Setup and add the toggle. See Sphinx v0.5.1 default.css. */
fg = jq('div.sphinxsidebar p a').css('color') || 'rgb(152, 219, 204)';
bg = jq('div.document').css('background-color') || 'rgb(28, 78, 99)';
wid_old = '230px';
wid_new = '5px';
tog.css('background-color', bg)
.css('border-width', '0px')
.css('border-right', wid_new + ' ridge ' + bg)
.css('cursor', 'pointer')
.css('position', 'absolute')
.css('left', '-' + wid_new)
.css('top', '0px')
.css('width', wid_new);
bod.css('position', 'relative');
bod.prepend(tog);
resize();
/* Cookie helpers. */
key = 'sphinxsidebar=';
set_state = function (s) {
var date = new Date();
/* Expiry in 7 days. */
date.setTime(date.getTime() + (7 * 24 * 3600 * 1000));
document.cookie = key + encodeURIComponent(s) + '; expires=' +
date.toUTCString() + '; path=/';
};
get_state = function () {
var i, c, crumbs = document.cookie.split(';');
for (i = 0; i < crumbs.length; i += 1) {
c = crumbs[i].replace(/^\s+/, '');
if (c.indexOf(key) === 0) {
return decodeURIComponent(c.substring(key.length, c.length));
}
}
return null;
};
/* Event handlers. */
tog.mouseover(function (ev) {
tog.css('border-right-color', fg);
}).mouseout(function (ev) {
tog.css('border-right-color', bg);
}).click(function (ev) {
if (bod.hasClass('wide')) {
bod.removeClass('wide');
bod.css('margin-left', wid_old);
bar.css('width', wid_old);
bar.show();
set_state('visible');
} else {
set_state('hidden');
bar.hide();
bar.css('width', '0px');
bod.css('margin-left', wid_new);
bod.addClass('wide');
}
resize();
});
/* Hide the normally visible sidebar? */
if (get_state() === 'hidden') {
tog.trigger('click');
} else {
set_state('visible');
}
});
</script>
</body>
</html>
