Ticket #12822: trac_12822_pt_translation_of_tutorial.patch

File trac_12822_pt_translation_of_tutorial.patch, 218.9 KB (added by goliveira, 7 years ago)
  • new file doc/pt/tutorial/afterword.rst

    # HG changeset patch
    # User Gustavo de Oliveira <goliveira5d@gmail.com>
    # Date 1334006083 -7200
    # Node ID ad8e41651a3187a45f087335cb048418bf545506
    # Parent  bbd101e6eaa8de241270aa8063dc8380a6d983e3
    Trac 12822: Portuguese translation of "Tutorial".
    
    diff --git a/doc/pt/tutorial/afterword.rst b/doc/pt/tutorial/afterword.rst
    new file mode 100644
    - +  
     1********
     2Posfacio
     3********
     4
     5Por quê o Python?
     6=================
     7
     8Vantagens do Python
     9-------------------
     10
     11A primeira linguagem de implementação do Sage é o Python (veja [Py]_),
     12embora rotinas que precisam ser muito rápidas são implementadas em uma
     13linguagem compilada. O Python possui várias vantagens:
     14
     15-  **Salvar objetos** é bem suportado em Python. Existe suporte
     16   extenso em Python para salvar (na grande maioria dos casos) objetos
     17   arbitrários em arquivos em disco ou em uma base de dados.
     18
     19-  Suporte excelente para **documentação** de funções e pacotes no
     20   código fonte, incluindo extração automática de documentação e teste
     21   automático de todos os exemplos. Os exemplos são automaticamente
     22   testados regularmente para garantir que funcionam como indicado.
     23
     24-  **Gerenciamento de memória:** O Python agora possui um sistema de
     25   gerenciamento de memória e "garbage collector" muito bem pensados e
     26   robustos que lidam corretamente com referências circulares, e
     27   permitem variáveis locais em arquivos.
     28
     29-  O Python possui **diversos pacotes** disponíveis que podem ser de
     30   grande interesse para os usuários do Sage: análise numérica e
     31   álgebra linear, visualização 2D e 3D, comunicação via rede (para
     32   computação distribuída e servidores, por exemplo, via twisted),
     33   suporte a base de dados, etc.
     34
     35-  **Portabilidade:** O Python é fácil de compilar a partir do código
     36   fonte em poucos minutos na maioria das arquiteturas.
     37
     38-  **Manuseamento de exceções:** O Python possui um sofisticado e bem
     39   pensado sistema de manuseamento de exceções, através do qual
     40   programas podem facilmente se recuperar mesmo se ocorrerem erros no
     41   código que está sendo executado.
     42
     43-  **Debugador:** O Python inclui um debugador, de modo que quando
     44   alguma rotina falha por algum motivo, o usuário pode acessar
     45   extensiva informação sobre a pilha de cálculos e inspecionar o
     46   estado de todas as variáveis relevantes.
     47
     48-  **Profiler:** Existe um profiler para o Python, o qual executa
     49   programas e cria um relatório detalhando quantas vezes e por quando
     50   tempo cada função foi executada.
     51
     52-  **Uma Linguagem:** Em vez de escrever uma **nova linguagem** para
     53   matemática como foi feito para o Magma, Maple, Mathematica, Matlab,
     54   GP/PARI, GAP, Macaulay 2, Simath, etc., nós usamos a linguagem
     55   Python, que é uma linguagem de programação popular que está
     56   sendo desenvolvida e otimizada ativamente por centenas de
     57   engenheiros de software qualificados. O Python é uma grande
     58   história de sucesso em desenvolvimento com código aberto com um
     59   processo de desenvolvimento maduro (veja [PyDev]_).
     60
     61.. _section-mathannoy:
     62
     63O Pré-Processador: Diferenças entre o Sage e o Python
     64-----------------------------------------------------
     65
     66Alguns aspectos matemáticos do Python podem ser confusos, logo o Sage
     67se comporta diferentemente do Python em diversas situações.
     68
     69-  **Notação para exponenciação:** ``**`` versus ``^``. Em Python,
     70   ``^`` significa "xor", não exponenciação, logo em Python temos
     71
     72   ::
     73
     74       >>> 2^8
     75       10
     76       >>> 3^2
     77       1
     78       >>> 3**2
     79       9
     80
     81   Esse uso de ``^`` pode parecer estranho, e é ineficiente para
     82   pesquisa em matemática pura, pois a função "ou exclusivo" é
     83   raramente usada. Por conveniência, o Sage pre-processa todos as
     84   linhas de comandos antes de passá-las para o Python, substituindo
     85   ocorrências de ``^`` que não estão em strings por ``**``:
     86
     87   ::
     88
     89       sage: 2^8
     90       256
     91       sage: 3^2
     92       9
     93       sage: "3^2"
     94       '3^2'
     95
     96-  **Divisão por inteiros:** A expressão em Python ``2/3`` não se
     97   comporta da forma que um matemático esperaria. Em Python, se ``m``
     98   e ``n`` são inteiros (int), então ``m/n`` também é um inteiro
     99   (int), a saber, o quociente de ``m`` dividido por ``n``. Portanto
     100   ``2/3=0``. Tem havido discussões na comunidade do Python para
     101   modificar o Python de modo que ``2/3`` retorne um número de
     102   precisão flutuante (float) ``0.6666...``, e ``2//3`` retorne ``0``.
     103
     104   Nós lidamos com isso no interpretador Sage, encapsulando inteiros
     105   literais em ``Integer()`` e fazendo a divisão um construtor para
     106   números racionais. Por exemplo:
     107
     108   ::
     109
     110       sage: 2/3
     111       2/3
     112       sage: (2/3).parent()
     113       Rational Field
     114       sage: 2//3
     115       0
     116       sage: int(2)/int(3)
     117       0
     118
     119-  **Inteiros longos:** O Python possui suporte nativo para inteiros
     120   com precisão arbitrária, além de int's do C. Esses são
     121   significantemente mais lentos do que os fornecidos pela biblioteca
     122   GMP, e têm a propriedade que eles são impressos com o sufixo ``L``
     123   para distingui-los de int's (e isso não será modificado no futuro
     124   próximo). O Sage implementa inteiros com precisão arbitrária usando
     125   a biblioteca C do GMP, e esses são impressos sem o sufixo ``L``.
     126
     127Em vez de modificar o interpretador Python (como algumas pessoas
     128fizeram para projetos internos), nós usamos a linguagem Python
     129exatamente com ela é, e escrevemos um pré-processador para o IPython de
     130modo que o comportamento da linha de comando seja o que um matemático
     131espera. Isso significa que qualquer programa existente em Python pode
     132ser usado no Sage. Todavia, deve-se obedecer as regras padrão do
     133Python para escrever programas que serão importados no Sage.
     134
     135(Para instalar uma biblioteca do Python, por exemplo uma que você
     136tenha encontrado na internet, siga as instruções, mas execute ``sage
     137-python`` em vez de ``python``. Frequentemente isso significa digitar
     138``sage -python setup.py install``.)
     139
     140Eu gostaria de contribuir de alguma forma. Como eu posso?
     141=========================================================
     142
     143Se você quiser contribuir para o Sage, a sua ajuda será muito bem
     144vinda! Ela pode variar desde substancial quantidade de código, até
     145contribuições com respeito à documentação ou notificação de defeitos
     146(bugs).
     147
     148Explore a página na web do Sage para informações para desenvolvedores;
     149entre outras coisas, você pode encontrar uma lista longa de projetos
     150relacionados ao Sage ordenados por prioridade e categoria. O `Guia
     151para desenvolvedores do Sage
     152<http://www.sagemath.org/doc/developer/>`_ (em inglês) também possui
     153informações úteis, e você pode também visitar o grupo de discussões
     154``sage-devel`` no Google Groups.
     155
     156Como eu faço referência ao Sage?
     157================================
     158
     159Se você escrever um artigo usando o Sage, por favor faça referência
     160aos cálculos feitos com o Sage incluindo
     161
     162::
     163
     164    [Sage] William A. Stein et al., Sage Mathematics Software (Version 4.3).
     165           The Sage Development Team, 2009, http://www.sagemath.org.
     166
     167na sua bibliografia (substituindo 4.3 pela versão do Sage que você
     168está usando). Além disso, procure observar quais componentes do Sage
     169você está usando em seus cálculos, por exemplo, PARI, Singular, GAP,
     170Maxima, e também site esses sistemas. Se você está em dúvida sobre
     171qual software está sendo usado em seus cálculos, fique à vontade para
     172perguntar no grupo ``sage-devel`` do Google Groups. Veja
     173:ref:`section-univariate` para mais discussões sobre esse aspecto.
     174
     175------------
     176
     177Se por acaso você leu este tutorial do começo ao fim em uma só vez, e
     178faz idéia de quanto tempo você levou, por favor nos informe no grupo
     179``sage-devel`` do Google Groups.
     180
     181Divirta-se com o Sage!
  • new file doc/pt/tutorial/appendix.rst

    diff --git a/doc/pt/tutorial/appendix.rst b/doc/pt/tutorial/appendix.rst
    new file mode 100644
    - +  
     1********
     2Apêndice
     3********
     4
     5.. _section-precedence:
     6
     7Precedência de operações aritméticas binárias
     8=============================================
     9
     10Quanto é ``3^2*4 + 2%5``? A resposta (38) é determinada pela "tabela
     11de precedência" abaixo. A tabela abaixo é baseada na tabela em § 5.14
     12do *Python Language Reference Manual* by G. Rossum and F. Drake. As
     13operações estão listadas aqui em ordem crescente de precedência.
     14
     15
     16==========================  =================
     17Operadores                  Descrição
     18==========================  =================
     19or                          "ou" booleano
     20and                             "e" booleano
     21not                                 "não" booleano
     22in, not in                      pertence
     23is, is not                      teste de identidade
     24>, <=, >, >=, ==, !=, <>    comparação
     25+, -                        adição, subtração
     26\*, /, %                    multiplicação, divisão, resto
     27\*\*, ^                     exponenciação
     28==========================  =================
     29
     30Portanto, para calcular ``3^2*4 + 2%5``, O Sage inclui parenteses de
     31precedência da seguinte forma: ``((3^2)*4) + (2%5)``. Logo, primeiro
     32calcula ``3^2``, que é ``9``, então calcula ``(3^2)*4`` e ``2%5``, e
     33finalmente soma os dois.
  • new file doc/pt/tutorial/bibliography.rst

    diff --git a/doc/pt/tutorial/bibliography.rst b/doc/pt/tutorial/bibliography.rst
    new file mode 100644
    - +  
     1************
     2Bibliografia
     3************
     4
     5..  [Cyt] Cython, http://www.cython.org.
     6
     7..  [Dive] Dive into Python, disponível gratuitamente na internet em
     8    http://diveintopython.org.
     9
     10..  [GAP] The GAP Group, GAP - Groups, Algorithms, and
     11    Programming, Version 4.4; 2005, http://www.gap-system.org
     12
     13..  [GAPkg] GAP Packages,
     14    http://www.gap-system.org/Packages/packages.html
     15
     16..  [GP] PARI/GP http://pari.math.u-bordeaux.fr/.
     17
     18..  [Ip] The IPython shell http://ipython.scipy.org.
     19
     20..  [Jmol] Jmol: an open-source Java viewer for chemical
     21    structures in 3D http://www.jmol.org/.
     22
     23..  [Mag] Magma http://magma.maths.usyd.edu.au/magma/.
     24
     25..  [Max] Maxima http://maxima.sf.net/
     26
     27..  [NagleEtAl2004] Nagle, Saff, and Snider.
     28    *Fundamentals of Differential Equations*. 6th edition, Addison-Wesley,
     29    2004.
     30
     31..  [Py] The Python language http://www.python.org/
     32    Reference Manual http://docs.python.org/ref/ref.html.
     33
     34..  [PyDev] Guido, Some Guys, and a Mailing List: How Python is
     35    Developed,
     36    http://www.python.org/dev/dev_intro.html.
     37
     38..  [Pyr] Pyrex,
     39    http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/.
     40
     41..  [PyT] The Python Tutorial http://www.python.org/.
     42
     43..  [SA] Sage web site http://www.sagemath.org/.
     44
     45..  [Si] G.-M. Greuel, G. Pfister, and H. Schönemann. Singular
     46    3.0. A Computer Algebra System for Polynomial Computations. Center
     47    for Computer Algebra, University of Kaiserslautern (2005).
     48    http://www.singular.uni-kl.de.
     49
     50..  [SJ] William Stein, David Joyner, Sage: System for Algebra and
     51    Geometry Experimentation, Comm. Computer Algebra {39}(2005)61-64.
     52
  • new file doc/pt/tutorial/conf.py

    diff --git a/doc/pt/tutorial/conf.py b/doc/pt/tutorial/conf.py
    new file mode 100644
    - +  
     1# -*- coding: utf-8 -*-
     2#
     3# Sage documentation build configuration file, based on the file created by
     4# sphinx-quickstart on Thu Aug 21 20:15:55 2008.
     5#
     6# This file is execfile()d with the current directory set to its containing dir.
     7#
     8# The contents of this file are pickled, so don't put values in the namespace
     9# that aren't pickleable (module imports are okay, they're removed automatically).
     10#
     11# All configuration values have a default; values that are commented out
     12# serve to show the default.
     13
     14import sys, os
     15sys.path.append(os.environ['SAGE_DOC'])
     16from common.conf import *
     17
     18# General information about the project.
     19project = u"Tutorial Sage"
     20name = u'tutorial-pt'
     21language = "pt_BR"
     22
     23# The name for this set of Sphinx documents.  If None, it defaults to
     24# "<project> v<release> documentation".
     25html_title = project + " v"+release
     26
     27# Output file base name for HTML help builder.
     28htmlhelp_basename = name
     29
     30# Grouping the document tree into LaTeX files. List of tuples
     31# (source start file, target name, title, author, document class [howto/manual]).
     32latex_documents = [
     33  ('index', name+'.tex', project,
     34   u'The Sage Group', 'manual'),
     35]
  • new file doc/pt/tutorial/index.rst

    diff --git a/doc/pt/tutorial/index.rst b/doc/pt/tutorial/index.rst
    new file mode 100644
    - +  
     1.. Sage documentation master file, created by sphinx-quickstart on Thu Aug 21 20:15:55 2008.
     2   You can adapt this file completely to your liking, but it should at least
     3   contain the root `toctree` directive.
     4
     5Bem-vindo ao Tutorial Sage!
     6===========================
     7
     8Sage é um software de matemática gratuito, de código aberto, para uso
     9em ensino e pesquisa em álgebra, geometria, teoria de números,
     10criptografia, computação numérica, e áreas relacionadas. Tanto o
     11modelo de desenvolvimento como a tecnologia empregada no Sage se
     12distinguem pela forte ênfase em transparência, cooperação, e
     13colaboração: estamos desenvolvendo o carro, não reinventando a roda. O
     14objetivo maior do Sage é criar uma alternativa viável, gratuita, e de
     15código aberto aos programas Maple, Mathematica, Magma e MATLAB.
     16
     17Este tutorial é a melhor forma de se familiarizar com o Sage em apenas
     18algumas horas. Você pode lê-lo em versão HTML ou PDF, ou diretamente
     19no Notebook Sage (clique em ``Help``, e então clique em ``Tutorial``
     20para percorrer o tutorial de forma iterativa diretamente do Sage).
     21
     22Este documento está sob a licença `Creative Commons CompartilhaIgual
     233.0`__.
     24
     25__ http://creativecommons.org/licenses/by-sa/3.0/deed.pt
     26
     27.. toctree::
     28   :maxdepth: 2
     29
     30   introduction
     31   tour
     32   interactive_shell
     33   interfaces
     34   latex
     35   programming
     36   sagetex
     37   afterword
     38   appendix
     39   bibliography
     40
     41Índices e tabelas
     42=================
     43
     44* :ref:`genindex`
     45* :ref:`modindex`
     46* :ref:`search`
  • new file doc/pt/tutorial/interactive_shell.rst

    diff --git a/doc/pt/tutorial/interactive_shell.rst b/doc/pt/tutorial/interactive_shell.rst
    new file mode 100644
    - +  
     1.. _chapter-interactive_shell:
     2
     3*****************************
     4A Linha de Comando Interativa
     5*****************************
     6Na maior parte deste tutorial, assumimos que você iniciou o
     7interpretador Sage usando o comando ``sage``. Isso inicia uma versão
     8personalizada da linha de comando IPython, e importa diversas funções
     9e classes de modo que elas fiquem prontas para serem usadas a partir
     10da linha de comando. Configuração adicional é possível editando o
     11arquivo ``$SAGE_ROOT/ipythonrc``. Assim que você inicia o Sage, você
     12obtém o seguinte:
     13
     14.. skip
     15
     16::
     17
     18    ----------------------------------------------------------------------
     19    | SAGE Version 3.1.1, Release Date: 2008-05-24                       |
     20    | Type notebook() for the GUI, and license() for information.        |
     21    ----------------------------------------------------------------------
     22    sage:
     23
     24Para sair do Sage pressione Ctrl-D ou digite ``quit`` ou ``exit``.
     25
     26.. skip
     27
     28::
     29
     30    sage: quit
     31    Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s)
     32
     33O wall time é o tempo que passou no relógio "pendurado na sua parede".
     34Isso é relevante, pois o tempo CPU não conta o tempo usado por
     35subprocessos como GAP ou Singular.
     36
     37(Evite terminar um processo do Sage usando ``kill -9`` a partir de um
     38terminal, pois o Sage pode não terminal seus subprocessos, por
     39exemplo, subprocessos do Maple, ou limpeza de arquivos temporários em
     40``$HOME/.sage/tmp``.)
     41
     42A Sua Sessão no Sage
     43====================
     44
     45A sessão é a sequência de entradas e saídas de dados desde o momento em
     46que você inicia até o momento em que você termina o Sage. O Sage grava
     47todas as entradas de dados, através do IPython. De fato, se você está
     48usando a linha de comando (não o Notebook), então a qualquer momento
     49você pode digitar ``%history`` (ou ``%hist``) para obter uma lista de
     50todas as linhas digitadas até então. Você pode digitar ``?`` no prompt
     51do Sage para aprender mais sobre o IPython, por exemplo, "IPython
     52offers numbered prompts ... with input and output caching. All input
     53is saved and can be retrieved as variables (besides the usual arrow
     54key recall). The following GLOBAL variables always exist (so don't
     55overwrite them!)":
     56
     57::
     58
     59      _:  previous input (interactive shell and notebook)
     60      __: next previous input (interactive shell only)
     61      _oh : list of all inputs (interactive shell only)
     62
     63Aqui vai um exemplo:
     64
     65.. skip
     66
     67::
     68
     69    sage: factor(100)
     70     _1 = 2^2 * 5^2
     71    sage: kronecker_symbol(3,5)
     72     _2 = -1
     73    sage: %hist   #This only works from the interactive shell, not the notebook.
     74    1: factor(100)
     75    2: kronecker_symbol(3,5)
     76    3: %hist
     77    sage: _oh
     78     _4 = {1: 2^2 * 5^2, 2: -1}
     79    sage: _i1
     80     _5 = 'factor(ZZ(100))\n'
     81    sage: eval(_i1)
     82     _6 = 2^2 * 5^2
     83    sage: %hist
     84    1: factor(100)
     85    2: kronecker_symbol(3,5)
     86    3: %hist
     87    4: _oh
     88    5: _i1
     89    6: eval(_i1)
     90    7: %hist
     91
     92Vamos omitir a numeração das linhas no restante deste tutorial e em
     93outras documentações do Sage.
     94
     95Você também pode salvar uma lista de comandos em uma macro.
     96
     97.. skip
     98
     99::
     100
     101    sage: E = EllipticCurve([1,2,3,4,5])
     102    sage: M = ModularSymbols(37)
     103    sage: %hist
     104    1: E = EllipticCurve([1,2,3,4,5])
     105    2: M = ModularSymbols(37)
     106    3: %hist
     107    sage: %macro em 1-2
     108    Macro `em` created. To execute, type its name (without quotes).
     109
     110
     111.. skip
     112
     113::
     114
     115    sage: E
     116    Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
     117    Rational Field
     118    sage: E = 5
     119    sage: M = None
     120    sage: em
     121    Executing Macro...
     122    sage: E
     123    Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
     124    Rational Field
     125
     126Quando se usa a linha de comando, qualquer comando UNIX pode ser
     127executado a partir do Sage inserindo um ponto de exclamação ``!`` como
     128prefixo. Por exemplo,
     129
     130.. skip
     131
     132::
     133
     134    sage: !ls
     135    auto  example.sage glossary.tex  t  tmp  tut.log  tut.tex
     136
     137fornece a lista de arquivos do atual diretório.
     138
     139O ``PATH`` possui o diretório bin do Sage em primeiro, portanto se
     140você digitar ``p``, ``gap``, ``singular``, ``maxima``, etc., você
     141executa a versão incluída no Sage.
     142
     143.. skip
     144
     145::
     146
     147    sage: !gp
     148    Reading GPRC: /etc/gprc ...Done.
     149   
     150                               GP/PARI CALCULATOR Version 2.2.11 (alpha)
     151                      i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version
     152    ...
     153    sage: !singular
     154                         SINGULAR                             /  Development
     155     A Computer Algebra System for Polynomial Computations   /   version 3-0-1
     156                                                           0<
     157         by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   October 2005
     158    FB Mathematik der Universitaet, D-67653 Kaiserslautern    \
     159
     160Gravando Entradas e Saídas de dados
     161===================================
     162
     163Gravar a sua sessão no Sage não é o mesmo que salvá-la (veja
     164:ref:`section-save`). Para gravar a entrada de dados (e opcionalmente
     165a saída) use o comando ``logstart``. Digite ``logstart?`` para mais
     166detalhes. Você pode usar esse comando para gravar tudo o que você
     167digita, toda a saída de dados, e até mesmo usar essa entrada de dados
     168que você guardou em uma sessão futura (simplesmente importando o
     169arquivo log).
     170
     171.. skip
     172
     173::
     174
     175    was@form:~$ sage
     176    ----------------------------------------------------------------------
     177    | SAGE Version 3.0.2, Release Date: 2008-05-24                       |
     178    | Type notebook() for the GUI, and license() for information.        |
     179    ----------------------------------------------------------------------
     180   
     181    sage: logstart setup
     182    Activating auto-logging. Current session state plus future input saved.
     183    Filename       : setup
     184    Mode           : backup
     185    Output logging : False
     186    Timestamping   : False
     187    State          : active
     188    sage: E = EllipticCurve([1,2,3,4,5]).minimal_model()
     189    sage: F = QQ^3
     190    sage: x,y = QQ['x,y'].gens()
     191    sage: G = E.gens()
     192    sage:
     193    Exiting SAGE (CPU time 0m0.61s, Wall time 0m50.39s).
     194    was@form:~$ sage
     195    ----------------------------------------------------------------------
     196    | SAGE Version 3.0.2, Release Date: 2008-05-24                       |
     197    | Type notebook() for the GUI, and license() for information.        |
     198    ----------------------------------------------------------------------
     199   
     200    sage: load "setup"
     201    Loading log file <setup> one line at a time...
     202    Finished replaying log file <setup>
     203    sage: E
     204    Elliptic Curve defined by y^2 + x*y  = x^3 - x^2 + 4*x + 3 over Rational
     205    Field
     206    sage: x*y
     207    x*y
     208    sage: G
     209    [(2 : 3 : 1)]
     210
     211Se você usa o Sage no terminal ``konsole`` do Linux KDE, então você
     212pode gravar a sessão da seguinte forma: após iniciar o Sage no
     213``konsole``, selecione "settings", então "history...", então "set
     214unlimited". Quando você estiver pronto para guardar a sua sessão,
     215selecione "edit" e então "save history as..." e digite um nome para
     216salvar o texto de sua sessão em seu computador. Após salvar esse
     217arquivo, você poderia abri-lô em um editor, tal como o xemacs, e
     218imprimi-lo.
     219
     220Colar Texto Ignora Prompts
     221==========================
     222
     223Suponha que você está lendo uma sequência de comandos em Sage ou
     224Python e quer copiá-los no Sage. Mas eles têm os irritantes prompts
     225``>>>`` ou ``sage:`` para te aborrecer. De fato, você pode copiar e
     226colar um exemplo, incluindo os prompts se você quiser, no Sage. Em
     227outras palavras, automaticamente o Sage remove os caracteres ``>>>``
     228ou ``sage:`` antes de colar o conteúdo no Python. Por exemplo,
     229
     230.. skip
     231
     232::
     233
     234    sage: 2^10
     235    1024
     236    sage: sage: sage: 2^10
     237    1024
     238    sage: >>> 2^10
     239    1024
     240
     241Comandos de Tempo
     242=================
     243
     244Se você colocar o comando ``%time`` no começo de uma linha de comando,
     245o tempo que o comando leva para ser executado vai aparecer após a
     246saída de dados. Por exemplo, nós podemos comparar o tempo de execução
     247para certas operações de exponenciação de várias formas. Os tempos
     248abaixo vão ser provavelmente muito diferentes para o seu computador,
     249ou até mesmo para versões diferentes do Sage. Primeiro, usando o
     250Python
     251
     252.. skip
     253
     254::
     255
     256    sage: %time a = int(1938)^int(99484)
     257    CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s
     258    Wall time: 0.66
     259
     260Isso significa que levou 0.66 segundos no total, e o wall time, isto
     261é, a quantidade de tempo que passou no seu relógio de parede, é também
     2620.66 segundos. Se o seu computador está executado outros programas o
     263wall time pode ser muito maior do que o tempo de CPU.
     264
     265A seguir verificamos o tempo de exponenciação usando o tipo Integer do
     266Sage, o qual é implementado (em Cython) usando a biblioteca GMP:
     267
     268.. skip
     269
     270::
     271
     272    sage: %time a = 1938^99484
     273    CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s
     274    Wall time: 0.04
     275
     276Usando a biblioteca C do PARI:
     277
     278.. skip
     279
     280::
     281
     282    sage: %time a = pari(1938)^pari(99484)
     283    CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s
     284    Wall time: 0.05
     285
     286A GMP é melhor, mas por pouco (como esperado, pois a versão do PARI
     287contida no Sage usa a GMP para aritmética de inteiros).
     288
     289Você pode também contar o tempo de um bloco de comandos usado o
     290comando ``cputime``, como ilustrado abaixo:
     291
     292::
     293
     294    sage: t = cputime()
     295    sage: a = int(1938)^int(99484)
     296    sage: b = 1938^99484
     297    sage: c = pari(1938)^pari(99484)
     298    sage: cputime(t)                       # somewhat random output
     299    0.64                                     
     300
     301.. skip
     302
     303::
     304
     305    sage: cputime?
     306    ...
     307        Return the time in CPU second since SAGE started, or with optional
     308        argument t, return the time since time t.
     309        INPUT:
     310            t -- (optional) float, time in CPU seconds
     311        OUTPUT:
     312            float -- time in CPU seconds
     313
     314O comando ``walltime`` se comporta como o comando ``cputime``, exceto
     315que ele conta o tempo do relógio.
     316
     317Nós podemos também calcular a potência acima em alguns softwares de
     318álgebra incluídos no Sage. Em cada caso executamos um comando trivial
     319no sistema de modo a inicializar o servidor para aquele programa. O
     320tempo mais relevante é o tempo do relógio. Todavia, se houver uma
     321diferença significativa entre o wall time e o CPU time então isso pode
     322indicar algum problema de performance que vale a pena investigar.
     323
     324.. skip
     325
     326::
     327
     328    sage: time 1938^99484;
     329    CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s
     330    Wall time: 0.01
     331    sage: gp(0)
     332    0
     333    sage: time g = gp('1938^99484')
     334    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     335    Wall time: 0.04
     336    sage: maxima(0)
     337    0
     338    sage: time g = maxima('1938^99484')
     339    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     340    Wall time: 0.30
     341    sage: kash(0)
     342    0
     343    sage: time g = kash('1938^99484')
     344    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     345    Wall time: 0.04
     346    sage: mathematica(0)
     347            0
     348    sage: time g = mathematica('1938^99484')
     349    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     350    Wall time: 0.03
     351    sage: maple(0)
     352    0
     353    sage: time g = maple('1938^99484')
     354    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     355    Wall time: 0.11
     356    sage: gap(0)
     357    0
     358    sage: time g = gap.eval('1938^99484;;')
     359    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
     360    Wall time: 1.02
     361
     362Note que o GAP e o Maxima são os mais lentos neste teste (isso foi
     363executado no computador ``sage.math.washington.edu``). Devido ao
     364"overhead" da interface pexpect, talvez não seja apropriado comparar
     365esses resultados com o Sage, que é o mais rápido.
     366
     367Outras Dicas para o IPython
     368===========================
     369
     370Como observado acima, o Sage usa o IPython como interface, logo você
     371pode usar quaisquer comandos e recursos do IPython. Você pode ler a
     372`Documentação completa do IPython
     373<http://ipython.scipy.org/moin/Documentation>`_ (em inglês).
     374
     375- Você pode usar ``%bg`` para executar um comando no background, e
     376  então usar ``jobs`` para acessar os resultados, da seguinte forma.
     377  (Os comentários ``not tested`` estão aqui porque a sintaxe ``%bg``
     378  não funciona bem com o sistema de testes automáticos do Sage. Se
     379  você digitar esses comandos, eles devem funcionar. Isso é obviamente
     380  mais útil com comandos que demoram para serem completados.)
     381
     382  ::
     383
     384    sage: def quick(m): return 2*m
     385    sage: %bg quick(20)  # not tested
     386    Starting job # 0 in a separate thread.
     387    sage: jobs.status()  # not tested
     388    Completed jobs:
     389    0 : quick(20)
     390    sage: jobs[0].result  # the actual answer, not tested
     391    40
     392
     393  Note que os comandos executados no background não usam o
     394  pre-processador (preparser) do Sage -- veja :ref:`section-mathannoy`
     395  para mais informações. Uma forma (estranha talvez) de contornar esse
     396  problema seria executar ::
     397
     398    sage: %bg eval(preparse('quick(20)')) # not tested
     399
     400  É mais seguro e simples, todavia, usar ``%bg`` apenas em comandos
     401  que não requerem o pre-processador (preparser).
     402
     403- Você pode usar ``%edit`` (ou ``%ed`` ou ``ed``) para abrir um
     404  editor, se você desejar digitar algum código mais complexo. Antes de
     405  iniciar o Sage, certifique-se de que a variável de environment
     406  :envvar:`EDITOR` está definida com o seu editor favorito (colocando
     407  ``export EDITOR=/usr/bin/emacs`` ou ``export EDITOR=/usr/bin/vim``
     408  or algo similar no lugar apropriado, como um arquivo ``.profile``).
     409  A partir do prompt do Sage, o comando ``%edit`` irá abrir o editor
     410  escolhido. Então usando o editor você pode definir uma função::
     411
     412    def some_function(n):
     413        return n**2 + 3*n + 2
     414
     415  Salve e feche o editor. No restante da sua sessão do Sage, você pode
     416  usar então a função ``some_function``. Se você quiser modificá-la,
     417  digite ``%edit some_function`` no prompt do Sage.
     418
     419- Se você for calcular algo e quiser modificar o resultado para outro
     420  uso, execute o cálculo e então digite ``%rep``: isso irá colocar o
     421  resultado do comando anterior no prompt do Sage, pronto para ser
     422  editado.::
     423
     424    sage: f(x) = cos(x)
     425    sage: f(x).derivative(x)
     426    -sin(x)
     427
     428  A esta altura, se você digitar ``%rep`` no prompt do Sage, você irá
     429  obter um novo prompt, seguido de ``-sin(x)``, com o cursor no final
     430  da linha.
     431
     432Para mais informações, digite ``%quickref`` para ver um guia rápido de
     433referência do IPython. Quando este tutorial foi escrito (April 2011),
     434o Sage usa a versão 0.9.1 do IPython, e a `documentation for its magic
     435commands <http://ipython.scipy.org/doc/rel-0.9.1/html/interactive/reference.html#magic-commands>`_
     436está disponível na internet.
     437
     438
     439Erros e Exceções
     440================
     441
     442Quando algo errado ocorre, você usualmente verá uma "exceção" do
     443Python. O Python até mesmo tenta sugerir o que ocasionou a exceção,
     444por exemplo, ``NameError`` ou ``ValueError`` (veja o Manual de
     445Referência do Python [Py]_ para uma lista completa de exceções). Por
     446exemplo,
     447
     448.. skip
     449
     450::
     451
     452    sage: 3_2
     453    ------------------------------------------------------------
     454       File "<console>", line 1
     455         ZZ(3)_2
     456               ^
     457    SyntaxError: invalid syntax
     458   
     459    sage: EllipticCurve([0,infinity])
     460    ------------------------------------------------------------
     461    Traceback (most recent call last):
     462    ...
     463    TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational
     464
     465O debugador interativo é as vezes útil para entender o que houve de
     466errado. Você pode ativá-lo e desativá-lo usando ``%pdb`` (o padrão é
     467desativado). O prompt ``ipdb>`` aparece se uma exceção é levantada e o
     468debugador está ativado. A partir do debugador, você pode imprimir o
     469estado de qualquer variável local, e mover a pilha de execução para
     470cima e para baixo. Por exemplo,
     471
     472.. skip
     473
     474::
     475
     476    sage: %pdb
     477    Automatic pdb calling has been turned ON
     478    sage: EllipticCurve([1,infinity])
     479    ---------------------------------------------------------------------------
     480    <type 'exceptions.TypeError'>             Traceback (most recent call last)
     481    ...
     482   
     483    ipdb>
     484
     485Para uma lista de comandos do debugador, digite ``?`` no prompt
     486``ipbd>``:
     487
     488::
     489
     490    ipdb> ?
     491   
     492    Documented commands (type help <topic>):
     493    ========================================
     494    EOF    break  commands   debug    h       l     pdef   quit    tbreak   
     495    a      bt     condition  disable  help    list  pdoc   r       u     
     496    alias  c      cont       down     ignore  n     pinfo  return  unalias
     497    args   cl     continue   enable   j       next  pp     s       up
     498    b      clear  d          exit     jump    p     q      step    w
     499    whatis where
     500   
     501    Miscellaneous help topics:
     502    ==========================
     503    exec  pdb
     504   
     505    Undocumented commands:
     506    ======================
     507    retval  rv
     508
     509Digite Ctrl-D ou ``quit`` para retornar ao Sage.
     510
     511.. _section-tabcompletion:
     512
     513Busca Reversa e Completamento Tab
     514==================================
     515
     516Busca reversa: Digite o começo de um comando, e então ``Ctrl-p`` (ou
     517tecle a seta para cima) para voltar para cada linha que você digitou
     518que começa daquela forma. Isso funciona mesmo se você encerrou o Sage
     519e iniciou novamente mais tarde. Você também pode fazer uma busca
     520reversa ao longo da história usando ``Ctrl-r``. Todos esses recursos
     521usam o pacote ``readline``, que está disponível no Linux.
     522
     523Para ilustrar a busca reversa, primeiro crie o e espaço vetorial
     524tri-dimensional :math:`V=\QQ^3` da seguinte forma:
     525
     526::
     527
     528    sage: V = VectorSpace(QQ,3)
     529    sage: V             
     530    Vector space of dimension 3 over Rational Field
     531
     532Você pode usar a seguinte notação mais compacta:
     533
     534::
     535
     536    sage: V = QQ^3
     537
     538Então é fácil listar todas as funções para :math:`V` usando
     539completamento. Digite ``V``, e então pressione a tecla ``[tab]`` no
     540seu teclado:
     541
     542.. skip
     543
     544::
     545
     546    sage: V.[tab key]
     547    V._VectorSpace_generic__base_field
     548    ...
     549    V.ambient_space
     550    V.base_field
     551    V.base_ring
     552    V.basis
     553    V.coordinates
     554    ...
     555    V.zero_vector
     556
     557Se você digitar as primeiras letras de uma função, e então a tecla
     558``[tab]``, você obtém apenas funções que começam conforme indicado.
     559
     560.. skip
     561
     562::
     563
     564    sage: V.i[tab key]
     565    V.is_ambient  V.is_dense    V.is_full     V.is_sparse
     566
     567Se você gostaria de saber o que uma função faz, por exemplo, a função
     568coordinates, digite ``V.coordinates?`` para ajuda ou
     569``V.coordinates??`` para ver o código fonte, como explicado na próxima
     570sessão.
     571
     572
     573
     574Sistema de Ajuda Integrado
     575==========================
     576
     577O Sage possui um sistema de ajuda integrado. Digite o nome da função
     578seguido de ? para ver informações sobre a função.
     579
     580.. skip
     581
     582::
     583
     584    sage: V = QQ^3
     585    sage: V.coordinates?
     586    Type:           instancemethod
     587    Base Class:     <type 'instancemethod'>
     588    String Form:    <bound method FreeModule_ambient_field.coordinates of Vector
     589    space of dimension 3 over Rational Field>
     590    Namespace:      Interactive
     591    File:           /home/was/s/local/lib/python2.4/site-packages/sage/modules/f
     592    ree_module.py
     593    Definition:     V.coordinates(self, v)
     594    Docstring:
     595        Write v in terms of the basis for self.
     596   
     597        Returns a list c such that if B is the basis for self, then
     598   
     599                sum c_i B_i = v.
     600   
     601        If v is not in self, raises an ArithmeticError exception.
     602   
     603        EXAMPLES:
     604            sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens()
     605            sage: W = M.submodule([M0 + M1, M0 - 2*M1])
     606            sage: W.coordinates(2*M0-M1)
     607            [2, -1]
     608
     609Como mostrado acima, o comando de ajuda mostra o tipo do objeto, o
     610arquivo no qual ele é definido, e uma descrição útil da função com
     611exemplos que você pode colar na sua sessão atual. Quase todos esses
     612exemplos são regularmente testados automaticamente para certificar que
     613eles se comportam exatamente como esperado.
     614
     615Outro recurso que vai muito na direção do espírito de código aberto do
     616Sage é que se ``f`` é uma função do Python, então o comando ``f??``
     617mostra o código fonte que define ``f``. Por exemplo,
     618
     619.. skip
     620
     621::
     622
     623    sage: V = QQ^3
     624    sage: V.coordinates??
     625    Type:           instancemethod
     626    ...
     627    Source:
     628    def coordinates(self, v):
     629            """
     630            Write $v$ in terms of the basis for self.
     631            ...
     632            """
     633            return self.coordinate_vector(v).list()
     634
     635Isso nos diz que tudo que a função ``coordinates`` faz é chamar a
     636função ``coordinate_vector`` e converter o resultado para uma lista. O
     637que a função ``coordinate_vector`` faz?
     638
     639.. skip
     640
     641::
     642
     643    sage: V = QQ^3
     644    sage: V.coordinate_vector??
     645    ...
     646    def coordinate_vector(self, v):
     647            ...
     648            return self.ambient_vector_space()(v)
     649
     650A função ``coordinate_vector`` coage a sua entrada em um espaço
     651ambiente, o que tem o efeito de calcular o vetor de coeficientes de
     652:math:`v` em termos de :math:`V`. O espaço :math:`V` já é o espaço
     653ambiente pois é simplesmente :math:`\QQ^3`. Existe também uma função
     654``coordinate_vector`` para subespaços, que é diferente. Vamos criar um
     655subespaço e ver:
     656
     657.. skip
     658
     659::
     660
     661    sage: V = QQ^3; W = V.span_of_basis([V.0, V.1])
     662    sage: W.coordinate_vector??
     663    ...
     664    def coordinate_vector(self, v):
     665            """
     666             ...
     667            """
     668            # First find the coordinates of v wrt echelon basis.
     669            w = self.echelon_coordinate_vector(v)
     670            # Next use transformation matrix from echelon basis to
     671            # user basis.
     672            T = self.echelon_to_user_matrix()
     673            return T.linear_combination_of_rows(w)
     674
     675(Se você acha que a implementação é ineficiente, por favor junte-se a
     676nós para ajudar a optimizar as funções de álgebra linear.)
     677
     678Você também pode digitar ``help(command_name)`` ou ``help(class)``
     679para ler um arquivo de ajuda sobre determinada classe.
     680
     681.. skip
     682
     683::
     684
     685    sage: help(VectorSpace)
     686    Help on class VectorSpace ...
     687   
     688    class VectorSpace(__builtin__.object)
     689     |  Create a Vector Space.
     690     |
     691     |  To create an ambient space over a field with given dimension
     692     |  using the calling syntax ...
     693     :
     694     :
     695
     696Quando você digita ``q`` para sair do sistema de ajuda, a sua sessão
     697aparece na tela da mesma forma que anteriormente. O texto de ajuda não
     698fica permanentemente em sua tela, ao contrário da saída de
     699``function_name?`` que as vezes fica. É partircularmente útil digitar
     700``help(module_name)``. Por exemplo, espaços vetoriais são definidos em
     701``sage.modules.free_module``, então digite
     702``help(sage.modules.free_module)`` para obter documentação sobre esse
     703módulo. Quando visualizando documentação usando a ajuda, você pode
     704procurar no texto digitando ``/`` e na ordem reversa digitando ``?``.
     705
     706Salvando e Carregando Objetos Individuais
     707=========================================
     708
     709Suponha que você calcule uma matriz, ou pior ainda, um espaço
     710complicado de símbolos, e gostaria de salvá-los para uso posterior. O
     711que você pode fazer? Existem várias estratégias que os sistemas
     712computacionais de álgebra adotam para salvar objetos individuais.
     713
     714#. **Salve seus cálculos:** Suportam apenas salvar e carregar uma
     715   sessão completa (por exemplo, GAP, Magma).
     716
     717#. **Entrada e Saída Unificadas:** Faz com que cada objeto seja
     718   impresso de uma forma que possa ser lido novamente (GP/PARI).
     719
     720#. **Eval:** Torna fácil processar um código arbitrário no
     721   interpretador (por exemplo, Singular, PARI).
     722
     723
     724
     725Como o Sage usa o Python, ele adota uma estratégia diferente, que se
     726baseia no fato de que qualquer objeto pode ser "serializado", isto é,
     727transformado em uma string a partir da qual o objeto pode ser
     728recuperado. Isso segue o espírito da estratégia unificada de entrada e
     729saída do PARI, exceto que não possue a desvantagem que os objetos são
     730impressos na tela em uma forma muito complicada. Além disso, o suporte
     731para salvar e recuperar é (na maior parte dos casos) completamente
     732automática, não requerendo nenhuma programação extra; é simplesmente um
     733recurso do Python que foi implementado na linguagem desde o início de
     734seu desenvolvimento.
     735
     736Quase todos os objetos ``x`` podem ser armazenados em disco de forma
     737comprimida usando ``save(x, filename)`` (ou em muitos casos
     738``x.save(filename)``). Para carregar o objeto de volta no Sage use
     739``load(filename)``.
     740
     741.. skip
     742
     743::
     744
     745    sage: A = MatrixSpace(QQ,3)(range(9))^2
     746    sage: A
     747    [ 15  18  21]
     748    [ 42  54  66]
     749    [ 69  90 111]
     750    sage: save(A, 'A')
     751
     752Você deve agora sair do Sage e reiniciá-lo. Então você pode obter
     753``A`` de volta:
     754
     755.. skip
     756
     757::
     758
     759    sage: A = load('A')
     760    sage: A
     761    [ 15  18  21]
     762    [ 42  54  66]
     763    [ 69  90 111]
     764
     765Você pode fazer o mesmo com objetos mais complicados, por exemplo,
     766curvas elípticas. Todos os dados sobre o objeto são guardados e
     767restaurados com o objeto. Por exemplo,
     768
     769.. skip
     770
     771::
     772
     773    sage: E = EllipticCurve('11a')
     774    sage: v = E.anlist(100000)              # takes a while
     775    sage: save(E, 'E')
     776    sage: quit
     777
     778A versão em disco de ``E`` ocupa 153 kilobytes, pois ela guarda os
     779primeiros 1000000 :math:`a_n` com ela.
     780
     781.. skip
     782
     783::
     784
     785    ~/tmp$ ls -l E.sobj
     786    -rw-r--r--  1 was was 153500 2006-01-28 19:23 E.sobj
     787    ~/tmp$ sage [...]
     788    sage: E = load('E')
     789    sage: v = E.anlist(100000)              # instant!
     790
     791(Em Python, salvar e restaurar é feito usando o módulo ``cPickle``. Em
     792particular, um objeto ``x`` do Sage pode ser salvado usando
     793``cPickle.dumps(x, 2)``. Note o ``2``!)
     794
     795O sage não pode salvar e carregar objetos criados em algum outro
     796sistema computacional de álgebra, por exemplo, GAP, Singular, Maxima,
     797etc. Eles são carregados em um estado "inválido". Em GAP, embora
     798muitos objetos podem ser impressos de uma forma que eles podem ser
     799reconstruídos, muitos não, logo reconstrução a partir de suas
     800representações impressas não é permitido.
     801
     802.. skip
     803
     804::
     805
     806    sage: a = gap(2)
     807    sage: a.save('a')
     808    sage: load('a')
     809    Traceback (most recent call last):
     810    ...
     811    ValueError: The session in which this object was defined is no longer
     812    running.
     813
     814Objetos do GP/PARI também podem ser salvados e carregados pois suas
     815representações em forma impressa são suficientes para reconstruí-los.
     816
     817.. skip
     818
     819::
     820
     821    sage: a = gp(2)     
     822    sage: a.save('a')
     823    sage: load('a')
     824    2
     825
     826Objetos que foram salvados podem ser abertos posteriormente em
     827computadores com arquiteturas e sistemas operacionais diferentes, por
     828exemplo, você poderia salvar uma matriz muito grande em um OS X de
     82932-bits e abri-lo em um Linux de 64-bits, encontrar a forma reduzida,
     830e movê-lo de volta. Além disso, em muitos casos você pode até mesmo
     831abrir objetos em versões do Sage diferentes daquela no qual o objeto
     832foi salvo, desde que o código para aquele objeto não seja muito
     833diferente. Todos os atributos do objetos são armazendos, assim como a
     834classe (mas não o código fonte) que define o objeto. Se aquela classe
     835não existir mais em uma nova versão do Sage, então o objeto não pode
     836ser reaberto nessa versão. Mas você poderia abri-lo em uma versão mais
     837antiga, obter o dicionário do objeto (com ``x.__dict__``), salvar o
     838dicionário, e abri-lo em uma versão mais nova.
     839
     840Salvando como Texto
     841-------------------
     842
     843Você também pode salvar a representação em texto (ASCII) de objetos em
     844um arquivo, simplesmente abrindo um arquivo em modo de escrita, e
     845escrevendo a string que representa o objeto no arquivo (você pode
     846salvar mais de um objeto dessa forma). Quando você terminar de
     847escrever os objetos, feche o arquivo.
     848
     849.. skip
     850
     851::
     852
     853    sage: R.<x,y> = PolynomialRing(QQ,2)
     854    sage: f = (x+y)^7
     855    sage: o = open('file.txt','w')
     856    sage: o.write(str(f))
     857    sage: o.close()
     858
     859.. _section-save:
     860
     861Salvando e Abrindo Sessões Completas
     862====================================
     863
     864O Sage é flexível para salvar e abrir sessões completas.
     865
     866O comando ``save_session(sessionname)`` salva todas as variáveis que
     867você definiu na sessão atual como um dicionário com o nome
     868``sessionname``. (No caso raro de uma variável não poder ser salva,
     869ela simplesmente não aparece no dicionário.) O resultado é um arquivo
     870``.sobj`` que pode ser aberto como qualquer outro objeto que foi
     871salvado. Quando você abre os objetos que foram salvados em uma sessão,
     872você obtém um dicionário cujas chaves (keys) são os nomes das
     873variáveis e os valores são os objetos.
     874
     875Você pode usar o comando ``load_session(sessionname)`` para carregar
     876na presente sessão as variáveis definidas em ``sessioname``. Note que
     877isso não remove as variáveis já definidas na presente sessão; em vez
     878disso, as duas sessões são combinadas.
     879
     880Primeiro iniciamos o Sage e definimos algumas variáveis.
     881
     882.. skip
     883
     884::
     885
     886    sage: E = EllipticCurve('11a')
     887    sage: M = ModularSymbols(37)
     888    sage: a = 389
     889    sage: t = M.T(2003).matrix(); t.charpoly().factor()
     890     _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2
     891
     892A seguir nós salvamos a nossa sessão, o que armazena cada uma das
     893variáveis acima em um arquivo. Então visualizamos o arquivo, que tem
     894por volta de 3K bytes.
     895
     896.. skip
     897
     898::
     899
     900    sage: save_session('misc')
     901    Saving a
     902    Saving M
     903    Saving t
     904    Saving E
     905    sage: quit
     906    was@form:~/tmp$ ls -l misc.sobj
     907    -rw-r--r--  1 was was 2979 2006-01-28 19:47 misc.sobj
     908
     909Por fim reiniciamos o Sage, definimos algumas variáveis extra, e
     910carregamos a sessão que foi salva anteriormente.
     911
     912.. skip
     913
     914::
     915
     916    sage: b = 19
     917    sage: load_session('misc')
     918    Loading a
     919    Loading M
     920    Loading E
     921    Loading t
     922
     923Cada variável que foi salva está de novo disponível. Além disso, a
     924variável ``b`` não foi redefinida.
     925
     926.. skip
     927
     928::
     929
     930    sage: M
     931    Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0
     932    and dimension 5 over Rational Field
     933    sage: E
     934    Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational
     935    Field
     936    sage: b
     937    19
     938    sage: a
     939    389
     940
     941
     942
     943.. _section-notebook:
     944
     945A Interface do Notebook
     946=======================
     947
     948O Sage Notebook é iniciado digitando
     949
     950.. skip
     951
     952::
     953
     954    sage: notebook()
     955
     956na linha de comando do Sage. Isso inicia o Notebook e abre o seu
     957browser padrão para visualizá-lo. Os arquivos de estado do servidor
     958são armazenados em ``$HOME/.sage/sage\_notebook``.
     959
     960Outras opções incluem:
     961
     962.. skip
     963
     964::
     965
     966    sage: notebook("directory")
     967
     968a qual inicia um novo servidor para o Notebook usando arquivos em um
     969dado diretório, em vez do diretório padrão
     970``$HOME/.sage/sage_notebook``. Isso pode ser útil se você quiser ter
     971uma coleção de folhas de trabalho (worksheets) associadas com um
     972projeto específico, ou executar vários Notebooks separadamente ao
     973mesmo tempo.
     974
     975Quando você inicia o Notebook, ele primeiro cria os seguintes arquivos
     976em ``$HOME/.sage/sage_notebook``:
     977
     978::
     979
     980    nb.sobj       (the notebook SAGE object file)
     981    objects/      (a directory containing SAGE objects)
     982    worksheets/   (a directory containing SAGE worksheets).
     983
     984Após criar os arquivos acima, o Notebook inicia o servidor web.
     985
     986Um "Notebook" é uma coleção de contas de usuário, cada qual pode ter
     987várias folhas de trabalho (worksheets). Quando você cria uma nova
     988folha de trabalho, os dados dela são armazenados no diretórios
     989``worksheets/username/number``. Em cada diretório desse há um arquivo
     990texto ``worksheet.txt`` - se algum problema ocorrer com as suas
     991folhas de trabalho, ou com o Sage, esse arquivo texto contém toda
     992informação necessária para reconstruir a folha de trabalho.
     993
     994A partir do Sage, digite ``notebook?`` para mais informações sobre
     995como iniciar um servidor.
     996
     997O seguinte diagrama ilustra a arquitetura do Notebook Sage:
     998
     999::
     1000
     1001    ----------------------
     1002    |                    |
     1003    |                    |
     1004    |   firefox/safari   |
     1005    |                    |
     1006    |     javascript     |
     1007    |      program       |
     1008    |                    |
     1009    |                    |
     1010    ----------------------
     1011          |      ^
     1012          | AJAX |
     1013          V      |
     1014    ----------------------
     1015    |                    |
     1016    |       sage         |                SAGE process 1
     1017    |       web          | ------------>  SAGE process 2    (Python processes)
     1018    |      server        |   pexpect      SAGE process 3
     1019    |                    |                    .
     1020    |                    |                    .
     1021    ----------------------                    .
     1022
     1023Para ajuda sobre as teclas de atalho disponíveis no Notebook, clique
     1024no link ``Help``.
  • new file doc/pt/tutorial/interfaces.rst

    diff --git a/doc/pt/tutorial/interfaces.rst b/doc/pt/tutorial/interfaces.rst
    new file mode 100644
    - +  
     1.. linkall
     2
     3**********
     4Interfaces
     5**********
     6
     7Uma característica central do Sage é que ele permite fazer cálculos
     8com objetos em vários sistemas de álgebra computacional usando uma
     9interface comum e uma linguagem de programação clara.
     10
     11Os métodos console e interact de uma interface executam tarefas bem
     12diferentes. Por exemplo, usando GAP:
     13
     14#. ``gap.console()``: Isso abre um console do GAP - o controle é
     15   transferido para o GAP. Aqui o Sage não é nada mais do que uma
     16   forma conveniente de executar um programa, similar à shell Bash do
     17   Linux.
     18
     19#. ``gap.interact()``: Essa é uma forma de interagir com uma instância
     20   do GAP que pode estar cheia de objetos do Sage. Você pode
     21   importar objetos nessa seção do GAP (até mesmo a partir da
     22   interface interativa), etc.
     23
     24
     25.. index: PARI; GP
     26
     27GP/PARI
     28=======
     29
     30O PARI é um programa em C muito compacto, maduro, e extremamente
     31otimizado cujo foco primário é teoria de números. Existem duas
     32interfaces distintas que podem ser usadas no Sage:
     33
     34
     35-  ``gp`` - o "**G** do **P** ARI" interpretador, e
     36
     37-  ``pari`` - a biblioteca C do PARI.
     38
     39Por exemplo, os seguintes comandos são duas formas de realizar a mesma
     40coisa. Eles parecem idênticos, mas o resultado é na verdade
     41diferente, e o que acontece por trás da cena é bastante diferente.
     42
     43::
     44
     45    sage: gp('znprimroot(10007)')
     46    Mod(5, 10007)
     47    sage: pari('znprimroot(10007)')
     48    Mod(5, 10007)
     49
     50No primeiro caso, uma cópia separada do interpretador GP é iniciada
     51como um servidor, e a string ``´znprimroot(10007)'`` é enviada,
     52calculada pelo GP, e o resultado é armazenado em uma variável no GP
     53(que ocupa espaço na memória dos processos do GP que não serão
     54liberados). Então o valor dessa variável é exibido. No segundo caso,
     55nenhum programa separado é iniciado, e a string
     56``´znprimroot(10007)'`` é calculada por uma certa função da biblioteca
     57C do PARI. O resultado é armazenado na memória em uso pelo Python, que
     58é liberada quando a variável não for mais referenciada. Os objetos
     59possuem tipos diferentes:
     60
     61::
     62
     63    sage: type(gp('znprimroot(10007)'))
     64    <class 'sage.interfaces.gp.GpElement'>
     65    sage: type(pari('znprimroot(10007)'))
     66    <type 'sage.libs.pari.gen.gen'>
     67
     68Então qual eu devo usar? Depende do que você está fazendo. A interface
     69GP pode fazer absolutamente tudo o que você poderia fazer na linha de
     70comando do GP/PARI, pois está simplesmente executando esse programa.
     71Em particular, você pode carregar programas complicados em PARI e
     72executá-los. Por outro lado, a interface do PARI (via a biblioteca C)
     73é muito mais restritiva. Primeiro, nem todas as funções foram
     74implementadas. Segundo, bastante código, por exemplo, envolvendo
     75integração numérica, não irá funcionar através da interface PARI.
     76Todavia, a interface PARI pode ser significamente mais rápida e mais
     77robusta do que a interface GP.
     78
     79(Se a interface GP ficar sem memória para calcular algum comando, ela
     80irá silenciosamente e automaticamente duplicar a memória alocada e
     81repetir o comando solicitado. Então os seus cálculos não irão ser
     82interrompidos se você não antecipou corretamente a quantidade de
     83memória que seria necessária. Esse é um truque útil que a interface
     84usual do GP não parece fornecer. Com respeito à interface da
     85biblioteca C do PARI, ela imediatamente copia cada objeto criado para
     86fora da pilha de memória, logo essa pilha nunca irá crescer. Contudo,
     87cada objeto não deve exceder 100MB de tamanho, ou a pilha irá estourar
     88quando o objeto for criado. Essa procedimento de cópia impõe uma leve
     89pena sobre a performace.)
     90
     91Em resumo, o Sage usa a biblioteca C do pari para fornecer
     92funcionalidade similar à fornecida pelo interpretador GP/PARI, exceto
     93que com um gerenciamento sofisticado de memória e a linguagem de
     94programação Python.
     95
     96Primeiro criamos uma lista do PARI a partir de uma lista do Python.
     97
     98::
     99
     100    sage: v = pari([1,2,3,4,5])
     101    sage: v
     102    [1, 2, 3, 4, 5]
     103    sage: type(v)
     104    <type 'sage.libs.pari.gen.gen'>
     105
     106Cada objeto do PARI é do tipo ``py_pari_gem``. O tipo PARI do objeto
     107subjacente pode ser obtido usando a função ``type``.
     108
     109::
     110
     111    sage: v.type()
     112    't_VEC'
     113
     114Em PARI, para criar uma curva elíptica digitamos
     115``ellinit([1,2,3,4,5])``. Em Sage é similar, exceto que ``ellnint`` é
     116um método que pode ser chamado em qualquer objeto do PARI, por
     117exemplo, ``t\_VEC v``.
     118
     119::
     120
     121    sage: e = v.ellinit()
     122    sage: e.type()         
     123    't_VEC'
     124    sage: pari(e)[:13]
     125    [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351]
     126
     127Agora que temos um objeto de curva elíptica, podemos calcular algumas
     128coisas a respeito dele.
     129
     130::
     131
     132    sage: e.elltors()
     133    [1, [], []]
     134    sage: e.ellglobalred()
     135    [10351, [1, -1, 0, -1], 1]
     136    sage: f = e.ellchangecurve([1,-1,0,-1])
     137    sage: f[:5]
     138    [1, -1, 0, 4, 3]
     139
     140.. index: GAP
     141
     142.. _section-gap:
     143
     144GAP
     145===
     146
     147O Sage vem com o GAP 4.4.10 para matemática discreta computacional,
     148especialmente teoria de grupos.
     149
     150Aqui está um exemplo com a função ``IdGroup`` do GAP, a qual usa a
     151base de dados opcional sobre grupos que precisa ser instalada
     152separadamente, como explicado abaixo.
     153
     154::
     155
     156    sage: G = gap('Group((1,2,3)(4,5), (3,4))')
     157    sage: G
     158    Group( [ (1,2,3)(4,5), (3,4) ] )
     159    sage: G.Center()
     160    Group( () )
     161    sage: G.IdGroup()    # requires optional database_gap package
     162    [ 120, 34 ]
     163    sage: G.Order()
     164    120
     165
     166Podemos realizar os mesmos cálculos no Sage sem explicitamente evocar
     167a interface do GAP da seguinte forma:
     168
     169::
     170
     171    sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]])
     172    sage: G.center()
     173    Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()]
     174    sage: G.group_id()     # requires optional database_gap package
     175    [120, 34]
     176    sage: n = G.order(); n
     177    120
     178
     179(Para alguns recursos adicionais do GAP, você deve instalar dois
     180pacotes opcionais. Digite ``sage -optional`` para uma lista e escolha
     181o pacote da forma ``gap\_packages-x.y.z``, então digite ``sage -i
     182gap\_packages-x.y.z``. Faça o mesmo para ``database\_gap-x.y.z``.
     183Alguns pacotes do GAP sem licensa GPL podem ser obtidos no site do GAP
     184[GAPkg]_, e copiados em ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg``.)
     185
     186Singular
     187========
     188
     189O Singular fornece uma biblioteca massiva e madura para bases de
     190Gröbner, máximo divisor comum para poliômios em várias variaveis,
     191bases de espaços de Riemann-Roch de uma curva plana, e fatorização,
     192entre outras coisas. Vamos ilustrar a fatorização de polinômios em
     193várias variáveis usando a interface do Sage para o Singular (não
     194digite ``...``):
     195
     196::
     197
     198    sage: R1 = singular.ring(0, '(x,y)', 'dp')
     199    sage: R1
     200    //   characteristic : 0
     201    //   number of vars : 2
     202    //        block   1 : ordering dp
     203    //                  : names    x y
     204    //        block   2 : ordering C
     205    sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \
     206    ...   9*x^6*y^4 + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - \
     207    ...   9*x^12*y^3 - 18*x^13*y^2 + 9*x^16')
     208
     209Agora que definimos :math:`f`, vamos imprimi-lo e fatorá-lo.
     210
     211::
     212
     213    sage: f
     214    9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
     215    sage: f.parent()
     216    Singular
     217    sage: F = f.factorize(); F
     218    [1]:
     219       _[1]=9
     220       _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
     221       _[3]=-x^5+y^2
     222    [2]:
     223       1,1,2
     224    sage: F[1][2]
     225    x^6-2*x^3*y^2-x^2*y^3+y^4
     226
     227Como com o exemplo para o GAP em :ref:`section-gap`, podemos calcular
     228a fatorização acima sem explicitamente usar a inteface do Singular
     229(todavia, implicitamente o Sage usa a interface do Singular para os
     230cálculos). Não digite ``...``:
     231
     232::
     233
     234    sage: x, y = QQ['x, y'].gens()
     235    sage: f = 9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + 9*x^6*y^4\
     236    ...   + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - 9*x^12*y^3\
     237    ...   - 18*x^13*y^2 + 9*x^16
     238    sage: factor(f)
     239    (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4)
     240
     241.. _section-maxima:
     242
     243Maxima
     244======
     245
     246O Maxima está incluido no Sage, assim como uma implementação do Lisp.
     247O pacote gnuplot (que o Maxima usa para criar gráficos) é distribuído
     248como um pacote adicional do Sage. Entre outras coisas, o Maxima
     249executa manipulações simbólicas. Ele pode integrar e diferenciar
     250funções simbolicamente, resolver EDOs de primeira ordem, grande parte
     251das EDOs lineares de segunda ordem, e tem implementado o método da
     252transformada de Laplace para EDOs lineares de qualquer ordem. O Maxima
     253também suporta uma série de funções especiais, é capaz de criar
     254gráficos via gnuplot, e possui métodos para resolver equações
     255polinômiais e manipular matrizes (por exemplo, escalonar e calcular
     256autovalores e autovetores).
     257
     258Nós ilustramos a interface Sage/Maxima construíndo uma matriz cuja
     259entrada :math:`i,j` é :math:`i/j`, para :math:`i,j=1,\ldots,4`.
     260
     261::
     262
     263    sage: f = maxima.eval('ij_entry[i,j] := i/j')
     264    sage: A = maxima('genmatrix(ij_entry,4,4)'); A
     265    matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
     266    sage: A.determinant()
     267    0
     268    sage: A.echelon()
     269    matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0])
     270    sage: A.eigenvalues()
     271    [[0,4],[3,1]]
     272    sage: A.eigenvectors()
     273    [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]]
     274
     275Aqui vai outro exemplo:
     276
     277::
     278
     279    sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])")
     280    sage: eigA = A.eigenvectors()
     281    sage: V = VectorSpace(QQ,3)
     282    sage: eigA
     283    [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]]
     284    sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0]
     285    sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1]
     286    sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2]
     287   
     288    sage: M = MatrixSpace(QQ,3,3)
     289    sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]])
     290    sage: b1 = v1.base_ring()
     291    sage: AA*v1 == b1(lambda1)*v1
     292    True
     293    sage: b2 = v2.base_ring()
     294    sage: AA*v2 == b2(lambda2)*v2
     295    True
     296    sage: b3 = v3.base_ring()
     297    sage: AA*v3 == b3(lambda3)*v3
     298    True
     299
     300Por fim, apresentamos um exemplo de como usar o Sage para criar
     301gráficos usando ``openmath``. Alguns desses exemplos são modificações
     302de exemplos do manual de referência do Maxima.
     303
     304Um gráfico em duas dimensões de diversas funções (não digite ``...``):
     305
     306::
     307
     308    sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]',\
     309    ...   '[plot_format,openmath]') # not tested
     310
     311Um gráfico em 3D que você pode mover com o seu mouse:
     312
     313::
     314
     315    sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]",\
     316    ...   '[plot_format, openmath]') # not tested
     317    sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]",\
     318    ...   "[grid, 50, 50]",'[plot_format, openmath]') # not tested
     319
     320O próximo gráfico é a famosa faixa de Möbious:
     321
     322::
     323
     324    sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)),\
     325    ...   y*sin(x/2)]", "[x, -4, 4]", "[y, -4, 4]",\
     326    ...   '[plot_format, openmath]') # not tested
     327
     328E agora a famosa garrafa de Klein:
     329
     330::
     331
     332    sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\
     333    ...   - 10.0")
     334    5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0
     335    sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)")
     336    -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)
     337    sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))")
     338    5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y))
     339    sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]",\
     340    ...   "[y, -%pi, %pi]", "['grid, 40, 40]",\
     341    ...   '[plot_format, openmath]') # not tested
  • new file doc/pt/tutorial/introduction.rst

    diff --git a/doc/pt/tutorial/introduction.rst b/doc/pt/tutorial/introduction.rst
    new file mode 100644
    - +  
     1**********
     2Introdução
     3**********
     4
     5Este tutorial leva no máximo de 3 a 4 horas para ser percorrido. Você
     6pode lê-lo em versão HTML ou PDF, ou a partir do Notebook Sage (clique
     7em ``Help``, então clique em ``Tutorial`` para percorrer o tutorial de
     8forma interativa).
     9
     10Embora grande parte do Sage seja implementado em Python, nenhum
     11conhecimento de Python é necessário para a leitura deste tutorial.
     12Você vai querer aprender Python (uma linguagem muito divertida!) em
     13algum momento, e existem diversas opções gratuitas disponíveis para
     14isso, entre elas [PyT]_ e [Dive]_ (em inglês). Se você quiser
     15experimentar o Sage rapidamente, este tutorial é o lugar certo para
     16começar. Por exemplo:
     17
     18::
     19
     20    sage: 2 + 2
     21    4
     22    sage: factor(-2007)
     23    -1 * 3^2 * 223
     24
     25    sage: A = matrix(4,4, range(16)); A
     26    [ 0  1  2  3]
     27    [ 4  5  6  7]
     28    [ 8  9 10 11]
     29    [12 13 14 15]
     30
     31    sage: factor(A.charpoly())
     32    x^2 * (x^2 - 30*x - 80)
     33
     34    sage: m = matrix(ZZ,2, range(4))
     35    sage: m[0,0] = m[0,0] - 3
     36    sage: m
     37    [-3  1]
     38    [ 2  3]
     39
     40    sage: E = EllipticCurve([1,2,3,4,5]);
     41    sage: E
     42    Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5
     43    over Rational Field
     44    sage: E.anlist(10)
     45    [0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3]
     46    sage: E.rank()
     47    1
     48
     49    sage: k = 1/(sqrt(3)*I + 3/4 + sqrt(73)*5/9); k
     50    1/(I*sqrt(3) + 5/9*sqrt(73) + 3/4)
     51    sage: N(k)
     52    0.165495678130644 - 0.0521492082074256*I
     53    sage: N(k,30)      # 30 "bits"
     54    0.16549568 - 0.052149208*I
     55    sage: latex(k)
     56    \frac{1}{i \, \sqrt{3} + \frac{5}{9} \, \sqrt{73} + \frac{3}{4}}
     57
     58.. _installation:
     59
     60Instalação
     61==========
     62
     63Se você não tem o Sage instalado em um computador e quer apenas
     64experimentar alguns comandos, use o Sage através do site
     65http://www.sagenb.org.
     66
     67Veja o guia de instalação do Sage na seção de documentação na página
     68principal do Sage [SA]_ para instruções de como instalar o Sage no seu
     69computador. Aqui faremos apenas alguns comentários.
     70
     71#. O arquivo para download do Sage vem com "baterias incluídas". Em
     72   outras palavras, embora o Sage use o Python, IPython, PARI, GAP,
     73   Singular, Maxima, NTL, GMP, e uma série de outros programas, você
     74   não precisa instalá-los separadamente pois eles estão incluídos no
     75   Sage. Todavia, para usar alguns recursos, por exemplo, o Macaulay
     76   ou o KASH, você precisa instalar pacotes de software adicionais ou
     77   ter os programas necessários já instalados no seu computador. O
     78   Macaulay e o KASH estão disponíveis como pacotes adicionais do Sage
     79   (para uma lista de pacotes adicionais, digite ``sage -optional``,
     80   ou visite a seção "Download" na página do Sage na internet).
     81
     82#. A versão pré-compilada do Sage (disponível na página do Sage na
     83   internet) pode ser mais fácil e rápida para instalar do que a
     84   versão obtida compilando o código fonte.
     85
     86#. Se você quiser usar o pacote SageTeX (que permite inserir
     87   cálculos do Sage em um arquivo LaTeX), você deve tornar
     88   o SageTex disponível para a sua distribuição TeX. Para fazer isso,
     89   consulte a seção "Make SageTex known to TeX" no `Sage installation
     90   guide <http://www.sagemath.org/doc/>`_. O procedimento é bem
     91   simples; você precisa apenas definir algumas variáveis no seu
     92   sistema ou copiar um arquivo para um diretório onde o TeX poderá
     93   encontrá-lo.
     94
     95   A documentação para usar o SageTex está disponível em
     96   ``$SAGE_ROOT/local/share/texmf/tex/generic/sagetex/``, onde
     97   ``$SAGE_ROOT`` refere-se ao diretório onde você instalou o Sage
     98   -- por exemplo, ``/opt/sage-4.2.1``.
     99
     100Formas de usar o Sage
     101=====================
     102
     103Você pode usar o Sage de diversas formas.
     104
     105
     106-  **Interface gráfica Notebook:** veja a seção sobre o Notebook em
     107   :ref:`section-notebook`,
     108
     109-  **Linha de comando interativa:** veja
     110   :ref:`chapter-interactive_shell`,
     111
     112-  **Programas:** escrevendo programas interpretados e compilados em
     113   Sage (veja :ref:`section-loadattach` e :ref:`section-compile`), e
     114
     115-  **Scripts:** escrevendo scripts em Python que usam a biblioteca do
     116   Sage (veja :ref:`section-standalone`).
     117
     118
     119Objetivos do Sage a longo prazo
     120===============================
     121
     122-  **Útil**: O público alvo do Sage são estudantes de matemática
     123   (desde o ensino médio até a pós-graduação), professores, e
     124   pesquisadores em matemática. O objetivo é fornecer um software que
     125   possa ser usado para explorar e experimentar construções matemáticas
     126   em álgebra, geometria, teoria de números, cálculo, computação
     127   numérica, etc. O Sage torna mais fácil a experimentação com objetos
     128   matemáticos de forma interativa.
     129
     130-  **Eficiente:** Ser rápido. O Sage usa software bastante otimizado
     131   como o GMP, PARI, GAP, e NTL, e portanto é muito rápido em certas
     132   operações.
     133
     134-  **Gratuito e de código aberto:** O código fonte deve ser amplamente
     135   disponível e legível, de modo que os usuários possam entender o que
     136   o software realmente faz e possam facilmente estendê-lo. Da mesma
     137   forma que matemáticos ganham entendimento sobre um teorema lendo
     138   cuidadosamente a sua demonstração, as pessoas que fazem cálculos
     139   deveriam poder entender como os cálculos são feitos lendo o código
     140   fonte e seus comentários. Se você usar o Sage para fazer cálculos em
     141   um artigo que seja publicado, você pode ter certeza que os leitores
     142   sempre terão livre acesso ao Sage e seu código fonte, e você tem até
     143   mesmo permissão para arquivar e redistribuir a versão do Sage que
     144   você utilizou.
     145
     146-  **Fácil de compilar:** O Sage deve ser fácil de compilar a partir
     147   do código fonte para usuários de Linux, OS X e Windows. Isso
     148   fornece mais flexibilidade para os usuários modificarem o sistema.
     149
     150-  **Cooperação:** Fornecer uma interface robusta para outros sistemas
     151   computacionais, incluindo PARI, GAP, Singular, Maxima, KASH, Magma,
     152   Maple e Mathematica. O Sage foi concebido para unificar e estender
     153   outros softwares de matemática existentes.
     154
     155-  **Bem documentado:** Tutorial, guia de programação, manual de
     156   referência, e how-to, com inúmeros exemplos e discussão sobre
     157   conceitos matemáticos relacionados.
     158
     159-  **Estensível:** Ser capaz de definir novos tipos de dados ou
     160   derivá-los a partir dos tipos de dados existentes, e usar programas
     161   escritos em diversas outras linguagens.
     162
     163-  **Fácil de usar:** Deve ser fácil entender quais recursos estão
     164   disponíveis para um determinado objeto e consultar a documentação e
     165   o código fonte.
  • new file doc/pt/tutorial/latex.rst

    diff --git a/doc/pt/tutorial/latex.rst b/doc/pt/tutorial/latex.rst
    new file mode 100644
    - +  
     1*********************************
     2Sage, LaTeX e Companheiros
     3*********************************
     4
     5AUTOR:  Rob Beezer (2010-05-23)
     6
     7O Sage e o dialeto LaTeX do TeX tem um relacionamento sinergético
     8intenso. Esta seção tem como objetivo introduzir as diversas formas de
     9interação entre eles, começado pelas mais básicas e indo até as menos
     10usuais. (Logo você pode não querer ler esta seção inteira na sua
     11primeira passagem por este tutorial.)
     12
     13Panorama Geral
     14==============
     15
     16Pode ser mais fácil entender os vários usos do LaTeX com um panorama
     17geral sobre os três principais métodos usados pelo Sage.
     18
     19#. Todo objeto no Sage possui uma representação em LaTeX. Você
     20   pode acessar essa representação executando, no Notebook ou na
     21   linha de comando do Sage, ``latex(foo)`` where ``foo`` é algum
     22   objeto no Sage. O resultado é uma string que deve fornecer uma
     23   representação razoável de ``foo`` no modo matemático em LaTeX
     24   (por exemplo, quando cercado por um par de símbolos $). Alguns
     25   exemplos disso seguem abaixo.
     26
     27   Dessa forma, o Sage pode ser usado efetivamente para construir
     28   partes de um documento LaTeX: crie ou calcule um objeto no
     29   Sage, imprima ``latex()`` do objeto e copie-e-cole o resultado
     30   no seu documento.
     31
     32#. A interface Notebook é configurada para usar o `jsMath
     33   <http://www.math.union.edu/~dpvc/jsMath/>`_ para representar
     34   fórmulas matemáticas de forma clara em um web browser. O jsMath é
     35   uma coleção de rotinas em JavaScript e fontes associadas.
     36   Tipicamente esses fontes ficam armazenadas em um servidor e são
     37   enviadas para o browser juntamente com a página onde elas estão
     38   sendo usadas. No caso do Sage, o Notebook está sempre conectado a
     39   um servidor usado para executar os comando do Sage, e esse servidor
     40   também fornece as fontes do jsMath necessárias. Logo não é
     41   necessário configurar nada mais para ter formulas matemáticas
     42   representadas no seu browser quando você usa o Notebook do Sage.
     43
     44   O jsMath é implementado para representar um subconjunto grande,
     45   mas não completo, do TeX. Ele não suporta objetos como, por
     46   exemplo, tabelas complicadas e seções, e é focado para
     47   representar acuradamente pequenas fórmulas em TeX. A
     48   representação automática de fórmulas matemáticas no Notebook é
     49   obtida convertendo a representação ``latex()`` de um objeto
     50   (como descrito acima) em uma forma de HTML mais adequada ao
     51   jsMath.
     52
     53   Como o jsMath usa as suas próprias fontes de tamanho variável,
     54   ele é superior a outros métodos que convertem equações, ou
     55   outros pequenos trechos de TeX, em imagens estáticas.
     56
     57   O jsMath muito provavelmente vai ser substituído pelo MathJAX,
     58   uma tecnologia similar do mesmo autor, que possui suporte
     59   extenso de editoras técnicas e sociedades profissionais.
     60
     61#. Na linha de comando do Sage, ou no Notebook quando o código em
     62   LaTeX é complicado demais para o jsMath processar, uma
     63   instalação local do LaTeX pode ser usada. O Sage inclui quase
     64   tudo que você precisa para compilar e usar o Sage, mas uma
     65   exceção significativa é o TeX. Então nessas situações você
     66   precisa ter o TeX instalado, juntamente com algumas ferramentas
     67   de conversão, para usar os recursos completos.
     68
     69Aqui nós demonstramos alguns usos básicos da função ``latex()``. ::
     70
     71    sage: var('z')
     72    z
     73    sage: latex(z^12)
     74    z^{12}
     75    sage: latex(integrate(z^4, z))
     76    \frac{1}{5} \, z^{5}
     77    sage: latex('a string')
     78    \verb|a|\phantom{x}\verb|string|
     79    sage: latex(QQ)
     80    \Bold{Q}
     81    sage: latex(matrix(QQ, 2, 3, [[2,4,6],[-1,-1,-1]]))
     82    \left(\begin{array}{rrr}
     83    2 & 4 & 6 \\
     84    -1 & -1 & -1
     85    \end{array}\right)
     86
     87A funcionalidade básica do jsMath é em sua maior parte automática no
     88Notebook, mas nós podemos demonstrar esse suporte parcialmente com a
     89classe ``jsMath``. A função ``eval`` dessa classe converte um objeto
     90do Sage em sua representação LaTeX e adiciona HTML que por sua vez
     91evoca a classe "matemática" do CSS, a qual então emprega o jsMath. ::
     92
     93    sage: from sage.misc.latex import JSMath
     94    sage: js = JSMath()
     95    sage: var('z')
     96    z
     97    sage: js(z^12)
     98    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}z^{12}</div></html>
     99    sage: js(QQ)
     100    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html>
     101    sage: js(ZZ[x])
     102    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Z}[x]</div></html>
     103    sage: js(integrate(z^4, z))
     104    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\frac{1}{5} \, z^{5}</div></html>
     105
     106Uso Básico
     107==========
     108
     109Como indicado acima, a forma mais simples de explorar o suporte do
     110Sage para o LaTeX é usando a função ``latex()`` para criar código
     111LaTeX para representar objetos matemáticos. Essas strings podem então
     112ser incorporadas em documentos LaTeX. Isso funciona igualmente no
     113Notebook ou na linha de comando do Sage.
     114
     115No outro extremo está o comando ``view()``. Na linha de comando do
     116Sage o comando ``view(foo)`` irá criar a representação em LaTeX de
     117``foo``, incorporar isso em um documento simples em LaTeX, e então
     118processar o documento usando o LaTeX em seu sistema. Por fim, o
     119visualizador apropriado será aberto para apresentar o documento
     120gerado. Qual versão do TeX é usada, e portanto as opções para a saída
     121e visualizador, podem ser personalizados (veja
     122:ref:`sec-custom-processing`).
     123
     124No Notebook, o comando ``view(foo)`` cria uma combinação apropriada de
     125HTML e CSS para que o jsMath mostre a representação em LaTeX na folha
     126de trabalho. Para o usuário, ele simplesmente cria uma versão
     127cuidadosamente formatada do resultado, distinta da saída padrão em
     128modo texto do Sage. Nem todo objeto no Sage possui uma representação
     129em LaTeX adequada às capacidades limitadas do jsMath. Nesses casos, a
     130interpretação pelo jsMath pode ser deixada de lado, e com isso o LaTeX
     131do sistema é chamado, e o resultado dessa chamada é convertido em uma
     132imagem que é inserida na folha de trabalho. Como alterar e controlar
     133esse processo é discutido abaixo na seção
     134:ref:`sec-custom-generation`.
     135
     136O comando interno ``pretty_print()`` ilustra a conversão de objetos do
     137Sage para HTML que emprega o jsMath no Notebook. ::
     138
     139    sage: from sage.misc.latex import pretty_print
     140    sage: pretty_print(x^12)
     141    <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}x^{12}</span></html>
     142    sage: pretty_print(integrate(sin(x), x))
     143    <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}-\cos\left(x\right)</span></html>
     144
     145O Notebook tem outros dois recursos para empregar o TeX. O primeiro é
     146o botão "Typeset" bem acima da primeira célula da folha de trabalho, à
     147direita dos quatro menus de opções. Quando selecionado, o resultado de
     148qualquer cálculo vai ser interpretado pelo jsMath. Note que esse
     149efeito não é retroativo -- células calculadas anteriormente precisam
     150ser recalculadas para ter o resultado representado pelo jsMath.
     151Essencialmente, selecionar o botão "Typeset" é equivalente a aplicar o
     152comando ``view()`` ao resultado de cada célula.
     153
     154Um segundo recurso disponível no Notebook é possibilidade de inserir
     155código TeX para fazer anotações na folha de trabalho. Quando o cursos
     156esta posicionado entre células de modo que uma barra azul fica
     157visível, então shift-click irá abrir um mini processador de texto,
     158TinyMCE. Isso permite digitar texto, usando um editor WSISYG para
     159criar HTML e CSS. Logo é possível inserir texto formatado para
     160complementar a folha de trabalho. Todavia, texto entre símbolos $, ou
     161$$, é interpretado pelo jsMath como "inline" ou "display math"
     162espectivamente.
     163
     164.. _sec-custom-generation:
     165
     166Personalizando a Criação de Código LaTeX
     167========================================
     168
     169Exitem várias formas de personalizar o código LaTeX gerado pelo
     170comando ``latex()``. No Notebook e na linha de comando existe um
     171objeto pré-definido chamado ``latex`` que possui diversos métodos, os
     172quais você pode listar digitando ``latex.``, seguido da tecla tab
     173(note a presença do ponto).
     174
     175Um bom exemplo é o método ``latex.matrix_delimiters``. Ele pode ser
     176usado para alterar a notação de matrizes -- parênteses grandes,
     177colchetes, barras verticais. Nenhuma noção de estilo é enfatizada,
     178você pode configurar como desejado. Observe como as barras invertidas
     179usadas em LaTeX requerem uma barra adicional de modo que elas possam
     180ser interpretadas (escaped) corretamente em uma string do Python. ::
     181
     182    sage: A = matrix(ZZ, 2, 2, range(4))
     183    sage: latex(A)
     184    \left(\begin{array}{rr}
     185    0 & 1 \\
     186    2 & 3
     187    \end{array}\right)
     188    sage: latex.matrix_delimiters(left='[', right=']')
     189    sage: latex(A)
     190    \left[\begin{array}{rr}
     191    0 & 1 \\
     192    2 & 3
     193    \end{array}\right]
     194    sage: latex.matrix_delimiters(left='\\{', right='\\}')
     195    sage: latex(A)
     196    \left\{\begin{array}{rr}
     197    0 & 1 \\
     198    2 & 3
     199    \end{array}\right\}
     200
     201O método ``latex.vector_delimiters`` funciona de forma similar.
     202
     203A forma como anéis e corpos comuns podem ser representados pode ser
     204controlada pelo método ``latex.blackboard_bold``. Esses conjuntos são
     205representados por padrão em negrito, mas podem opcionalmente ser
     206escritos em letras duplas como é comum em trabalhos escritos. Isso é
     207obtido redefinindo a macro ``\Bold{}`` que faz parte do Sage. ::
     208
     209    sage: latex(QQ)
     210    \Bold{Q}
     211    sage: from sage.misc.latex import JSMath
     212    sage: js=JSMath()
     213    sage: js(QQ)
     214    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html>
     215    sage: latex.blackboard_bold(True)
     216    sage: js(QQ)
     217    <html><div class="math">\newcommand{\Bold}[1]{\mathbb{#1}}\Bold{Q}</div></html>
     218    sage: latex.blackboard_bold(False)
     219
     220É possível aproveitar os recursos do TeX adicionando novas macros e
     221novos pacotes. Primeiro, macros individuais podem ser adicionadas para
     222serem usadas quando o jsMath interpreta pequenos trechos de códigos
     223TeX no Notebook. ::
     224
     225    sage: latex.extra_macros()
     226    ''
     227    sage: latex.add_macro("\\newcommand{\\foo}{bar}")
     228    sage: latex.extra_macros()
     229    '\\newcommand{\\foo}{bar}'
     230    sage: var('x y')
     231    (x, y)
     232    sage: latex(x+y)
     233    x + y
     234    sage: from sage.misc.latex import JSMath
     235    sage: js=JSMath()
     236    sage: js(x+y)
     237    <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\newcommand{\foo}{bar}x + y</div></html>
     238
     239Macros adicionais usadas dessa forma serão também usadas eventualmente
     240se a versão do TeX no seu sistema for usada para lidar com algo muito
     241complicado para o jsMath. O comando ``latex_extra_preamble`` é usado
     242para construir o preambulo de um documento completo em LaTeX.
     243Ilustramos a seguir como fazer isso. Novamente note a necessidade de
     244barras invertidas duplas nas strings do Python. ::
     245
     246
     247    sage: latex.extra_macros('')
     248    sage: latex.extra_preamble('')
     249    sage: from sage.misc.latex import latex_extra_preamble
     250    sage: print latex_extra_preamble()
     251    \newcommand{\ZZ}{\Bold{Z}}
     252    ...
     253    \newcommand{\Bold}[1]{\mathbf{#1}}
     254    sage: latex.add_macro("\\newcommand{\\foo}{bar}")
     255    sage: print latex_extra_preamble()
     256    \newcommand{\ZZ}{\Bold{Z}}
     257    ...
     258    \newcommand{\Bold}[1]{\mathbf{#1}}
     259    \newcommand{\foo}{bar}
     260
     261Novamente, para expressões grandes ou mais complicadas do LaTeX, é
     262possível adicionar pacotes (ou qualquer outra coisa) ao preambulo do
     263arquivo LaTeX. Qualquer coisa pode ser incorporada no preambulo com o
     264comando ``latex.add_to_preamble``, e o comando mais especializado
     265``latex.add_package_to_preamble_if_available`` irá primeiro verificar
     266se certo pacote está realmente disponível antes de adicioná-lo ao
     267preambulo
     268
     269Agora adicionamos o pacote geometry ao preambulo e usamos ele para
     270definir o tamanho da região na página que o TeX vai usar
     271(efetivamente definido as margens). Novamente, observe a necessidade
     272de barras duplas nas strings do Python. ::
     273
     274
     275    sage: from sage.misc.latex import latex_extra_preamble
     276    sage: latex.extra_macros('')
     277    sage: latex.extra_preamble('')
     278    sage: latex.add_to_preamble('\\usepackage{geometry}')
     279    sage: latex.add_to_preamble('\\geometry{letterpaper,total={8in,10in}}')
     280    sage: latex.extra_preamble()
     281    '\\usepackage{geometry}\\geometry{letterpaper,total={8in,10in}}'
     282    sage: print latex_extra_preamble()
     283    \usepackage{geometry}\geometry{letterpaper,total={8in,10in}}
     284    \newcommand{\ZZ}{\Bold{Z}}
     285    ...
     286    \newcommand{\Bold}[1]{\mathbf{#1}}
     287
     288Um pacote pode ser adicionado juntamente com a verificação de sua
     289existência, da seguinte forma. Como um exemplo, nós ilustramos uma
     290tentativa de adicionar ao preambulo um pacote que supostamente não
     291existe. ::
     292
     293    sage: latex.extra_preamble('')
     294    sage: latex.extra_preamble()
     295    ''
     296    sage: latex.add_to_preamble('\\usepackage{foo-bar-unchecked}')
     297    sage: latex.extra_preamble()
     298    '\\usepackage{foo-bar-unchecked}'
     299    sage: latex.add_package_to_preamble_if_available('foo-bar-checked')
     300    sage: latex.extra_preamble()
     301    '\\usepackage{foo-bar-unchecked}'
     302
     303.. _sec-custom-processing:
     304
     305Personalizando o Processamento em LaTeX
     306=======================================
     307
     308É também possível controlar qual variação do TeX é usada quando a
     309versão do sistema for evocada, logo influenciando também o resultado.
     310De forma similar, é também possível controlar quando o Notebook irá
     311usar o jsMath (trechos simples em TeX) ou a versão do TeX do sistema
     312(expressões mais complicadas).
     313
     314O comando ``latex.engine()`` pode ser usado para controlar de os
     315executáveis ``latex``, ``pdflatex`` ou ``xelatex`` do sistema são
     316usados para processar expressões mais complicadas. Quando ``view()`` é
     317chamado na linha de comando do Sage e o processador é definido como
     318``latex``, um arquivo dvi é produzido e o Sage vai usar um
     319visualizador de dvi (como o xdvi) para apresentar o resultado. Por
     320outro lado, usando ``view()`` na linha de comando do Sage, quando o
     321processador é definido como ``pdflatex``, irá produzir um PDF e o Sage vai
     322executar o programa disponível no seu sistema para visualizar arquivos
     323PDF (acrobat, okular, evince, etc.).
     324
     325No Notebook, é necessário interver na decisão de se o jsMath vai
     326interpretar trechos em TeX, ou se o LaTeX do sistema deve fazer o
     327trabalho se o código em LaTeX for complicado demais. O dispositivo é
     328uma lista de strings, que se forem encontradas em um trecho de código
     329LaTeX sinalizam para o Notebook usar o LaTeX (ou qualquer executável
     330que for definido pelo comando ``latex.engine()``). Essa lista é
     331gerenciada pelos comandos ``latex.add_to_jsmath_avoid_list`` e
     332``latex.jsmath_avoid_list``. ::
     333
     334    sage: latex.jsmath_avoid_list([])
     335    sage: latex.jsmath_avoid_list()
     336    []
     337    sage: latex.jsmath_avoid_list(['foo', 'bar'])
     338    sage: latex.jsmath_avoid_list()
     339    ['foo', 'bar']
     340    sage: latex.add_to_jsmath_avoid_list('tikzpicture')
     341    sage: latex.jsmath_avoid_list()
     342    ['foo', 'bar', 'tikzpicture']
     343    sage: latex.jsmath_avoid_list([])
     344    sage: latex.jsmath_avoid_list()
     345    []
     346
     347Suponha que uma expressão em LaTeX é produzida no Notebook com o
     348comando ``view()`` ou enquanto o botão "Typeset" está selecionado, e
     349então reconhecida, através da "lista de comandos a serem evitados no
     350jsMath", como necessitando a versão do LaTeX no sistema. Então o
     351executável selecionado (como especificado por ``latex.engine()``) irá
     352processar o código em LaTeX. Todavia, em vez de então abrir um
     353visualizador externo (o que é o comportamento na linha de comando), o
     354Sage irá tentar converter o resultado em uma imagem, que então é
     355inserida na folha de trabalho como o resultado da célula.
     356
     357Exatamente como essa conversão é feita depende de vários fatores --
     358qual executável você especificou como processador e quais utilitários
     359de conversão estão disponíveis no seu sistema. Quatro conversores
     360usuais que irão cobrir todas as ocorrências são o ``dvips``,
     361``ps2pdf``, e ``dvipng``, e do pacote ``ImageMagick``, o ``convert``.
     362O objetivo é produzir um arquivo PNG para ser inserido de volta na
     363folha de trabalho. Quando uma expressão em LaTeX pode ser convertida
     364com sucesso em um arquivo dvi pelo processador LaTeX, então o dvipng
     365deve dar conta da conversão. Se a expressão em LaTeX e o processador
     366especificado criarem um arquivo dvi com conteúdo especial que o dvipng
     367não pode converter, então o dvips vai criar um arquivo PostScript.
     368Esse arquivo PostScript, ou um PDF criado por pelo processador
     369``pdflatex``, é então convertido em um arquivo dvi pelo programa
     370``convert``. A presença de dois desses conversores pode ser testado
     371com as rotinas ``have_dvipng()`` e ``have_convert()``.
     372
     373Essas conversões são feitas automaticamente se você tiver os
     374conversores necessários instalados; se não, então uma mensagem de erro
     375é impressa dizendo o que está faltando e onde obter.
     376
     377Para um exemplo concreto de como expressões complicadas em LaTeX podem
     378ser processadas, veja o exemplo na próxima seção
     379(:ref:`sec-tkz-graph`) para usar o pacote ``tkz-graph`` para produzir
     380ilustrações de grafos combinatoriais de alta qualidade. Para outros
     381exemplos, existem alguns casos teste incluídos no Sage. Para usá-los,
     382é necessário importar o objeto ``sage.misc.latex.latex_examples``, que
     383é uma instância da classe ``sage.misc.latex.LatexExamples``, como
     384mostrado abaixo. Essa classe possui exemplos de diagramas comutativos,
     385grafos combinatoriais, teoria de nós e pstricks, os quais
     386respectivamente testam os seguintes pacotes: xy, tkz-graph, xypic,
     387pstricks. Após importar o objeto, use completamento tab em
     388``latex_examples`` para ver os exemplos disponíveis. Ao carregar um
     389exemplo você irá obter explicações sobre o que é necessário para fazer
     390o conteúdo do exemplo ser exibido corretamente. Para de fato ver os
     391exemplos, é necessário usar ``view()`` (uma vez que o preambulo,
     392processador, etc. estão configurados corretamente).
     393
     394::
     395
     396    sage: from sage.misc.latex import latex_examples
     397    sage: latex_examples.diagram()
     398    LaTeX example for testing display of a commutative diagram produced
     399    by xypic.
     400    <BLANKLINE>
     401    To use, try to view this object -- it won't work.  Now try
     402    'latex.add_to_preamble("\\usepackage[matrix,arrow,curve,cmtip]{xy}")',
     403    and try viewing again -- it should work in the command line but not
     404    from the notebook.  In the notebook, run
     405    'latex.add_to_jsmath_avoid_list("xymatrix")' and try again -- you
     406    should get a picture (a part of the diagram arising from a filtered
     407    chain complex).
     408
     409.. _sec-tkz-graph:
     410
     411Exemplo: Grafos Combinatoriais com tkz-graph
     412============================================
     413
     414Ilustrações de alta qualidade de grafos combinatoriais (daqui por
     415diante, simplesmente grafos) são possíveis com o pacote ``tkz-graph``.
     416Esse pacote baseia-se no ``tikz`` front-end da biblioteca ``pgf``.
     417Logo todos esses componentes precisam ser parte de uma instalação
     418completa do LaTeX em seu sistema, e pode acontecer que alguns desses
     419componentes não estejam em sua versão mais recente em algumas
     420distribuições do TeX. Logo, para melhores resultados, seria necessário
     421ou recomendável instalar esses pacotes como parte do seu diretório
     422texmf pessoal. Criar, manter e personalizar uma instalação do TeX no
     423sistema ou em um diretório pessoal vai além do escopo deste documento,
     424mas deve ser fácil encontrar instruções para isso. Os arquivos
     425necessários estão listados em :ref:`sec-system-wide-tex`.
     426
     427Portanto, para começar precisamos nos certificar que os pacotes
     428relevantes estão incluídos adicionando-os ao preambulo do eventual
     429documento LaTeX. As imagens dos grafos não são formadas corretamente
     430quando um arquivo dvi é usando como formato intermediário, logo é
     431melhor definir o processador do LaTeX como ``pdflatex``. A esta altura
     432um comando como ``view(graphs.CompleteGraph(4))`` deve funcionar na
     433linha de comando do Sage e produzir um PDF com a imagem completa do
     434grafo `K_4`.
     435
     436Para uma experiência semelhante no Notebook, é necessário desabilitar
     437o processador jsMath para o código LaTeX do grafo usando a "lista de
     438comandos a serem evitados pelo jsMath". Grafos são criados usando o
     439environment ``tikzpicture``, logo essa uma boa escolha para uma string
     440a ser incluída na lista que acabamos de mencionar. Agora,
     441``view(graphs.CompleteGraph(4))`` em uma folha de trabalho deve
     442executar o pdflatex para criar um PDF e então o programa ``convert``
     443para obter um gráfico PNG que vai ser inserido na folha de trabalho.
     444Os seguintes comandos ilustram os passos para obter grafos processados
     445pelo LaTeX no Notebook. ::
     446
     447    sage: from sage.graphs.graph_latex import setup_latex_preamble
     448    sage: setup_latex_preamble()
     449    sage: latex.extra_preamble() # random - depends on system's TeX installation
     450    '\\usepackage{tikz}\n\\usepackage{tkz-graph}\n\\usepackage{tkz-berge}\n'
     451    sage: latex.engine('pdflatex')
     452    sage: latex.add_to_jsmath_avoid_list('tikzpicture')
     453    sage: latex.jsmath_avoid_list()
     454    ['tikzpicture']
     455
     456Agora, um comando como ``view(graphs.CompleteGraph(4))`` deve produzir
     457um gráfico do grafo no Notebook, tendo usado ``pdflatex`` para
     458processar os comandos do ``tkz-graph`` para construir o grafo. Note
     459que há diversas opções que afetam o resultado do gráfico obtido usando
     460o LaTeX via ``tkz-graph``, o que mais uma vez está além do escopo
     461desta seção (veja a seção do Manual de Referência com título "Opções
     462do LaTeX para Grafos" para instruções e detalhes).
     463
     464.. _sec-system-wide-tex:
     465
     466Uma Instalação Completa do TeX
     467==============================
     468Vários dos recursos avançados de integração do TeX com o Sage requerem
     469uma instalação do TeX em seu sistema. Várias versões do Linux possuem
     470pacotes do TeX baseados no TeX-live, para o OSX existe o TeXshop e
     471para o windows existe o MikTex. O utilitário ``convert`` é parte do
     472`ImageMagick <http://www.imagemagick.org/>`_ (que deve ser um pacote
     473na sua versão do Linux ou ser fácil de instalar), e os três programas
     474``dvipng``, ``ps2pdf``, e ``dvips`` podem estar incluídos na sua
     475distribuição do TeX. Os dois primeiros podem também ser obtidos em,
     476respectivamente, http://sourceforge.net/projects/dvipng/ e como parte
     477do `Ghostscript <http://www.ghostscript.com/>`_.
     478
     479A criação de grafos combinatoriais requer uma versão recente da
     480biblioteca PGF, e os arquivos ``tkz-graph.sty``, ``tkz-arith.sty`` e
     481talvez ``tkz-berge.sty``, que estão disponíveis em `Altermundus site
     482<http://altermundus.com/pages/graph.html>`_.
     483
     484Programas Externos
     485==================
     486
     487Existem três programas disponíveis para integrar ainda mais o TeX e o
     488Sage. O primeiro é o sagetex. Uma descrição concisa do sagetex é que
     489ele é uma coleção de macros do TeX que permitem incluir em um
     490documento LaTeX instruções para usar o Sage para calcular vários
     491objetos, e/ou formatar objetos usando o comando ``latex()`` existente
     492no Sage. Logo, como um passo intermediário para compilar um documento
     493LaTeX, todos os recursos computacionais e de formatação do Sage podem
     494ser executados automaticamente. Como um exemplo, um exame matemático
     495pode manter uma correspondência entre questões e respostas usando o
     496sagetex para fazer cálculos com o Sage. Veja :ref:`sec-sagetex` para
     497mais informações.
     498
     499O tex2sws começa com um documento LaTeX, mas define environments
     500adicionais para inserir código em Sage. Quando processado com as
     501ferramentas adequadas, o resultado é uma folha de trabalho do Sage,
     502com conteúdo apropriadamente formatado para o jsMath e com código em
     503Sage incorporado como células de entrada. Então um livro texto ou
     504artigo pode ser criado em LaTeX, ter blocos de código em Sage
     505incluídos, e o documento todo pode ser transformado em uma folha de
     506trabalho do Sage onde o texto matemático é bem formatado e os blocos
     507de código em Sage podem ser facilmente executados. Atualmente em
     508desenvolvimento, veja `tex2sws @ BitBucket
     509<http://bitbucket.org/rbeezer/tex2sws/>`_ para mais informações.
     510
     511O sws2tex reverte o processo partindo de uma folha de trabalho do Sage
     512e convertendo o conteúdo para LaTeX para ser posteriormente processado
     513com as ferramentas disponíveis para documentos em LaTeX. Atualmente em
     514desenvolvimento, veja `sws2tex @ BitBucket
     515<http://bitbucket.org/whuss/sws2tex/>`_ para mais informações.
  • new file doc/pt/tutorial/programming.rst

    diff --git a/doc/pt/tutorial/programming.rst b/doc/pt/tutorial/programming.rst
    new file mode 100644
    - +  
     1***********
     2Programação
     3***********
     4
     5.. _section-loadattach:
     6
     7Carregando e Anexando Arquivos do Sage
     8======================================
     9
     10A seguir ilustramos como carregar no Sage programas escritos em um
     11arquivo separado. Crie um arquivo chamado ``example.sage`` com o
     12seguinte conteúdo:
     13
     14.. skip
     15
     16::
     17
     18    print "Hello World"
     19    print 2^3
     20
     21Você pode ler e executar o arquivo ``example.sage`` usando o comando
     22``load``.
     23
     24.. skip
     25
     26::
     27
     28    sage: load "example.sage"
     29    Hello World
     30    8
     31
     32Você também pode anexar um arquivo em Sage à sessão em execução usando
     33o comando ``attach``.
     34
     35.. skip
     36
     37::
     38
     39    sage: attach "example.sage"
     40    Hello World
     41    8
     42
     43Agora se você alterar ``example.sage`` e adicionar uma linha em branco
     44(por exemplo), então o conteúdo de ``example.sage`` será
     45automaticamente recarregado no Sage.
     46
     47Em particular, ``attach`` automaticamente recarrega um arquivo toda
     48vez que ele for modificado, o que é útil para desenvolver e testar um
     49programa, enquanto ``load`` carrega o arquivo apenas uma vez.
     50
     51Quando o Sage carrega ``example.sage`` ele converte esse arquivo para
     52o Python, o qual é então executado pelo interpretador do Python. Essa
     53conversão é mínima; ela essencialmente consiste em encapsular inteiros
     54em ``Integer()``, números float em ``RealNumber()``, substituir ``^``
     55por ``**``, e substituir, por exemplo, ``R.2`` por ``R.gen(2)``. A
     56versão convertida de ``example.sage`` é armazenada no mesmo diretório
     57de ``example.sage`` e é chamada ``example.sage.py``. Esse arquivo
     58contém o seguinte código:
     59
     60::
     61
     62    print "Hello World"
     63    print Integer(2)**Integer(3)
     64
     65Inteiros literais são encapsulados e ``^`` é substituído por ``**``.
     66(Em Python, ``^`` significa "ou exclusivo" e ``**`` significa
     67"exponenciação".)
     68
     69Esse "preparsing" está implementado em ``sage/misc/interpreter.py``.)
     70
     71Você pode colar código tabulado com muitas linhas no Sage desde que
     72existam linhas em branco separando blocos de código (isso não é
     73necessário em arquivos). Todavia, a melhor forma de adicionar tal
     74código a uma sessão do Sage é salvá-lo em um arquivo e usar
     75``attach``, como descrito anteriormente.
     76
     77
     78.. _section-compile:
     79
     80Criando Código Compilado
     81========================
     82
     83Velocidade é crucial em cálculos matemáticos. Embora o Python seja uma
     84linguagem conveniente de alto nível, certos cálculos podem ser várias
     85vezes mais rápidos do que em Python se eles forem implementados usando
     86tipos estáticos em uma linguagem compilada. Alguns aspectos do Sage
     87seriam muito lentos se eles fossem escritos inteiramente em Python.
     88Para lidar com isso, o Sage suporta uma "versão" compilada do Python
     89chamada Cython ([Cyt]_ and [Pyr]_). O Cython é simultaneamente similar
     90ao Python e ao C. A maior parte das construções em Python, incluindo
     91"list comprehensions", expressões condicionais, código como ``+=`` são
     92permitidos; você também pode importar código que você escreveu em
     93outros módulos em Python. Além disso, você pode declarar variáveis em
     94C arbitrárias, e qualquer chamada de bibliotecas em C pode ser feita
     95diretamente. O código resultante é convertido para C e compilado
     96usando um compilador para C.
     97
     98Para criar o seu próprio código compilado em Sage, nomeie o arquivo
     99com uma extensão ``.spyx`` (em vez de ``.sage``). Se você está
     100trabalhando na linha de comando, você pode anexar e carregar código
     101compilado exatamente como se faz com código interpretado (no momento,
     102anexar e carregar código em Cython não é suportado no Notebook). A
     103compilação é realizada implicitamente sem que você tenha que fazer
     104qualquer coisa explicitamente. Veja
     105``$SAGE_ROOT/examples/programming/sagex/factorial.spyx`` para um
     106exemplo de uma implementação compilada para a função fatorial que usa
     107diretamente a biblioteca GMP em C. Experimente o seguinte, usando cd,
     108vá para o diretório ``$SAGE_ROOT/examples/programming/sagex/``, e
     109então faça o seguinte:
     110
     111.. skip
     112
     113::
     114
     115    sage: load "factorial.spyx"
     116    ***************************************************
     117                    Recompiling factorial.spyx
     118    ***************************************************
     119    sage: factorial(50)
     120    30414093201713378043612608166064768844377641568960512000000000000L
     121    sage: time n = factorial(10000)
     122    CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s
     123    Wall time: 0.03
     124
     125Aqui o sufixo L indica um "long integer" do Python (veja
     126:ref:`section-mathannoy`).
     127
     128Note que o Sage vai recompilar ``factorial.spyx`` se você encerrar e
     129reiniciar o Sage. A biblioteca compilada e compartilhada é armazenada
     130em ``$HOME/.sage/temp/hostname/pid/spyx``. Esses arquivos são
     131excluídos quando você encerra o Sage.
     132
     133Nenhum pré-processador (preparsing) é aplicado em arquivos spyx, por
     134exemplo, ``1/3`` vai resultar em 0 em um arquivo spyx em vez do número
     135racional :math:`1/3`. Se ``foo`` é uma função da biblioteca Sage, para
     136usá-la em um arquivo spyx importe ``sage.all`` e use ``sage.all.foo``.
     137
     138::
     139
     140    import sage.all
     141    def foo(n):
     142        return sage.all.factorial(n)
     143
     144Acessando Funções em C em Arquivos Separados
     145--------------------------------------------
     146
     147É fácil também acessar funções em C definidas em arquivos \*.c
     148separados. Aqui vai um exemplo. Crie os arquivos ``test.c`` e
     149``test.spyx`` no mesmo diretório contendo:
     150
     151Código C puro: ``test.c``
     152
     153::
     154
     155    int add_one(int n) {
     156      return n + 1;
     157    }
     158
     159Código Cython: ``test.spyx``:
     160
     161::
     162
     163    cdef extern from "test.c":
     164        int add_one(int n)
     165   
     166    def test(n):
     167        return add_one(n)
     168
     169Então o seguinte funciona:
     170
     171.. skip
     172
     173::
     174
     175    sage: attach "test.spyx"
     176    Compiling (...)/test.spyx...
     177    sage: test(10)
     178    11
     179
     180Se uma biblioteca ``foo`` adicional é necessária para compilar código
     181em C gerado a partir de um arquivo em Cython, adicione a linha ``clib
     182foo`` no arquivo fonte em Cython. De forma similar, um arquivo em C
     183adicional ``bar`` pode ser incluído na compilação declarando ``cfile
     184bar``.
     185
     186.. _section-standalone:
     187
     188Scripts Independentes em Python/Sage
     189====================================
     190
     191O seguinte script em Sage fatora inteiros, polinômios, etc:
     192
     193::
     194
     195    #!/usr/bin/env sage -python
     196   
     197    import sys
     198    from sage.all import *
     199   
     200    if len(sys.argv) != 2:
     201        print "Usage: %s <n>"%sys.argv[0]
     202        print "Outputs the prime factorization of n."
     203        sys.exit(1)
     204   
     205    print factor(sage_eval(sys.argv[1]))
     206
     207Para usar esse script, sua ``SAGE_ROOT`` precisa estar na sua variável
     208PATH. Se o script acima for chamado ``factor``, aqui está um exemplo
     209de como usá-lo:
     210
     211::
     212
     213    bash $ ./factor 2006
     214    2 * 17 * 59
     215    bash $ ./factor "32*x^5-1"
     216    (2*x - 1) * (16*x^4 + 8*x^3 + 4*x^2 + 2*x + 1)
     217
     218Tipo de Dados
     219=============
     220
     221Cada objeto em Sage possui um tipo bem definido. O Python possui
     222diversos tipos de dados, e a biblioteca do Sage adiciona ainda mais.
     223Os tipos de dados de Python incluem strings, listas, tuplas, inteiros
     224e floats, como ilustrado:
     225
     226::
     227
     228    sage: s = "sage"; type(s)
     229    <type 'str'>
     230    sage: s = 'sage'; type(s)      # you can use either single or double quotes
     231    <type 'str'>
     232    sage: s = [1,2,3,4]; type(s)
     233    <type 'list'>
     234    sage: s = (1,2,3,4); type(s)
     235    <type 'tuple'>
     236    sage: s = int(2006); type(s)
     237    <type 'int'>
     238    sage: s = float(2006); type(s)
     239    <type 'float'>
     240
     241Além disso, o Sage acrescenta vários outros tipos. Por exemplo,
     242espaços vetoriais:
     243
     244::
     245
     246    sage: V = VectorSpace(QQ, 1000000); V
     247    Vector space of dimension 1000000 over Rational Field
     248    sage: type(V)
     249    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category'>
     250
     251Apenas certas funções podem ser aplicadas sobre ``V``. Em outros
     252softwares de matemática, essas seriam chamadas usando a notação
     253"funcional" ``foo(V,...)``. Em Sage, algumas funções estão anexadas ao
     254tipo (ou classe) de ``V``, e são chamadas usando uma sintaxe orientada
     255a objetos como em Java ou C++, por exemplo, ``V.foo()``. Isso ajuda a
     256manter o espaço de variáveis global sem milhares de funções, e permite
     257que várias funções diferentes com comportamento diferente possam ser
     258chamadas foo, sem a necessidade de usar um mecanismo de identificação
     259de tipos (ou casos) para decidir qual chamar. Além disso, se você
     260reutilizar o nome de uma função, essa função continua ainda disponível
     261(por exemplo, se você chamar algo ``zeta``, e então quiser calcular o
     262valor da função zeta de Riemann em 0.5, você continua podendo digitar
     263``s=.5; s.zeta()``).
     264
     265::
     266
     267    sage: zeta = -1
     268    sage: s=.5; s.zeta()     
     269    -1.46035450880959
     270
     271Em alguns casos muito comuns, a notação funcional usual é também
     272suportada por conveniência e porque expressões matemáticas podem
     273parecer confusas usando a notação orientada a objetos. Aqui vão alguns
     274exemplos.
     275
     276::
     277
     278    sage: n = 2; n.sqrt()
     279    sqrt(2)
     280    sage: sqrt(2)
     281    sqrt(2)
     282    sage: V = VectorSpace(QQ,2)
     283    sage: V.basis()
     284        [
     285        (1, 0),
     286        (0, 1)
     287        ]
     288    sage: basis(V)
     289        [
     290        (1, 0),
     291        (0, 1)
     292        ]
     293    sage: M = MatrixSpace(GF(7), 2); M
     294    Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7
     295    sage: A = M([1,2,3,4]); A
     296    [1 2]
     297    [3 4]
     298    sage: A.charpoly('x')
     299    x^2 + 2*x + 5
     300    sage: charpoly(A, 'x')
     301    x^2 + 2*x + 5
     302
     303Para listar todas as funções para :math:`A`, use completamento tab.
     304Simplesmente digite ``A.``, então tecle ``[tab]`` no seu teclado, como
     305descrito em :ref:`section-tabcompletion`.
     306
     307Listas, Tuplas e Sequências
     308===========================
     309
     310O tipo de dados lista armazena elementos de um tipo arbitrário. Como
     311em C, C++, etc. (mas diferentemente da maioria dos sistemas de álgebra
     312computacional), os elementos da lista são indexados a partir do
     313:math:`0`:
     314
     315::
     316
     317    sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v
     318    [2, 3, 5, 'x', Symmetric group of order 3! as a permutation group]
     319    sage: type(v)
     320    <type 'list'>
     321    sage: v[0]
     322    2
     323    sage: v[2]
     324    5
     325
     326(Quando se indexa uma lista, é permitido que o índice não seja um int
     327do Python!) Um Inteiro do Sage (ou Racional, ou qualquer objeto que
     328possua um método ``__index__``) também ira funcionar.
     329
     330::
     331
     332    sage: v = [1,2,3]
     333    sage: v[2]
     334    3
     335    sage: n = 2      # SAGE Integer
     336    sage: v[n]       # Perfectly OK!
     337    3
     338    sage: v[int(n)]  # Also OK.
     339    3
     340
     341A função ``range`` cria uma lista de int's do Python (não Inteiros do
     342Sage):
     343
     344::
     345
     346    sage: range(1, 15)
     347    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
     348
     349Isso é útil quando se usa "list comprehensions" para construir listas:
     350
     351::
     352
     353    sage: L = [factor(n) for n in range(1, 15)]
     354    sage: print L
     355    [1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7]
     356    sage: L[12]
     357    13
     358    sage: type(L[12])
     359    <class 'sage.structure.factorization_integer.IntegerFactorization'>
     360    sage: [factor(n) for n in range(1, 15) if is_odd(n)]
     361    [1, 3, 5, 7, 3^2, 11, 13]
     362
     363Para mais sobre como criar listas usando "list comprehensions", veja
     364[PyT]_.
     365
     366Fatiamento de lista (list slicing) é um recurso fantástico. Se ``L`` é
     367uma lista, então ``L[m:n]`` retorna uma sub-lista de ``L`` obtida
     368começando do :math:`m`-ésimo elemento e terminando no
     369:math:`(n-1)`-ésimo elemento, como ilustrado abaixo.
     370
     371::
     372
     373    sage: L = [factor(n) for n in range(1, 20)]
     374    sage: L[4:9]
     375    [5, 2 * 3, 7, 2^3, 3^2]
     376    sage: print L[:4]
     377    [1, 2, 3, 2^2]
     378    sage: L[14:4]
     379    []
     380    sage: L[14:]
     381    [3 * 5, 2^4, 17, 2 * 3^2, 19]
     382
     383Tuplas são semelhantes à listas, exceto que elas são imutáveis: uma
     384vez criadas elas não podem ser alteradas.
     385
     386::
     387
     388    sage: v = (1,2,3,4); v
     389    (1, 2, 3, 4)
     390    sage: type(v)
     391    <type 'tuple'>
     392    sage: v[1] = 5
     393    Traceback (most recent call last):
     394    ...   
     395    TypeError: 'tuple' object does not support item assignment
     396
     397Sequências são um terceiro tipo de dados do Sage semelhante a listas.
     398Diferentemente de listas e tuplas, Sequence não é um tipo de dados
     399nativo do Python. Por definição, uma sequência é mutável, mas usando o
     400método ``set_immutable`` da classe ``Sequence`` elas podem ser feitas
     401imutáveis, como mostra o exemplo a seguir. Todos os elementos da
     402sequência possuem um parente comum, chamado o universo da sequência.
     403
     404::
     405
     406    sage: v = Sequence([1,2,3,4/5])
     407    sage: v
     408    [1, 2, 3, 4/5]
     409    sage: type(v)
     410    <class 'sage.structure.sequence.Sequence_generic'>
     411    sage: type(v[1])
     412    <type 'sage.rings.rational.Rational'>
     413    sage: v.universe()
     414    Rational Field
     415    sage: v.is_immutable()
     416    False
     417    sage: v.set_immutable()
     418    sage: v[0] = 3
     419    Traceback (most recent call last):
     420    ...
     421    ValueError: object is immutable; please change a copy instead.
     422
     423Sequências são derivadas de listas e podem ser usadas em qualquer
     424lugar que listas são usadas.
     425
     426::
     427
     428    sage: v = Sequence([1,2,3,4/5])
     429    sage: isinstance(v, list)
     430    True
     431    sage: list(v)
     432    [1, 2, 3, 4/5]
     433    sage: type(list(v))
     434    <type 'list'>
     435
     436Como um outro exemplo, bases para espaços vetoriais são sequências
     437imutáveis, pois é importante que elas não sejam modificadas.
     438
     439::
     440
     441    sage: V = QQ^3; B = V.basis(); B
     442    [
     443    (1, 0, 0),
     444    (0, 1, 0),
     445    (0, 0, 1)
     446    ]
     447    sage: type(B)
     448    <class 'sage.structure.sequence.Sequence_generic'>
     449    sage: B[0] = B[1]
     450    Traceback (most recent call last):
     451    ...
     452    ValueError: object is immutable; please change a copy instead.
     453    sage: B.universe()
     454    Vector space of dimension 3 over Rational Field
     455
     456Dicionários
     457===========
     458
     459Um dicionário (também chamado as vezes de lista associativa) é um
     460mapeamento de objetos "hashable" em objetos arbitrários. (Exemplos de
     461objetos "hashable" são strings e números; veja a documentação Python
     462em http://docs.python.org/tut/node7.html e
     463http://docs.python.org/lib/typesmapping.html para detalhes).
     464
     465::
     466
     467    sage: d = {1:5, 'sage':17, ZZ:GF(7)}
     468    sage: type(d)
     469    <type 'dict'>
     470    sage: d.keys()
     471     [1, 'sage', Integer Ring]
     472    sage: d['sage']
     473    17
     474    sage: d[ZZ]
     475    Finite Field of size 7
     476    sage: d[1]
     477    5
     478
     479A terceira chave (key) ilustra como os índices de um dicionário podem
     480ser complicados, por exemplo, um anel de inteiros.
     481
     482Você pode transformar o dicionário acima em uma lista com os mesmos
     483dados:
     484
     485.. link
     486
     487::
     488
     489    sage: d.items()
     490    [(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]
     491
     492É comum iterar sobre os pares em um dicionário:
     493
     494::
     495
     496    sage: d = {2:4, 3:9, 4:16}
     497    sage: [a*b for a, b in d.iteritems()]
     498    [8, 27, 64]
     499
     500Um dicionário não possui ordem, como o exemplo acima mostra.
     501
     502Conjuntos
     503=========
     504
     505O Python possui um tipo set (conjuntos) nativo. O principal recurso
     506que ele oferece é a rápida verificação se um objeto está ou não em um
     507conjunto, juntamente com as operações comuns em conjuntos.
     508
     509::
     510
     511    sage: X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
     512    sage: X
     513    set(['a', 1, 19])
     514    sage: Y
     515    set([1, 2/3])
     516    sage: 'a' in X
     517    True
     518    sage: 'a' in Y
     519    False
     520    sage: X.intersection(Y)
     521    set([1])
     522
     523O Sage também possui o seu próprio tipo de dados para conjuntos que é
     524(em alguns casos) implementado usando o tipo nativo do Python, mas
     525possuir algumas funcionalidades adicionais. Crie um conjunto em Sage
     526usando ``Set(...)``. Por exemplo,
     527
     528::
     529
     530    sage: X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
     531    sage: X
     532    {'a', 1, 19}
     533    sage: Y
     534    {1, 2/3}
     535    sage: X.intersection(Y)
     536    {1}
     537    sage: print latex(Y)
     538    \left\{1, \frac{2}{3}\right\}
     539    sage: Set(ZZ)
     540    Set of elements of Integer Ring
     541
     542Iteradores
     543==========
     544
     545Iteradores foram adicionados recentemente ao Python e são
     546particularmente úteis em aplicações matemáticas. Aqui estão vários
     547exemplos; veja [PyT]_ para mais detalhes. Vamos criar um iterador
     548sobre o quadrados dos números inteiros até :math:`10000000`.
     549
     550::
     551
     552    sage: v = (n^2 for n in xrange(10000000))
     553    sage: v.next()
     554    0
     555    sage: v.next()
     556    1
     557    sage: v.next()
     558    4
     559
     560Criamos agora um iterador sobre os primos da forma :math:`4p+1` com
     561:math:`p` também primo, e observamos os primeiros valores.
     562
     563::
     564
     565    sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
     566    sage: w         # in the next line, 0xb0853d6c is a random 0x number
     567    <generator object at 0xb0853d6c>
     568    sage: w.next()
     569    13
     570    sage: w.next()
     571    29
     572    sage: w.next()
     573    53
     574
     575Certos anéis, por exemplo, corpos finitos e os inteiros possuem
     576iteradores associados a eles:
     577
     578::
     579
     580    sage: [x for x in GF(7)]
     581    [0, 1, 2, 3, 4, 5, 6]
     582    sage: W = ((x,y) for x in ZZ for y in ZZ)
     583    sage: W.next()
     584    (0, 0)
     585    sage: W.next()
     586    (0, 1)
     587    sage: W.next()
     588    (0, -1)
     589
     590Laços, Funções, Enunciados de Controle e Comparações
     591====================================================
     592
     593Nós já vimos alguns exemplos de alguns usos comuns de laços (loops)
     594``for``. Em Python, um laço ``for`` possui uma estrutura tabulada, tal
     595como
     596
     597::
     598
     599    >>> for i in range(5):
     600           print(i)
     601       
     602    0
     603    1
     604    2
     605    3
     606    4
     607
     608Note que os dois pontos no final do enunciado (não existe "do" ou "od"
     609como no GAP ou Maple), e a identação antes dos comandos dentro do
     610laço, isto é, ``print(i)``. A tabulação é importante. No Sage, a
     611tabulação é automaticamente adicionada quando você digita ``enter``
     612após ":", como ilustrado abaixo.
     613
     614::
     615
     616    sage: for i in range(5):
     617    ...       print(i)  # now hit enter twice
     618    0
     619    1
     620    2
     621    3
     622    4
     623
     624O símbolo ``=`` é usado para atribuição.
     625O símbolo ``==`` é usado para verificar igualdade:
     626
     627::
     628
     629    sage: for i in range(15):
     630    ...       if gcd(i,15) == 1:
     631    ...           print(i)
     632    1
     633    2
     634    4
     635    7
     636    8
     637    11
     638    13
     639    14
     640
     641Tenha em mente como a tabulação determina a estrutura de blocos para
     642enunciados ``if``, ``for``, e ``while``:
     643
     644::
     645
     646    sage: def legendre(a,p):
     647    ...       is_sqr_modp=-1
     648    ...       for i in range(p):
     649    ...           if a % p == i^2 % p:
     650    ...               is_sqr_modp=1
     651    ...       return is_sqr_modp
     652             
     653    sage: legendre(2,7)
     654    1
     655    sage: legendre(3,7)
     656    -1
     657
     658Obviamente essa não é uma implementação eficiente do símbolo de
     659Legendre! O objetivo é ilustrar vários aspectos da programação em
     660Python/Sage. A função {kronecker}, que já vem com o Sage, calcula o
     661símbolo de Legendre eficientemente usando uma biblioteca em C do PARI.
     662
     663Finalmente, observamos que comparações, tais como ``==``, ``!=``,
     664``<=``, ``>=``, ``>``, ``<``, entre números irão automaticamente
     665converter ambos os números para o mesmo tipo, se possível:
     666
     667::
     668
     669    sage: 2 < 3.1; 3.1 <= 1
     670    True
     671    False
     672    sage: 2/3 < 3/2;   3/2 < 3/1
     673    True
     674    True
     675
     676Quase todos pares de objetos podem ser comparados; não se supõe que os
     677objetos estejam equipados com uma ordem total.
     678
     679::
     680
     681    sage: 2 < CC(3.1,1)
     682    True
     683    sage: 5 < VectorSpace(QQ,3)   # output can be somewhat random
     684    True
     685
     686Use bool para desigualdades simbólicas:
     687
     688::
     689
     690    sage: x < x + 1
     691    x < x + 1
     692    sage: bool(x < x + 1)
     693    True
     694
     695Quando se compara objetos de tipos diferentes no Sage, na maior parte
     696dos casos o Sage tenta encontrar uma coação canônica para ambos os
     697objetos em um parente comum (veja :ref:`section-coercion` para mais
     698detalhes). Se isso for bem sucedido, a comparação é realizada entre os
     699objetos que foram coagidos; se não for bem sucedido, os objetos são
     700considerados diferentes. Para testar se duas variáveis fazem
     701referência ao mesmo objeto use ``is``. Como se vê no próximo exemplo,
     702o int ``1`` do Python é único, mas o Inteiro ``1`` do Sage não é.
     703
     704::
     705
     706    sage: 1 is 2/2
     707    False
     708    sage: int(1) is int(2)/int(2)
     709    True
     710    sage: 1 is 1
     711    False
     712    sage: 1 == 2/2
     713    True
     714
     715Nas duas linhas seguintes, a primeira igualdade é falsa (``False``)
     716porque não existe um morfismo canônico :math:`QQ\to \GF{5}`, logo
     717não há uma forma de comparar o :math:`1` em :math:`\GF{5}` com o
     718:math:`1 \in \QQ`. Em contraste, existe um mapa canônico entre
     719:math:`\ZZ \to \GF{5}`, logo a segunda comparação é verdadeira
     720(``True``)
     721
     722::
     723
     724    sage: GF(5)(1) == QQ(1); QQ(1) == GF(5)(1)
     725    False
     726    False
     727    sage: GF(5)(1) == ZZ(1); ZZ(1) == GF(5)(1)
     728    True
     729    True
     730    sage: ZZ(1) == QQ(1)
     731    True
     732
     733ATENÇÃO: Comparação no Sage é mais restritiva do que no Magma, o qual
     734declara :math:`1 \in \GF{5}` igual a :math:`1 \in \QQ`.
     735
     736::
     737
     738    sage: magma('GF(5)!1 eq Rationals()!1')            # optional magma required
     739    true
     740
     741Otimização (Profiling)
     742======================
     743
     744Autor desta seção: Martin Albrecht (malb@informatik.uni-bremen.de)
     745
     746    "Premature optimization is the root of all evil." - Donald Knuth
     747
     748As vezes é útil procurar por gargalos em programas para entender quais
     749partes gastam maior tempo computacional; isso pode dar uma boa ideia
     750sobre quais partes otimizar. Python e portanto Sage fornecem várias
     751opções de "profiling" (esse é o nome que se dá ao processo de
     752otimização).
     753
     754O mais simples de usar é o comando ``prun`` na linha de comando
     755interativa. Ele retorna um sumário sobre o tempo computacional
     756utilizado por cada função. Para analisar (a atualmente lenta! -- na
     757versão 1.0) multiplicação de matrizes sobre corpos finitos, por
     758exemplo, faça o seguinte:
     759
     760::
     761
     762    sage: k,a = GF(2**8, 'a').objgen()
     763    sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])
     764
     765.. skip
     766
     767::
     768
     769    sage: %prun B = A*A
     770           32893 function calls in 1.100 CPU seconds
     771   
     772    Ordered by: internal time
     773   
     774    ncalls tottime percall cumtime percall filename:lineno(function)
     775     12127  0.160   0.000   0.160  0.000 :0(isinstance)
     776      2000  0.150   0.000   0.280  0.000 matrix.py:2235(__getitem__)
     777      1000  0.120   0.000   0.370  0.000 finite_field_element.py:392(__mul__)
     778      1903  0.120   0.000   0.200  0.000 finite_field_element.py:47(__init__)
     779      1900  0.090   0.000   0.220  0.000 finite_field_element.py:376(__compat)
     780       900  0.080   0.000   0.260  0.000 finite_field_element.py:380(__add__)
     781         1  0.070   0.070   1.100  1.100 matrix.py:864(__mul__)
     782      2105  0.070   0.000   0.070  0.000 matrix.py:282(ncols)
     783      ...
     784
     785Aqui ``ncalls`` é o números de chamadas, ``tottime`` é o tempo total
     786gasto por uma determinada função (excluíndo o tempo gasto em chamadas
     787de subfunções), ``percall`` é o quociente de ``tottime`` dividido por
     788``ncalls``. ``cumtime`` é o tempo total gasto nessa e em todas as
     789subfunções (isto é, desde o início até o término da execução da
     790função), ``percall`` é o quociente de ``cumtime`` dividido pelas
     791chamadas primitivas, e ``filename:lineno(function)`` fornece os dados
     792respectivos para cada função. A regra prática aqui é: Quanto mais no
     793topo uma função aparece nessa lista, mais custo computacional ela
     794acarreta. Logo é mais interessante para ser optimizada.
     795
     796Como usual, ``prun?`` fornece detalhes sobre como usar o "profiler" e
     797como entender a saída de dados.
     798
     799A saída de dados pode ser escrita em um objeto para permitir uma
     800análise mais detalhada:
     801
     802.. skip
     803
     804::
     805
     806    sage: %prun -r A*A
     807    sage: stats = _
     808    sage: stats?
     809
     810Note: digitando ``stats = prun -r A\*A`` obtém-se um erro de sintaxe
     811porque prun é um comando do IPython, não uma função comum.
     812
     813Para uma representação gráfica dos dados do "profiling", você pode
     814usar o "hotspot profiler", um pequeno script chamado
     815``hotshot2cachetree`` e o programa ``kcachegrind`` (apenas no Unix). O
     816mesmo exemplo agora com o "hotspot profiler":
     817
     818.. skip
     819
     820::
     821
     822    sage: k,a = GF(2**8, 'a').objgen()
     823    sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)])
     824    sage: import hotshot
     825    sage: filename = "pythongrind.prof"
     826    sage: prof = hotshot.Profile(filename, lineevents=1)
     827
     828.. skip
     829
     830::
     831
     832    sage: prof.run("A*A")
     833    <hotshot.Profile instance at 0x414c11ec>
     834    sage: prof.close()
     835
     836Isso resulta em um arquivo ``pythongrind.prof`` no diretório de
     837trabalho atual. Ele pode ser convertido para o formato cachegrind para
     838visualização.
     839
     840Em uma linha de comando do sistema, digite
     841
     842.. skip
     843
     844::
     845
     846    hotshot2calltree -o cachegrind.out.42 pythongrind.prof
     847
     848O arquivo de saída ``cachegrind.out.42`` pode ser examinado com
     849``kcachegrind``. Note que a convenção de nomes ``cachegrind.out.XX``
     850precisa ser obedecida.
  • new file doc/pt/tutorial/sagetex.rst

    diff --git a/doc/pt/tutorial/sagetex.rst b/doc/pt/tutorial/sagetex.rst
    new file mode 100644
    - +  
     1.. _sec-sagetex:
     2
     3****************
     4Usando o SageTeX
     5****************
     6
     7O pacote SageTeX permite que você insira resultados de cálculos feitos
     8com o Sage em um documento LaTeX. Esse pacote já vem com o Sage. Para
     9usá-lo, você precisa "instalá-lo" em seu sistema LaTeX local; aqui
     10instalar significa copiar um simples arquivo. Veja :ref:`installation`
     11neste tutorial e a seção "Make SageTeX known to TeX" do `Guia de
     12instalação do Sage <http://sagemath.org/doc/installation/index.html>`_
     13(em inglês) (`este link <../installation/index.html>`_ deve levá-lo a
     14uma cópia local do guia de instalação para mais informações de como
     15proceder.
     16
     17Aqui vai um breve exemplo de como usar o SageTeX. A documentação
     18completa pode ser encontrada em
     19``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``, onde
     20``SAGE_ROOT`` é o diretório onde se encontra a sua instalação. Esse
     21diretório contém a documentação, um arquivo de exemplo, e alguns
     22scripts em Python possivelmente úteis.
     23
     24Para ver como o SageTeX funciona, siga as instruções para instalar o
     25SageTeX (em :ref:`installation`) e copie o seguinte texto em um
     26arquivo chamado ``st_example.tex``, por exemplo.
     27
     28.. warning::
     29
     30  O texto abaixo vai apresentar diversos erros sobre "unknown control
     31  sequences" se você está visualizando isto na ajuda "live". Use a
     32  versão estática para ver o texto corretamente.
     33
     34.. code-block:: latex
     35
     36    \documentclass{article}
     37    \usepackage{sagetex}
     38
     39    \begin{document}
     40
     41    Using Sage\TeX, one can use Sage to compute things and put them into
     42    your \LaTeX{} document. For example, there are
     43    $\sage{number_of_partitions(1269)}$ integer partitions of $1269$.
     44    You don't need to compute the number yourself, or even cut and paste
     45    it from somewhere.
     46
     47    Here's some Sage code:
     48
     49    \begin{sageblock}
     50        f(x) = exp(x) * sin(2*x)
     51    \end{sageblock}
     52
     53    The second derivative of $f$ is
     54
     55    \[
     56      \frac{\mathrm{d}^{2}}{\mathrm{d}x^{2}} \sage{f(x)} =
     57      \sage{diff(f, x, 2)(x)}.
     58    \]
     59
     60    Here's a plot of $f$ from $-1$ to $1$:
     61
     62    \sageplot{plot(f, -1, 1)}
     63
     64    \end{document}
     65
     66Execute o LaTeX em ``st_example.tex`` da forma usual. Note que o LaTeX
     67vai reclamar sobre algumas coisas, entre elas::
     68
     69    Package sagetex Warning: Graphics file
     70    sage-plots-for-st_example.tex/plot-0.eps on page 1 does not exist. Plot
     71    command is on input line 25.
     72
     73    Package sagetex Warning: There were undefined Sage formulas and/or
     74    plots. Run Sage on st_example.sage, and then run LaTeX on
     75    st_example.tex again.
     76
     77Observe que, além dos arquivos usuais produzidos pelo LaTeX, existe um
     78arquivo chamado ``st_example.sage``. Esse é um script em Sage
     79produzido quando você executa o LaTeX em ``st_example.tex``. A
     80mensagem de alerta pede para você executar o LaTeX em
     81``st_example.sage``, então siga essa sugestão e faça isso. Você vai
     82receber uma mensagem para executar o LaTeX em ``st_example.tex``
     83novamente, mas antes que você faça isso, observe que um novo arquivo
     84foi criado: ``st_example.sout``. Esse arquivo contém os resultados dos
     85cálculos feitos pelo Sage, em um formato que o LaTeX pode usar para
     86inserir em seu texto. Um novo diretório contendo um arquivo EPS do seu
     87gráfico também foi criado. Execute o LaTeX novamente e você vai ver
     88que tudo que foi calculado, incluindo os gráficos, foi incluído em seu
     89documento.
     90
     91As macros utilizadas acima devem ser fáceis de entender. Um
     92environment ``sageblock`` insere código "verbatim" (exatamente como é
     93digitado) e também executa o código quando você executa o Sage. Quando
     94você insere ``\sage{foo}``, é incluído em seu documento o resultado
     95que você obteria executando ``latex(foo)`` no Sage. Comandos para
     96fazer gráficos são um pouco mais complicados, mas em sua forma mais
     97simples, ``\sageplot{foo}`` insere a imagem que você obtêm usando
     98``foo.save('filename.eps')``.
     99
     100Em geral, a rotina é a seguinte:
     101
     102    - execute o LaTeX no seu arquivo .tex;
     103    - execute o Sage no arquivo .sage que foi gerado;
     104    - execute o LaTeX novamente.
     105
     106Você pode omitir a execução do Sage desde que você não tenha alterado
     107os comandos em Sage em seu documento.
     108
     109Há muito mais sobre o SageTeX, e como tanto o Sage como o LaTeX são
     110ferramentas complexas e poderosas, é uma boa idéia ler a documentação
     111para o SageTeX que se encontra em
     112``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``.
  • new file doc/pt/tutorial/tour.rst

    diff --git a/doc/pt/tutorial/tour.rst b/doc/pt/tutorial/tour.rst
    new file mode 100644
    - +  
     1*****************
     2Um passeio guiado
     3*****************
     4
     5Esta seção é um passeio guiado pelo que está disponível no Sage. Para
     6diversos outros exemplos, veja "Construções em Sage", que tem como
     7objetivo responder à questão geral "Como eu construo ...?". Veja
     8também o "Sage Reference Manual", que possui centenas de outros
     9exemplos. Note que é também possível percorrer este tutorial no Sage
     10Notebook clicando no link ``Help``.
     11
     12(Se você está acessando este tutorial no Sage Notebook, pressione
     13``shift-enter`` para processar qualquer célula de entrada. Você pode
     14até editar a célula antes de pressionar ``shift-enter``. Em alguns
     15Macs pode ser necessário pressionar ``shift-return`` em vez de
     16``shift-enter``.)
     17
     18.. toctree::
     19
     20   tour_assignment
     21   tour_help
     22   tour_algebra
     23   tour_plotting
     24   tour_functions
     25   tour_rings
     26   tour_linalg
     27   tour_polynomial
     28   tour_coercion
     29   tour_groups
     30   tour_numtheory
     31   tour_advanced
  • new file doc/pt/tutorial/tour_advanced.rst

    diff --git a/doc/pt/tutorial/tour_advanced.rst b/doc/pt/tutorial/tour_advanced.rst
    new file mode 100644
    - +  
     1Um Pouco Mais de Matemática Avançada
     2====================================
     3
     4Geometria Algébrica
     5-------------------
     6
     7Você pode definir variedades algébricas arbitrárias no Sage, mas as
     8vezes alguma funcionalidade não-trivial é limitada a anéis sobre
     9:math:`\QQ` ou corpos finitos. Por exemplo, vamos calcular a união de
     10duas curvas planas afim, e então recuperar as curvas como as
     11componentes irredutíveis da união.
     12
     13::
     14
     15    sage: x, y = AffineSpace(2, QQ, 'xy').gens()
     16    sage: C2 = Curve(x^2 + y^2 - 1)
     17    sage: C3 = Curve(x^3 + y^3 - 1)
     18    sage: D = C2 + C3
     19    sage: D
     20    Affine Curve over Rational Field defined by
     21       x^5 + x^3*y^2 + x^2*y^3 + y^5 - x^3 - y^3 - x^2 - y^2 + 1
     22    sage: D.irreducible_components()
     23    [
     24    Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
     25      x^2 + y^2 - 1,
     26    Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
     27      x^3 + y^3 - 1
     28    ]
     29
     30Você também pode encontrar todos os pontos de interseção das duas
     31curvas, intersectando-as, e então calculando as componentes
     32irredutíveis.
     33
     34.. link
     35
     36::
     37
     38    sage: V = C2.intersection(C3)
     39    sage: V.irreducible_components()
     40    [
     41    Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
     42      y - 1,
     43      x,
     44    Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
     45      y,
     46      x - 1,
     47    Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
     48      x + y + 2,
     49      2*y^2 + 4*y + 3
     50    ]
     51
     52Portanto, por exemplo, :math:`(1,0)` e :math:`(0,1)` estão em ambas as
     53curvas (o que é claramente visível), como também estão certos pontos
     54(quadráticos) cuja coordenada :math:`y` satisfaz :math:`2y^2 + 4y +
     553=0`.
     56
     57O Sage pode calcular o ideal toroidal da cúbica torcida no espaço-3
     58projetivo:
     59
     60::
     61
     62    sage: R.<a,b,c,d> = PolynomialRing(QQ, 4)
     63    sage: I = ideal(b^2-a*c, c^2-b*d, a*d-b*c)
     64    sage: F = I.groebner_fan(); F
     65    Groebner fan of the ideal:
     66    Ideal (b^2 - a*c, c^2 - b*d, -b*c + a*d) of Multivariate Polynomial Ring
     67    in a, b, c, d over Rational Field
     68    sage: F.reduced_groebner_bases ()
     69    [[-c^2 + b*d, -b*c + a*d, -b^2 + a*c],
     70     [c^2 - b*d, -b*c + a*d, -b^2 + a*c],
     71     [c^2 - b*d, b*c - a*d, -b^2 + a*c, -b^3 + a^2*d],
     72     [c^2 - b*d, b*c - a*d, b^3 - a^2*d, -b^2 + a*c],
     73     [c^2 - b*d, b*c - a*d, b^2 - a*c],
     74     [-c^2 + b*d, b^2 - a*c, -b*c + a*d],
     75     [-c^2 + b*d, b*c - a*d, b^2 - a*c, -c^3 + a*d^2],
     76     [c^3 - a*d^2, -c^2 + b*d, b*c - a*d, b^2 - a*c]]
     77    sage: F.polyhedralfan()
     78    Polyhedral fan in 4 dimensions of dimension 4
     79
     80Curvas Elípticas
     81----------------
     82
     83A funcionalidade para curvas elípticas inclui a maior parte da
     84funcionalidade para curvas elípticas do PARI, acesso aos dados da base
     85de dados Cremona (isso requer um pacote adicional), os recursos do
     86mwrank, isto é, "2-descends" com cálculos do grupo de Mordell-Weil
     87completo, o algoritmo SEA (singla em inglês), cálculo de todas as
     88isogenias, bastante código novo para curvas sobre :math:`\QQ`, e parte
     89do software "algebraic descent" de Denis Simons.
     90
     91O comando ``EllipticCurve`` para criar curvas elípticas possui várias
     92formas:
     93
     94
     95-  EllipticCurve([:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]):
     96   Fornece a curva elíptica
     97
     98   .. math::  y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6,
     99
     100
     101   onde os :math:`a_i`'s são coagidos para os parentes de :math:`a_1`.
     102   Se todos os :math:`a_i` possuem parente :math:`\ZZ`, então eles são
     103   coagidos para :math:`\QQ`.
     104
     105-  EllipticCurve([:math:`a_4`, :math:`a_6`]): Conforme acima, mas
     106   :math:`a_1=a_2=a_3=0`.
     107
     108-  EllipticCurve(label): Fornece a curva elíptica da base de dados
     109   Cremona com o "label" (novo) dado. O label é uma string, tal como
     110   ``"11a"`` ou ``"37b2"``. As letras devem ser minúsculas (para
     111   distinguir dos labels antigos).
     112
     113-  EllipticCurve(j): Fornece uma curva elíptica com invariante
     114   :math:`j`.
     115
     116-  EllipticCurve(R,
     117   [:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]):
     118   Cria uma curva elíptica sobre um anel :math:`R` com os
     119   :math:`a_i`'s.
     120
     121
     122Agora ilustramos cada uma dessas construções:
     123
     124::
     125
     126    sage: EllipticCurve([0,0,1,-1,0])
     127    Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
     128   
     129    sage: EllipticCurve([GF(5)(0),0,1,-1,0])
     130    Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5
     131   
     132    sage: EllipticCurve([1,2])
     133    Elliptic Curve defined by y^2  = x^3 + x + 2 over Rational Field
     134   
     135    sage: EllipticCurve('37a')
     136    Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
     137   
     138    sage: EllipticCurve_from_j(1)
     139    Elliptic Curve defined by y^2 + x*y = x^3 + 36*x + 3455 over Rational Field
     140   
     141    sage: EllipticCurve(GF(5), [0,0,1,-1,0])
     142    Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5
     143
     144O par :math:`(0,0)` é um ponto na curva elíptica :math:`E` definida
     145por :math:`y^2 + y = x^3 - x`. Para criar esse ponto digite
     146``E([0,0])``. O Sage pode somar pontos em uma curva elíptica
     147(lembre-se que é possível definir uma estrutura de grupo aditivo em
     148curvas elípticas onde o ponto no infinito é o elemento nulo, e a some
     149de três pontos colineares sobre a curva é zero):
     150
     151::
     152
     153    sage: E = EllipticCurve([0,0,1,-1,0])
     154    sage: E
     155    Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
     156    sage: P = E([0,0])
     157    sage: P + P
     158    (1 : 0 : 1)
     159    sage: 10*P
     160    (161/16 : -2065/64 : 1)
     161    sage: 20*P
     162    (683916417/264517696 : -18784454671297/4302115807744 : 1)
     163    sage: E.conductor()
     164    37
     165
     166As curvas elípticas sobre os números complexos são parametrizadas
     167pelo invariante :math:`j`. O Sage calcula o invariante :math:`j` da
     168seguinte forma:
     169
     170::
     171
     172    sage: E = EllipticCurve([0,0,0,-4,2]); E
     173    Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field
     174    sage: E.conductor()
     175    2368
     176    sage: E.j_invariant()
     177    110592/37     
     178
     179Se criarmos uma curva com o mesmo invariante :math:`j` que a curva
     180:math:`E`, ela não precisa ser isomórfica a :math:`E`. No seguinte
     181exemplo, as curvas não são isomórficas porque os seus condutores são
     182diferentes.
     183
     184::
     185
     186    sage: F = EllipticCurve_from_j(110592/37)
     187    sage: F.conductor()
     188    37
     189
     190Todavia, uma torção de :math:`F` por um fator 2 resulta em uma curva
     191isomórfica.
     192
     193.. link
     194
     195::
     196
     197    sage: G = F.quadratic_twist(2); G
     198    Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field
     199    sage: G.conductor()
     200    2368
     201    sage: G.j_invariant()
     202    110592/37
     203
     204Nós podemos calcular os coeficientes :math:`a_n` de uma
     205série-:math:`L` ou forma modular :math:`\sum_{n=0}^\infty
     206a_nq^n` associada à curva elíptica. Esse cálculo usa a biblioteca C do
     207PARI.
     208
     209::
     210
     211    sage: E = EllipticCurve([0,0,1,-1,0])
     212    sage: print E.anlist(30) 
     213    [0, 1, -2, -3, 2, -2, 6, -1, 0, 6, 4, -5, -6, -2, 2, 6, -4, 0, -12, 0, -4,
     214     3, 10, 2, 0, -1, 4, -9, -2, 6, -12]
     215    sage: v = E.anlist(10000)   
     216
     217Leva apenas um segundo para calcular todos os :math:`a_n` para
     218:math:`n\leq 10^5`:
     219
     220.. skip
     221
     222::
     223
     224    sage: %time v = E.anlist(100000)
     225    CPU times: user 0.98 s, sys: 0.06 s, total: 1.04 s
     226    Wall time: 1.06
     227
     228Curvas elípticas podem ser construídas usando o "label" da base de
     229dados Cremona. Isso importa a curva elíptica com informações prévias
     230sobre o seu posto, números de Tomagawa, regulador, etc.
     231
     232::
     233
     234    sage: E = EllipticCurve("37b2")
     235    sage: E
     236    Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational
     237    Field
     238    sage: E = EllipticCurve("389a")
     239    sage: E
     240    Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2*x  over Rational Field
     241    sage: E.rank()
     242    2
     243    sage: E = EllipticCurve("5077a")
     244    sage: E.rank()
     245    3
     246
     247Nós também podemos acessar a base de dados Cremona diretamente.
     248
     249::
     250
     251    sage: db = sage.databases.cremona.CremonaDatabase()
     252    sage: db.curves(37)
     253    {'a1': [[0, 0, 1, -1, 0], 1, 1], 'b1': [[0, 1, 1, -23, -50], 0, 3]}
     254    sage: db.allcurves(37)
     255    {'a1': [[0, 0, 1, -1, 0], 1, 1],
     256     'b1': [[0, 1, 1, -23, -50], 0, 3],
     257     'b2': [[0, 1, 1, -1873, -31833], 0, 1],
     258     'b3': [[0, 1, 1, -3, 1], 0, 3]}
     259
     260Os objetos obtidos pela base de dados não são do tipo
     261``EllipticCurve``. Eles são elementos de uma base de dados e possuem
     262alguns campos, e apenas isso. Existe uma versão básica da base de
     263dados Cremona, que já é distribuída na versão padrão do Sage, e contém
     264informações limitadas sobre curvas elípticas de condutor :math:`\leq
     26510000`. Existe também uma versão estendida opcional, que contém
     266informações extensas sobre curvas elípticas de condutor :math:`\leq
     267120000` (em outubro de 2005). Por fim, existe ainda uma versão (2GB)
     268opcional de uma base de dados para o Sage que contém centenas de
     269milhares de curvas elípticas na base de dados Stein-Watkins.
     270
     271Caracteres de Dirichlet
     272-----------------------
     273
     274Um *caractere de Dirichlet* é a extensão de um homomorfismo
     275:math:`(\ZZ/N\ZZ)* \to R^*`, para algum anel :math:`R`, para o mapa
     276:math:`\ZZ \to R` obtido mapeando os inteiros :math:`x` tais que
     277:math:`\gcd(N,x)>1` em 0.
     278
     279::
     280
     281    sage: G = DirichletGroup(12)
     282    sage: G.list()
     283    [Dirichlet character modulo 12 of conductor 1 mapping 7 |--> 1, 5 |--> 1,
     284    Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1,
     285    Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1,
     286    Dirichlet character modulo 12 of conductor 12 mapping 7 |--> -1, 5 |--> -1]
     287    sage: G.gens()
     288    (Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1,
     289    Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1)
     290    sage: len(G)
     291    4
     292
     293Tendo criado o grupo, a seguir calculamos um elemento e fazemos
     294cálculos com ele.
     295
     296.. link
     297
     298::
     299
     300    sage: G = DirichletGroup(21)
     301    sage: chi = G.1; chi
     302    Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6
     303    sage: chi.values()
     304    [0, 1, zeta6 - 1, 0, -zeta6, -zeta6 + 1, 0, 0, 1, 0, zeta6, -zeta6, 0, -1,
     305     0, 0, zeta6 - 1, zeta6, 0, -zeta6 + 1, -1]
     306    sage: chi.conductor()
     307    7
     308    sage: chi.modulus()
     309    21
     310    sage: chi.order()
     311    6
     312    sage: chi(19)
     313    -zeta6 + 1
     314    sage: chi(40)
     315    -zeta6 + 1
     316
     317É também possível calcular a ação do grupo de Galois
     318:math:`\text{Gal}(\QQ(\zeta_N)/\QQ)` sobre esses caracteres, bem como
     319a decomposição em produto direto correspondente à fatorização do
     320módulo.
     321
     322.. link
     323
     324::
     325
     326    sage: chi.galois_orbit()
     327    [Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6,
     328    Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> -zeta6 + 1]
     329   
     330    sage: go = G.galois_orbits()
     331    sage: [len(orbit) for orbit in go]
     332    [1, 2, 2, 1, 1, 2, 2, 1]
     333   
     334    sage: G.decomposition()
     335    [
     336    Group of Dirichlet characters of modulus 3 over Cyclotomic Field of order
     337    6 and degree 2,
     338    Group of Dirichlet characters of modulus 7 over Cyclotomic Field of order
     339    6 and degree 2
     340    ]
     341
     342A seguir, construímos o grupo de caracteres de Dirichlet mod 20, mas
     343com valores em :math:`\QQ(i)`:
     344
     345::
     346
     347    sage: K.<i> = NumberField(x^2+1)
     348    sage: G = DirichletGroup(20,K)
     349    sage: G
     350    Group of Dirichlet characters of modulus 20 over Number Field in i with defining polynomial x^2 + 1
     351
     352Agora calculamos diversos invariantes de ``G``:
     353
     354.. link
     355
     356::
     357
     358    sage: G.gens()
     359    (Dirichlet character modulo 20 of conductor 4 mapping 11 |--> -1, 17 |--> 1,
     360    Dirichlet character modulo 20 of conductor 5 mapping 11 |--> 1, 17 |--> i)
     361
     362    sage: G.unit_gens()
     363    [11, 17]
     364    sage: G.zeta()
     365    i
     366    sage: G.zeta_order()
     367    4
     368
     369No próximo exemplo criamos um caractere de Dirichlet com valores em um
     370corpo numérico. Nós especificamos explicitamente a escolha da raiz da
     371unidade no terceiro argumento do comando ``DirichletGroup`` abaixo.
     372
     373::
     374
     375    sage: x = polygen(QQ, 'x')
     376    sage: K = NumberField(x^4 + 1, 'a'); a = K.0
     377    sage: b = K.gen(); a == b
     378    True
     379    sage: K
     380    Number Field in a with defining polynomial x^4 + 1
     381    sage: G = DirichletGroup(5, K, a); G
     382    Group of Dirichlet characters of modulus 5 over Number Field in a with
     383    defining polynomial x^4 + 1
     384    sage: chi = G.0; chi
     385    Dirichlet character modulo 5 of conductor 5 mapping 2 |--> a^2
     386    sage: [(chi^i)(2) for i in range(4)]
     387    [1, a^2, -1, -a^2]
     388
     389Aqui ``NumberField(x^4 + 1, 'a')`` diz para o Sage usar o símbolo "a"
     390quando imprimir o que é ``K`` (um corpo numérico definido pelo
     391polinômio :math:`x^4 + 1`). O nome "a" não está declarado até então.
     392Uma vez que ``a = K.0`` (ou equivalentemente ``a = K.gen()``) é
     393calculado, o símbolo "a" representa a raiz do polinômio gerador
     394:math:`x^4+1`.
     395
     396Formas Modulares
     397----------------
     398
     399O Sage pode fazer alguns cálculos relacionados a formas modulares,
     400incluindo dimensões, calcular espaços de símbolos modulares,
     401operadores de Hecke, e decomposições.
     402
     403Existem várias funções disponíveis para calcular dimensões de espaços
     404de formas modulares. Por exemplo,
     405
     406::
     407
     408    sage: dimension_cusp_forms(Gamma0(11),2)
     409    1
     410    sage: dimension_cusp_forms(Gamma0(1),12)
     411    1
     412    sage: dimension_cusp_forms(Gamma1(389),2)
     413    6112
     414
     415A seguir ilustramos o cálculo dos operadores de Hecke em um espaço de
     416símbolos modulares de nível :math:`1` e peso :math:`12`.
     417
     418::
     419
     420    sage: M = ModularSymbols(1,12)
     421    sage: M.basis()
     422    ([X^8*Y^2,(0,0)], [X^9*Y,(0,0)], [X^10,(0,0)])
     423    sage: t2 = M.T(2)
     424    sage: t2
     425    Hecke operator T_2 on Modular Symbols space of dimension 3 for Gamma_0(1)
     426    of weight 12 with sign 0 over Rational Field
     427    sage: t2.matrix()
     428    [ -24    0    0]
     429    [   0  -24    0]
     430    [4860    0 2049]
     431    sage: f = t2.charpoly('x'); f
     432    x^3 - 2001*x^2 - 97776*x - 1180224
     433    sage: factor(f)
     434    (x - 2049) * (x + 24)^2
     435    sage: M.T(11).charpoly('x').factor()
     436    (x - 285311670612) * (x - 534612)^2
     437
     438Podemos também criar espaços para :math:`\Gamma_0(N)` e
     439:math:`\Gamma_1(N)`.
     440
     441
     442::
     443
     444    sage: ModularSymbols(11,2)
     445    Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign
     446     0 over Rational Field
     447    sage: ModularSymbols(Gamma1(11),2)
     448    Modular Symbols space of dimension 11 for Gamma_1(11) of weight 2 with
     449    sign 0 and over Rational Field
     450
     451Vamos calcular alguns polinômios característicos e expansões
     452:math:`q`.
     453
     454::
     455
     456    sage: M = ModularSymbols(Gamma1(11),2)
     457    sage: M.T(2).charpoly('x')
     458    x^11 - 8*x^10 + 20*x^9 + 10*x^8 - 145*x^7 + 229*x^6 + 58*x^5 - 360*x^4
     459         + 70*x^3 - 515*x^2 + 1804*x - 1452
     460    sage: M.T(2).charpoly('x').factor()
     461    (x - 3) * (x + 2)^2 * (x^4 - 7*x^3 + 19*x^2 - 23*x + 11)
     462            * (x^4 - 2*x^3 + 4*x^2 + 2*x + 11)
     463    sage: S = M.cuspidal_submodule()
     464    sage: S.T(2).matrix()
     465    [-2  0]
     466    [ 0 -2]
     467    sage: S.q_expansion_basis(10)
     468    [
     469        q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10)
     470    ]
     471
     472Podemos até mesmo calcular espaços de símbolos modulares com carácter.
     473
     474::
     475
     476    sage: G = DirichletGroup(13)
     477    sage: e = G.0^2
     478    sage: M = ModularSymbols(e,2); M
     479    Modular Symbols space of dimension 4 and level 13, weight 2, character
     480    [zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2
     481    sage: M.T(2).charpoly('x').factor()
     482    (x - 2*zeta6 - 1) * (x - zeta6 - 2) * (x + zeta6 + 1)^2
     483    sage: S = M.cuspidal_submodule(); S
     484    Modular Symbols subspace of dimension 2 of Modular Symbols space of
     485    dimension 4 and level 13, weight 2, character [zeta6], sign 0, over
     486    Cyclotomic Field of order 6 and degree 2
     487    sage: S.T(2).charpoly('x').factor()
     488    (x + zeta6 + 1)^2
     489    sage: S.q_expansion_basis(10)
     490    [
     491    q + (-zeta6 - 1)*q^2 + (2*zeta6 - 2)*q^3 + zeta6*q^4 + (-2*zeta6 + 1)*q^5
     492      + (-2*zeta6 + 4)*q^6 + (2*zeta6 - 1)*q^8 - zeta6*q^9 + O(q^10)
     493    ]
     494
     495Aqui está um outro exemplo de como o Sage pode calcular a ação de
     496operadores de Hecke em um espaço de formas modulares.
     497
     498::
     499
     500    sage: T = ModularForms(Gamma0(11),2)
     501    sage: T
     502    Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of
     503    weight 2 over Rational Field
     504    sage: T.degree()
     505    2
     506    sage: T.level()
     507    11
     508    sage: T.group()
     509    Congruence Subgroup Gamma0(11)
     510    sage: T.dimension()
     511    2
     512    sage: T.cuspidal_subspace()
     513    Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for
     514    Congruence Subgroup Gamma0(11) of weight 2 over Rational Field
     515    sage: T.eisenstein_subspace()
     516    Eisenstein subspace of dimension 1 of Modular Forms space of dimension 2
     517    for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field
     518    sage: M = ModularSymbols(11); M
     519    Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign
     520    0 over Rational Field
     521    sage: M.weight()
     522    2
     523    sage: M.basis()
     524    ((1,0), (1,8), (1,9))
     525    sage: M.sign()
     526    0
     527
     528Denote por :math:`T_p` os operadores de Hecke usuais (:math:`p`
     529primo).  Como os operadores de Hecke :math:`T_2`, :math:`T_3`,
     530e :math:`T_5` agem sobre o espaço de símbolos modulares?
     531
     532
     533.. link
     534
     535::
     536
     537    sage: M.T(2).matrix()
     538    [ 3  0 -1]
     539    [ 0 -2  0]
     540    [ 0  0 -2]
     541    sage: M.T(3).matrix()
     542    [ 4  0 -1]
     543    [ 0 -1  0]
     544    [ 0  0 -1]
     545    sage: M.T(5).matrix()
     546    [ 6  0 -1]
     547    [ 0  1  0]
     548    [ 0  0  1]
  • new file doc/pt/tutorial/tour_algebra.rst

    diff --git a/doc/pt/tutorial/tour_algebra.rst b/doc/pt/tutorial/tour_algebra.rst
    new file mode 100644
    - +  
     1Álgebra Elementar e Cálculo
     2===========================
     3
     4O Sage pode realizar diversos cálculos em álgebra elementar e cálculo
     5diferencial e integral: por exemplo, encontrar soluções de equações,
     6diferenciar, integrar, e calcular a transformada de Laplace. Veja a
     7documentação em `Sage Constructions
     8<http://www.sagemath.org/doc/constructions/>`_ para mais exemplos.
     9
     10Resolvendo equações
     11-------------------
     12
     13Resolvendo equações exatamente
     14~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     15
     16A função ``solve`` resolve equações. Para usá-la, primeiro especifique
     17algumas variáveis; então os argumentos de ``solve`` são uma equação
     18(ou um sistema de equações), juntamente com as variáveis para as
     19quais resolver:
     20
     21::
     22
     23    sage: x = var('x')
     24    sage: solve(x^2 + 3*x + 2, x)
     25    [x == -2, x == -1]
     26
     27Você pode resolver equações para uma variável em termos das outras:
     28
     29::
     30
     31    sage: x, b, c = var('x b c')
     32    sage: solve([x^2 + b*x + c == 0],x)
     33    [x == -1/2*b - 1/2*sqrt(b^2 - 4*c), x == -1/2*b + 1/2*sqrt(b^2 - 4*c)]
     34
     35Você pode resolver para diversas variáveis:
     36
     37::
     38
     39    sage: x, y = var('x, y')
     40    sage: solve([x+y==6, x-y==4], x, y)
     41    [[x == 5, y == 1]]
     42
     43O seguinte exemplo, que mostra como usar o Sage para resolver um
     44sistema de equações não-lineares, foi sugerido por Jason Grout:
     45primeiro, resolvemos o sistemas simbolicamente:
     46
     47::
     48
     49    sage: var('x y p q')
     50    (x, y, p, q)
     51    sage: eq1 = p+q==9
     52    sage: eq2 = q*y+p*x==-6
     53    sage: eq3 = q*y^2+p*x^2==24
     54    sage: solve([eq1,eq2,eq3,p==1],p,q,x,y)
     55    [[p == 1, q == 8, x == -4/3*sqrt(10) - 2/3, y == 1/6*sqrt(2)*sqrt(5) - 2/3],
     56     [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]]
     57
     58Para obter soluções numéricas aproximadas, podemos usar:
     59
     60.. link
     61
     62::
     63
     64    sage: solns = solve([eq1,eq2,eq3,p==1],p,q,x,y, solution_dict=True)
     65    sage: [[s[p].n(30), s[q].n(30), s[x].n(30), s[y].n(30)] for s in solns]
     66    [[1.0000000, 8.0000000, -4.8830369, -0.13962039],
     67     [1.0000000, 8.0000000, 3.5497035, -1.1937129]]
     68
     69(A função ``n`` imprime uma aproximação numérica, e o argumento é o
     70número de bits de precisão.)
     71
     72Resolvendo Equações Numericamente
     73~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     74
     75Frequentemente, ``solve`` não será capaz de encontrar uma solução
     76exata para uma equação ou sistema de equações. Nesse caso, você pode
     77usar ``find_root`` para encontrar uma solução numérica. Por exemplo,
     78``solve`` não encontra uma solução para a equação abaixo::
     79
     80    sage: theta = var('theta')
     81    sage: solve(cos(theta)==sin(theta), theta)
     82    [sin(theta) == cos(theta)]
     83
     84Por outro lado, podemos usar ``find_root`` para encontrar uma solução
     85para a equação acima no intervalo :math:`0 < \phi < \pi/2`::
     86
     87    sage: phi = var('phi')
     88    sage: find_root(cos(phi)==sin(phi),0,pi/2)
     89    0.785398163397448...
     90
     91Diferenciação, Integração, etc.
     92-------------------------------
     93
     94O Sage é capaz de diferenciar e integrar diversas funções. Por
     95exemplo, para diferenciar :math:`\sin(u)` com respeito a :math:`u`,
     96faça o seguinte:
     97
     98::
     99
     100    sage: u = var('u')
     101    sage: diff(sin(u), u)
     102    cos(u)
     103
     104Para calcular a quarta derivada de :math:`\sin(x^2)`:
     105
     106::
     107
     108    sage: diff(sin(x^2), x, 4)
     109    16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2)
     110
     111Para calcular as derivadas parciais de :math:`x^2+17y^2` com respeito
     112a *x* e *y*, respectivamente:
     113
     114::
     115
     116    sage: x, y = var('x,y')
     117    sage: f = x^2 + 17*y^2
     118    sage: f.diff(x)
     119    2*x
     120    sage: f.diff(y)
     121    34*y
     122
     123Passamos agora para integrais, tanto indefinidas como definidas. Para
     124calcular :math:`\int x\sin(x^2)\, dx` e :math:`\int_0^1
     125\frac{x}{x^2+1}\, dx`:
     126
     127::
     128
     129    sage: integral(x*sin(x^2), x)
     130    -1/2*cos(x^2)
     131    sage: integral(x/(x^2+1), x, 0, 1)
     132    1/2*log(2)
     133
     134Para calcular a decomposição em frações parciais de
     135:math:`\frac{1}{x^2-1}`:
     136
     137::
     138
     139    sage: f = 1/((1+x)*(x-1))
     140    sage: f.partial_fraction(x)
     141    1/2/(x - 1) - 1/2/(x + 1)
     142
     143.. _section-systems:
     144
     145Resolvendo Equações Diferenciais
     146--------------------------------
     147
     148Você pode usar o Sage para investigar equações diferenciais
     149ordinárias. Para resolver a equação :math:`x'+x-1=0`:
     150
     151::
     152
     153    sage: t = var('t')    # define a variable t
     154    sage: x = function('x',t)   # define x to be a function of that variable
     155    sage: DE = diff(x, t) + x - 1
     156    sage: desolve(DE, [x,t])
     157    (c + e^t)*e^(-t)
     158
     159Esse método usa a interface do Sage para o Maxima [Max]_. Logo, o
     160formato dos resultados é um pouco diferente de outros cálculos
     161realizados no Sage. Nesse caso, o resultado diz que a solução geral da
     162equação diferencial é :math:`x(t) = e^{-t}(e^{t}+c)`.
     163
     164Você pode calcular a transformada de Laplace também; a transformada de
     165Laplace de :math:`t^2e^t -\sin(t)` é calculada da seguinte forma:
     166
     167::
     168
     169    sage: s = var("s")
     170    sage: t = var("t")
     171    sage: f = t^2*exp(t) - sin(t)
     172    sage: f.laplace(t,s)
     173    2/(s - 1)^3 - 1/(s^2 + 1)
     174
     175A seguir, um exemplo mais complicado. O deslocamento, com respeito à
     176posição de equilíbrio, de duas massas presas a uma parede através de
     177molas, conforme a figura abaixo,
     178
     179::
     180
     181    |------\/\/\/\/\---|massa1|----\/\/\/\/\/----|massa2|
     182             mola1                    mola2
     183
     184é modelado pelo sistema de equações diferenciais de segunda ordem
     185
     186.. math::
     187
     188    m_1 x_1'' + (k_1+k_2) x_1 - k_2 x_2 = 0
     189
     190    m_2 x_2''+ k_2 (x_2-x_1) = 0,
     191
     192
     193
     194onde, para :math:`i=1,2`, :math:`m_{i}` é a massa do objeto *i*,
     195:math:`x_{i}` é o deslocamento com respeito à posição de equilíbrio da
     196massa *i*, e :math:`k_{i}` é a constante de mola para a mola *i*.
     197
     198**Exemplo:** Use o Sage para resolver o problema acima com
     199:math:`m_{1}=2`, :math:`m_{2}=1`, :math:`k_{1}=4`,
     200:math:`k_{2}=2`, :math:`x_{1}(0)=3`, :math:`x_{1}'(0)=0`,
     201:math:`x_{2}(0)=3`, :math:`x_{2}'(0)=0`.
     202
     203Solução: Primeiramente, calcule a transformada de Laplace da primeira
     204equação (usando a notação :math:`x=x_{1}`, :math:`y=x_{2}`):
     205
     206::
     207
     208    sage: de1 = maxima("2*diff(x(t),t, 2) + 6*x(t) - 2*y(t)")
     209    sage: lde1 = de1.laplace("t","s"); lde1
     210    2*(-?%at('diff(x(t),t,1),t=0)+s^2*'laplace(x(t),t,s)-x(0)*s)-2*'laplace(y(t),t,s)+6*'laplace(x(t),t,s)
     211
     212O resultado é um pouco difícil de ler, mas diz que
     213
     214.. math:: -2x'(0) + 2s^2*X(s) - 2sx(0) - 2Y(s) + 6X(s) = 0
     215
     216
     217(onde a transformada de Laplace de uma função em letra minúscula
     218:math:`x(t)` é a função em letra maiúscula :math:`X(s)`). Agora,
     219calcule a transformada de Laplace da segunda equação:
     220
     221::
     222
     223    sage: de2 = maxima("diff(y(t),t, 2) + 2*y(t) - 2*x(t)")
     224    sage: lde2 = de2.laplace("t","s"); lde2
     225    -?%at('diff(y(t),t,1),t=0)+s^2*'laplace(y(t),t,s)+2*'laplace(y(t),t,s)-2*'laplace(x(t),t,s)-y(0)*s
     226
     227O resultado significa que
     228
     229.. math:: -Y'(0) + s^2Y(s) + 2Y(s) - 2X(s) - sy(0) = 0.
     230
     231
     232Em seguida, substitua a condição inicial para :math:`x(0)`,
     233:math:`x'(0)`, :math:`y(0)`, e :math:`y'(0)`, e resolva as equações
     234resultantes:
     235
     236::
     237
     238    sage: var('s X Y')
     239    (s, X, Y)
     240    sage: eqns = [(2*s^2+6)*X-2*Y == 6*s, -2*X +(s^2+2)*Y == 3*s]
     241    sage: solve(eqns, X,Y)
     242    [[X == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4),
     243      Y == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]]
     244
     245Agora calcule a transformada de Laplace inversa para obter a resposta:
     246
     247::
     248
     249    sage: var('s t')
     250    (s, t)
     251    sage: inverse_laplace((3*s^3 + 9*s)/(s^4 + 5*s^2 + 4),s,t)
     252    cos(2*t) + 2*cos(t)
     253    sage: inverse_laplace((3*s^3 + 15*s)/(s^4 + 5*s^2 + 4),s,t)
     254    -cos(2*t) + 4*cos(t)
     255
     256Portanto, a solução é
     257
     258.. math:: x_1(t) = \cos(2t) + 2\cos(t), \quad x_2(t) = 4\cos(t) - \cos(2t).
     259
     260
     261Ela pode ser representada em um gráfico parametricamente usando os
     262comandos
     263
     264::
     265
     266    sage: t = var('t')
     267    sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\
     268    ...   (t, 0, 2*pi), rgbcolor=hue(0.9))
     269    sage: show(P)
     270
     271As componentes individuais podem ser representadas em gráfico usando
     272
     273::
     274
     275    sage: t = var('t')
     276    sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3))
     277    sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6))
     278    sage: show(p1 + p2)
     279
     280Leia mais sobre gráficos em :ref:`section-plot`. Veja a seção 5.5 de
     281[NagleEtAl2004]_ (em inglês) para mais informações sobre equações
     282diferenciais.
     283
     284
     285Método de Euler para Sistemas de Equações Diferenciais
     286------------------------------------------------------
     287
     288No próximo exemplo, vamos ilustrar o método de Euler para EDOs de
     289primeira e segunda ordem. Primeiro, relembramos a ideia básica para
     290equações de primeira ordem. Dado um problema de valor inicial da forma
     291
     292.. math::
     293
     294    y'=f(x,y), \quad y(a)=c,
     295
     296queremos encontrar o valor aproximado da solução em :math:`x=b` com
     297:math:`b>a`.
     298
     299Da definição de derivada segue que
     300
     301.. math::  y'(x) \approx \frac{y(x+h)-y(x)}{h},
     302
     303
     304onde :math:`h>0` é um número pequeno. Isso, juntamente com a equação
     305diferencial, implica que :math:`f(x,y(x))\approx
     306\frac{y(x+h)-y(x)}{h}`. Agora resolvemos para :math:`y(x+h)`:
     307
     308.. math::   y(x+h) \approx y(x) + h*f(x,y(x)).
     309
     310
     311Se chamarmos :math:`h f(x,y(x))` de "termo de correção", :math:`y(x)`
     312de "valor antigo de *y*", e :math:`y(x+h)` de "novo valor de *y*",
     313então essa aproximação pode ser reescrita como
     314
     315.. math::   y_{novo} \approx y_{antigo} + h*f(x,y_{antigo}).
     316
     317
     318Se dividirmos o intervalo de *a* até *b* em *n* partes, de modo que
     319:math:`h=\frac{b-a}{n}`, então podemos construir a seguinte tabela.
     320
     321============== ==================   ================
     322:math:`x`      :math:`y`            :math:`hf(x,y)`
     323============== ==================   ================
     324:math:`a`      :math:`c`            :math:`hf(a,c)`
     325:math:`a+h`    :math:`c+hf(a,c)`    ...
     326:math:`a+2h`   ...
     327...
     328:math:`b=a+nh` ???                  ...
     329============== ==================   ================
     330
     331
     332O objetivo é completar os espaços em branco na tabela, em uma linha
     333por vez, até atingirmos ???, que é a aproximação para :math:`y(b)`
     334usando o método de Euler.
     335
     336A ideia para sistemas de EDOs é semelhante.
     337
     338**Exemplo:** Aproxime numericamente :math:`z(t)` em :math:`t=1` usando
     3394 passos do método de Euler, onde :math:`z''+tz'+z=0`, :math:`z(0)=1`,
     340:math:`z'(0)=0`.
     341
     342Devemos reduzir a EDO de segunda ordem a um sistema de duas EDOs de
     343primeira ordem (usando :math:`x=z`, :math:`y=z'`) e aplicar o método
     344de Euler:
     345
     346::
     347
     348    sage: t,x,y = PolynomialRing(RealField(10),3,"txy").gens()
     349    sage: f = y; g = -x - y * t
     350    sage: eulers_method_2x2(f,g, 0, 1, 0, 1/4, 1)
     351          t                x            h*f(t,x,y)                y       h*g(t,x,y)
     352          0                1                  0.00                0           -0.25
     353        1/4              1.0                -0.062            -0.25           -0.23
     354        1/2             0.94                 -0.12            -0.48           -0.17
     355        3/4             0.82                 -0.16            -0.66          -0.081
     356          1             0.65                 -0.18            -0.74           0.022
     357
     358Portanto, :math:`z(1)\approx 0.65`.
     359
     360Podemos também representar em um gráfico os pontos :math:`(x,y)` para
     361obter uma figura da solução aproximada. A função
     362``eulers_method_2x2_plot`` fará isso; para usá-la, precisamos definir
     363funções *f* e *g* que recebam um argumento com três coordenadas (*t*,
     364*x*, *y*).
     365
     366::
     367
     368    sage: f = lambda z: z[2]        # f(t,x,y) = y
     369    sage: g = lambda z: -sin(z[1])  # g(t,x,y) = -sin(x)
     370    sage: P = eulers_method_2x2_plot(f,g, 0.0, 0.75, 0.0, 0.1, 1.0)
     371
     372A esta altura, ``P`` armazena dois gráficos: ``P[0]``, o gráfico de
     373*x* versus *t*, e ``P[1]``, o gráfico de *y* versus *t*. Podemos
     374visualizar os dois gráficos da seguinte forma:
     375
     376.. link
     377
     378::
     379
     380    sage: show(P[0] + P[1])
     381
     382(Para mais sobre gráficos, veja :ref:`section-plot`.)
     383
     384Funções Especiais
     385-----------------
     386
     387Diversos polinômios ortogonais e funções especiais estão
     388implementadas, usando tanto o PARI [GP]_ como o Maxima [Max]_. Isso
     389está documentado nas seções apropriadas ("Orthogonal polynomials" and
     390"Special functions", respectivamente) do manual de referência do Sage
     391(em inglês).
     392
     393::
     394
     395    sage: x = polygen(QQ, 'x')
     396    sage: chebyshev_U(2,x)
     397    4*x^2 - 1
     398    sage: bessel_I(1,1,"pari",250)
     399    0.56515910399248502720769602760986330732889962162109200948029448947925564096
     400    sage: bessel_I(1,1)
     401    0.565159103992485
     402    sage: bessel_I(2,1.1,"maxima")  # last few digits are random
     403    0.16708949925104899
     404
     405No momento, essas funções estão disponíveis na interface do Sage
     406apenas para uso numérico. Para uso simbólico, use a interface do
     407Maxima diretamente, como no seguinte exemplo:
     408
     409::
     410
     411    sage: maxima.eval("f:bessel_y(v, w)")
     412    'bessel_y(v,w)'
     413    sage: maxima.eval("diff(f,w)")
     414    '(bessel_y(v-1,w)-bessel_y(v+1,w))/2'
  • new file doc/pt/tutorial/tour_assignment.rst

    diff --git a/doc/pt/tutorial/tour_assignment.rst b/doc/pt/tutorial/tour_assignment.rst
    new file mode 100644
    - +  
     1Atribuição, Igualdade, e Aritmética
     2===================================
     3
     4Com pequenas exceções, o Sage utiliza a linguagem de programação
     5Python, logo a maioria dos livros de introdução ao Python vão ajudá-lo
     6a aprender Sage.
     7
     8O Sage usa ``=`` para atribuição, e usa ``==``, ``<=``, ``>=``, ``<``
     9e ``>`` para comparação:
     10
     11::
     12
     13    sage: a = 5
     14    sage: a
     15    5
     16    sage: 2 == 2
     17    True
     18    sage: 2 == 3
     19    False
     20    sage: 2 < 3
     21    True
     22    sage: a == 5
     23    True
     24
     25O Sage fornece todas as operações matemáticas básicas:
     26
     27::
     28
     29    sage: 2**3    #  ** means exponent
     30    8
     31    sage: 2^3     #  ^ is a synonym for ** (unlike in Python)
     32    8
     33    sage: 10 % 3  #  for integer arguments, % means mod, i.e., remainder
     34    1
     35    sage: 10/4
     36    5/2
     37    sage: 10//4   #  for integer arguments, // returns the integer quotient
     38    2
     39    sage: 4 * (10 // 4) + 10 % 4 == 10
     40    True
     41    sage: 3^2*4 + 2%5
     42    38
     43
     44O cálculo de uma expressão como ``3^2*4 + 2%5`` depende da ordem em
     45que as operações são aplicadas; isso é especificado na "tabela de
     46precedência" em :ref:`section-precedence`.
     47
     48O Sage também fornece várias funções matemáticas básicas; aqui estão
     49apenas alguns exemplos:
     50
     51::
     52
     53    sage: sqrt(3.4)
     54    1.84390889145858
     55    sage: sin(5.135)
     56    -0.912021158525540
     57    sage: sin(pi/3)
     58    1/2*sqrt(3)
     59
     60Como o último exemplo mostra, algumas expressões matemáticas retornam
     61valores 'exatos' em vez de aproximações numéricas. Para obter uma
     62aproximação numérica, use a função ``n`` ou o método ``n`` (ambos
     63possuem um nome longo, ``numerical_approx``, e a função ``N`` é o
     64mesma que ``n``). Essas funções aceitam o argumento opcional
     65``prec``, que é o número de bits de precisão requisitado, e
     66``digits``, que é o número de dígitos decimais de precisão
     67requisitado; o padrão é 53 bits de precisão.
     68
     69::
     70
     71    sage: exp(2)
     72    e^2
     73    sage: n(exp(2))
     74    7.38905609893065
     75    sage: sqrt(pi).numerical_approx()
     76    1.77245385090552
     77    sage: sin(10).n(digits=5)
     78    -0.54402
     79    sage: N(sin(10),digits=10)
     80    -0.5440211109
     81    sage: numerical_approx(pi, prec=200)
     82    3.1415926535897932384626433832795028841971693993751058209749
     83
     84O Python é uma linguagem "dinâmicamente digitada" (dynamically typed),
     85portanto o valor referido por cada variável possui um tipo associado a
     86ele, mas uma variável pode possuir valores de qualquer tipo em
     87determinado escopo:
     88
     89::
     90
     91    sage: a = 5   # a is an integer
     92    sage: type(a)
     93    <type 'sage.rings.integer.Integer'>
     94    sage: a = 5/3  # now a is a rational number
     95    sage: type(a)
     96    <type 'sage.rings.rational.Rational'>
     97    sage: a = 'hello'  # now a is a string
     98    sage: type(a)
     99    <type 'str'>
     100
     101A linguagem de programação C, que é "estaticamente digitada"
     102(statically typed), é muito diferente; uma variável que foi declarada
     103como int pode apenas armazenar um int em seu escopo.
     104
     105Uma potencial fonte de confusão em Python é que um inteiro literal que
     106começa com zero é tratado como um número octal, isto é, um número na
     107base 8.
     108
     109::
     110
     111    sage: 011
     112    9
     113    sage: 8 + 1
     114    9
     115    sage: n = 011
     116    sage: n.str(8)   # string representation of n in base 8
     117    '11'
     118
     119Isso é consistente com a linguagem de programação C.
  • new file doc/pt/tutorial/tour_coercion.rst

    diff --git a/doc/pt/tutorial/tour_coercion.rst b/doc/pt/tutorial/tour_coercion.rst
    new file mode 100644
    - +  
     1.. -*- coding: utf-8 -*-
     2
     3.. _section-coercion:
     4
     5============================
     6Parentes, Conversão e Coação
     7============================
     8
     9Esta seção pode parecer mais técnica do que as anteriores, mas
     10acreditamos que é importante entender o significado de parentes e
     11coação de modo a usar anéis e outras estruturas algébricas no Sage de
     12forma efetiva e eficiente.
     13
     14Note que vamos explicar algumas noções, mas não vamos mostrar aqui
     15como implementá-las. Um tutorial voltado à implementação está
     16disponível (em inglês) como um
     17`arquivo Sage <http://flask.sagenb.org/home/pub/82/>`_.
     18
     19Elementos
     20---------
     21
     22Caso se queira implementar um anel em Python, uma primeira aproximação
     23seria criar uma classe para os elementos ``X`` do anel e adicionar os
     24requeridos métodos (com underscores duplos) ``__add__``, ``__sub``,
     25``__mul__``, obviamente garantindo que os axiomas de anel são
     26verificados.
     27
     28Como o Python é uma linguagem "strongly typed" (ainda que "dynamically
     29typed"), poderia-se, pelo menos a princípio, esperar-se que fosse
     30implementado em Python uma classe para cada anel. No final das contas,
     31o Python contém um tipo ``<int>`` para os inteiros, um tipo
     32``<float>`` para os reais, e assim por diante. Mas essa estratégia
     33logo encontra uma limitação: Existe um número infinito de anéis, e não
     34se pode implementar um número infinito de classes.
     35
     36Em vez disso, poderia-se criar uma hierarquia de classes projetada
     37para implementar elementos de estruturas algébricas ubíquas, tais como
     38grupos, anéis, anéis comutativos, corpos, álgebras, e assim por
     39diante.
     40
     41Mas isso significa que elementos de anéis bastante diferentes podem
     42ter o mesmo tipo.
     43
     44::
     45
     46    sage: P.<x,y> = GF(3)[]
     47    sage: Q.<a,b> = GF(4,'z')[]
     48    sage: type(x)==type(a)
     49    True
     50
     51Por outro lado, poderia-se ter também classes diferentes em Python
     52fornecendo implementações diferentes da mesma estrutura matemática
     53(por exemplo, matrizes densas versus matrizes esparsas).
     54
     55::
     56
     57    sage: P.<a> = PolynomialRing(ZZ)
     58    sage: Q.<b> = PolynomialRing(ZZ, sparse=True)
     59    sage: R.<c> = PolynomialRing(ZZ, implementation='NTL')
     60    sage: type(a); type(b); type(c)
     61    <type 'sage.rings.polynomial.polynomial_integer_dense_flint.Polynomial_integer_dense_flint'>
     62    <class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_sparse'>
     63    <type 'sage.rings.polynomial.polynomial_integer_dense_ntl.Polynomial_integer_dense_ntl'>
     64
     65Isso apresenta dois problemas: Por um lado, se tivéssemos elementos
     66que são duas instancias da mesma classe, então poderia-se esperar que
     67o método ``__add__`` dessas classes permitisse somá-los; mas não
     68se deseja isso, se os elementos pertencem a anéis bastante diferentes.
     69Por outro lado, se possui-se elementos que pertencem a implementações
     70diferentes do mesmo anel, então gostaria-se de somá-los, mas isso não
     71pode ser feito diretamente se eles pertencem a classes diferentes em
     72Python.
     73
     74A solução para esses problemas é chamada coação e será explicada a
     75seguir.
     76
     77Todavia, é essencial que cada elemento saiba a qual pertence. Isso
     78está disponível através método ``parent()``:
     79
     80.. link
     81
     82::
     83
     84    sage: a.parent(); b.parent(); c.parent()
     85    Univariate Polynomial Ring in a over Integer Ring
     86    Sparse Univariate Polynomial Ring in b over Integer Ring
     87    Univariate Polynomial Ring in c over Integer Ring (using NTL)
     88
     89
     90Parentes e Categorias
     91---------------------
     92
     93De forma similar à hierarquia de classes em Python voltada para
     94elementos de estruturas algébricas, o Sage também fornece classes para
     95as estruturas algébricas que contém esses elementos. Estruturas
     96contendo elementos são chamadas "estruturas parente" no Sage, e existe
     97uma classe básica para elas. Paralelamente à hierarquia de noções
     98matemáticas, tem-se uma hierarquia de classes, a saber, para
     99conjuntos, anéis, corpos e assim por diante:
     100
     101::
     102
     103    sage: isinstance(QQ,Field)
     104    True
     105    sage: isinstance(QQ, Ring)
     106    True
     107    sage: isinstance(ZZ,Field)
     108    False
     109    sage: isinstance(ZZ, Ring)
     110    True
     111
     112Em álgebra, objetos que compartilham o mesmo tipo de estruturas
     113algébricas são agrupados nas assim chamadas "categorias". Logo, existe
     114uma analogia aproximada entre a hierarquia de classes em Sage e a
     115hierarquia de categorias. Todavia, essa analogia de classes em Python
     116e categorias não deve ser enfatizada demais. No final das contas,
     117categorias matemáticas também são implementadas no Sage:
     118
     119::
     120
     121    sage: Rings()
     122    Category of rings
     123    sage: ZZ.category()
     124    Category of euclidean domains
     125    sage: ZZ.category().is_subcategory(Rings())
     126    True
     127    sage: ZZ in Rings()
     128    True
     129    sage: ZZ in Fields()
     130    False
     131    sage: QQ in Fields()
     132    True
     133
     134Enquanto a hierarquia de classes no Sage é centrada nos detalhes de
     135implementação, a construção de categorias em Sage é mais centrada
     136na estrutura matemática. É possível implementar métodos e testes
     137gerais independentemente de uma implementação específica nas
     138categorias.
     139
     140Estruturas parentes em Sage são supostamente objetos únicos em Python.
     141Por exemplo, uma vez que um anel de polinômios sobre um certo anel
     142base e com uma certa lista de geradores é criada, o resultado é
     143arquivado:
     144
     145::
     146
     147    sage: RR['x','y'] is RR['x','y']
     148    True
     149
     150
     151Tipos versus Parentes
     152---------------------
     153
     154O tipo ``RingElement`` não deve ser confundido com a noção matemática
     155de elemento de anel; por razões práticas, as vezes um objeto é uma
     156instancia de ``RingElement`` embora ele não pertence a um anel:
     157
     158::
     159
     160    sage: M = Matrix(ZZ,2,3); M
     161    [0 0 0]
     162    [0 0 0]
     163    sage: isinstance(M, RingElement)
     164    True
     165
     166Enquanto *parentes* são únicos, elementos iguais de um parente em Sage
     167não são necessariamente idênticos. Isso contrasta com o comportamento
     168do Python para alguns (embora não todos) inteiros:
     169
     170::
     171
     172    sage: int(1) is int(1) # Python int
     173    True
     174    sage: int(-15) is int(-15)
     175    False
     176    sage: 1 is 1           # Sage Integer
     177    False
     178
     179É importante observar que elementos de anéis diferentes em geral não
     180podem ser distinguidos pelos seus tipos, mas sim por seus parentes:
     181
     182::
     183
     184    sage: a = GF(2)(1)
     185    sage: b = GF(5)(1)
     186    sage: type(a) is type(b)
     187    True
     188    sage: parent(a)
     189    Finite Field of size 2
     190    sage: parent(b)
     191    Finite Field of size 5
     192
     193Logo, de um ponto de vista algébrico, **o parente de um elemento é
     194mais importante do que seu tipo.**
     195
     196Conversão versus Coação
     197-----------------------
     198
     199Em alguns casos é possível converter um elemento de uma estrutura
     200parente em um elemento de uma outra estrutura parente. Tal conversão
     201pode ser tanto explícita como implícita (essa é chamada *coação*).
     202
     203O leitor pode conhecer as noções de *conversão de tipo* e *coação de
     204tipo* como na linguagem C, por exemplo. Existem noções de *conversão*
     205e *coação* em Sage também. Mas as noções em Sage são centradas em
     206*parentes*, não em tipos. Então, por favor não confunda conversão de
     207tipo em C com conversão em Sage!
     208
     209Aqui se encontra uma breve apresentação. Para uma descrição detalhada
     210e informações sobre a implementação, referimos à seção sobre coação no
     211manual de referência e para o `arquivo tutorial
     212<http://flask.sagenb.org/home/pub/82/>`_.
     213
     214Existem duas possibilidades extremas com respeito à possibilidade de
     215fazer aritmética com elementos de *anéis diferentes*:
     216
     217* Anéis diferentes são mundos diferentes, e não faz nenhum sentido
     218  somar ou multiplicar elementos de anéis diferentes; mesmo ``1 +
     219  1/2`` não faz sentido, pois o primeiro somando é um inteiro e o
     220  segundo um racional.
     221
     222Ou
     223
     224* Se um elemento ``r1`` de uma aner ``R1`` pode de alguma forma ser
     225  interpretado em um outro anel ``R2``, então todas as operações
     226  aritméticas envolvendo ``r1`` e qualquer elemento de ``R2`` são
     227  permitidas. O elemento neutro da multiplicação existe em todos os
     228  corpos e em vários anéis, e eles devem ser todos iguais.
     229
     230O Sage faz uma concessão. Se ``P1`` e ``P2`` são estruturas parentes e
     231``p1`` é um elemento de ``P1``, então o usuário pode explicitamente
     232perguntar por uma interpretação de ``p1`` em ``P2``. Isso pode não
     233fazer sentido em todos os casos ou não estar definido para todos os
     234elementos de ``P1``, e fica a cargo do usuário assegurar que isso faz
     235sentido. Nos referimos a isso como **conversão**:
     236
     237::
     238
     239    sage: a = GF(2)(1)
     240    sage: b = GF(5)(1)
     241    sage: GF(5)(a) == b
     242    True
     243    sage: GF(2)(b) == a
     244    True
     245
     246Todavia, uma conversão *implícita* (ou automática) ocorrerá apenas se
     247puder ser feita *completamente* e *consistentemente*. Rigor matemático
     248é essencial nesse ponto.
     249
     250Uma tal conversão implícita é chamada **coação**. Se coação for
     251definida, então deve coincidir com conversão. Duas condições devem ser
     252satisfeitas para uma coação ser definida:
     253
     254#. Uma coação de ``P1`` para ``P2`` deve ser dada por uma estrutura
     255   que preserva mapeamentos (por exemplo, um homomorfismo de anéis).
     256   Não é suficiente que *alguns* elementos de ``P1`` possam ser
     257   mapeados em ``P2``, e o mapa deve respeitar a estrutura algébrica
     258   de ``P1``.
     259#. A escolha desses mapas de coação deve ser consistente: Se ``P3`` é
     260   uma terceira estrutura parente, então a composição da coação
     261   adotada de ``P1`` para ``P2`` com a coação de ``P2`` para ``P3``
     262   deve coincidir com a coação adotada de ``P1`` para ``P3``. Em
     263   particular, se existir uma coação de ``P1`` para ``P2`` e ``P2``
     264   para ``P1``, a composição deve ser o mapa identidade em ``P1``.
     265
     266Logo, embora é possível converter cada elemento de ``GF(2)`` para
     267``GF(5)``, não há coação, pois não existe homomorfismo de anel entre
     268``GF(2)`` e ``GF(5)``.
     269
     270O segundo aspecto - consistência - é um pouco mais difícil de
     271explicar. Vamos ilustrá-lo usando anéis de polinômios em mais de uma
     272variável. Em aplicações, certamente faz mais sentido ter coações que
     273preservam nomes. Então temos:
     274
     275::
     276
     277    sage: R1.<x,y> = ZZ[]
     278    sage: R2 = ZZ['y','x']
     279    sage: R2.has_coerce_map_from(R1)
     280    True
     281    sage: R2(x)
     282    x
     283    sage: R2(y)
     284    y
     285
     286Se não existir homomorfismo de anel que preserve nomes, coerção não é
     287definida. Todavia, conversão pode ainda ser possível, a saber,
     288mapeando geradores de anel de acordo com sua posição da lista de
     289geradores:
     290
     291.. link
     292
     293::
     294
     295    sage: R3 = ZZ['z','x']
     296    sage: R3.has_coerce_map_from(R1)
     297    False
     298    sage: R3(x)
     299    z
     300    sage: R3(y)
     301    x
     302
     303Mas essas conversões que preservam a posição não se qualificam como
     304coação: Compondo um mapa que preserva nomes de ``ZZ['x','y']`` para
     305``ZZ['y','x']``, com um mapa que preserva nomes de ``ZZ['y','x']``
     306para ``ZZ['a','b']``, resultaria em um mapa que não preserva nomes nem
     307posição, violando a consistência.
     308
     309Se houver coação, ela será usada para comparar elementos de anéis
     310diferentes ou fazer aritmética. Isso é frequentemente conveniente, mas
     311o usuário deve estar ciente que estender a relação ``==`` além das
     312fronteiras de parentes diferentes pode facilmente resultar em
     313problemas. Por exemplo, enquanto ``==`` é supostamente uma relação de
     314equivalência sobre os elementos de *um* anel, isso não é
     315necessariamente o caso se anéis *diferentes* estão envolvidos. Por
     316exemplo, ``1`` em ``ZZ`` e em um corpo finito são considerados iguais,
     317pois existe uma coação canônica dos inteiros em qualquer corpo finito.
     318Todavia, em geral não existe coação entre dois corpos finitos
     319diferentes. Portanto temos
     320
     321.. link
     322
     323::
     324
     325    sage: GF(5)(1) == 1
     326    True
     327    sage: 1 == GF(2)(1)
     328    True
     329    sage: GF(5)(1) == GF(2)(1)
     330    False
     331    sage: GF(5)(1) != GF(2)(1)
     332    True
     333
     334Similarmente,
     335
     336.. link
     337
     338::
     339
     340    sage: R3(R1.1) == R3.1
     341    True
     342    sage: R1.1 == R3.1
     343    False
     344    sage: R1.1 != R3.1
     345    True
     346
     347Uma outra consequência da condição de consistência é que coação pode
     348apenas ir de anéis exatos (por exemplo, os racionais ``QQ``) para
     349anéis não-exatos (por exemplo, os números reais com uma precisão fixa
     350``RR``), mas não na outra direção. A razão é que a composição da
     351coação de ``QQ`` em ``RR`` com a conversão de ``RR`` para ``QQ``
     352deveria ser a identidade em ``QQ``. Mas isso é impossível, pois alguns
     353números racionais distintos podem ser tratados como iguais em ``RR``,
     354como no seguinte exemplo:
     355
     356::
     357
     358    sage: RR(1/10^200+1/10^100) == RR(1/10^100)
     359    True
     360    sage: 1/10^200+1/10^100 == 1/10^100
     361    False
     362
     363Quando se compara elementos de dois parentes ``P1`` e ``P2``, é
     364possível que não haja coação entre os dois anéis, mas existe uma
     365escolha canônica de um parente ``P3`` de modo que tanto ``P1`` como
     366``P2`` são coagidos em ``P3``. Nesse caso, coação vai ocorrer também.
     367Um caso de uso típico é na soma de um número racional com um polinômio
     368com coeficientes inteiros, resultando em um polinômio com coeficientes
     369racionais:
     370
     371::
     372
     373    sage: P1.<x> = ZZ[]
     374    sage: p = 2*x+3
     375    sage: q = 1/2
     376    sage: parent(p)
     377    Univariate Polynomial Ring in x over Integer Ring
     378    sage: parent(p+q)
     379    Univariate Polynomial Ring in x over Rational Field
     380
     381Note que a princípio o resultado deveria também fazer sentido no
     382corpo de frações de ``ZZ['x']``. Todavia, o Sage tenta escolher um
     383parente *canônico* comum que parece ser o mais natural (``QQ['x']`` no
     384nosso exemplo). Se vários potenciais parentes comuns parecem
     385igualmente naturais, o Sage *não* vai escolher um deles
     386aleatoriamente. Os mecanismos sobre os quais essa escolha se baseia é
     387explicado em um `arquivo tutorial
     388<http://flask.sagenb.org/home/pub/82/>`_
     389
     390Nenhuma coação para um parente comum vai ocorrer no seguinte exemplo:
     391
     392::
     393
     394    sage: R.<x> = QQ[]
     395    sage: S.<y> = QQ[]
     396    sage: x+y
     397    Traceback (most recent call last):
     398    ...
     399    TypeError: unsupported operand parent(s) for '+': 'Univariate Polynomial Ring in x over Rational Field' and 'Univariate Polynomial Ring in y over Rational Field'
     400
     401A razão é que o Sage não escolhe um dos potenciais candidatos
     402``QQ['x']['y']``, ``QQ['y']['x']``, ``QQ['x','y']`` ou
     403``QQ['y','x']``, porque todas essas estruturas combinadas em pares
     404diferentes parecem ser parentes comuns naturais, e não existe escolha
     405canônica aparente.
  • new file doc/pt/tutorial/tour_functions.rst

    diff --git a/doc/pt/tutorial/tour_functions.rst b/doc/pt/tutorial/tour_functions.rst
    new file mode 100644
    - +  
     1.. _section-functions-issues:
     2
     3Algumas Questões Frequentes sobre Funções
     4=========================================
     5
     6Alguns aspectos sobre definição de funções (por exemplo, para
     7diferenciação, ou para criar gráficos) podem se tornar confusos. Nesta
     8seção, procuramos tratar algumas questões relevantes.
     9
     10Aqui estão várias formas de definir objetos que merecem ser chamamos
     11de "funções":
     12
     131. Defina uma função em Python, como descrito em
     14:ref:`section-functions`. Essas funções podem ser usadas para criar
     15gráficos, mas não podem ser diferenciadas ou integradas.
     16
     17::
     18
     19       sage: def f(z): return z^2
     20       sage: type(f)
     21       <type 'function'>
     22       sage: f(3)
     23       9
     24       sage: plot(f, 0, 2)
     25
     26Na última linha, observe a sintaxe. Se fosse usado ``plot(f(z), 0,
     272)`` ocorreria um erro, porque ``z`` é uma variável muda na definição
     28de ``f`` e não está definida fora do contexto da função. De fato,
     29somente ``f(z)`` já provoca um erro. Os seguintes comandos vão
     30funcionar neste caso, embora em geral eles devam ser evitados pois
     31podem ocasionar erros (veja o item 4 abaixo).
     32
     33.. link
     34
     35::
     36
     37       sage: var('z')   # define z to be a variable
     38       z
     39       sage: f(z)
     40       z^2
     41       sage: plot(f(z), 0, 2)
     42
     43Acima, ``f(z)`` é uma expressão simbólica, o próximo item na nossa
     44lista.
     45
     462. Defina um "expressão simbólica que pode ser evocada". Essas podem
     47ser usadas para criar gráficos, e podem ser diferenciadas ou
     48integradas.
     49
     50::
     51
     52       sage: g(x) = x^2
     53       sage: g        # g sends x to x^2
     54       x |--> x^2
     55       sage: g(3)
     56       9
     57       sage: Dg = g.derivative(); Dg
     58       x |--> 2*x
     59       sage: Dg(3)
     60       6
     61       sage: type(g)
     62       <type 'sage.symbolic.expression.Expression'>
     63       sage: plot(g, 0, 2)
     64
     65Note que enquanto ``g`` é uma expressão simbólica que pode ser
     66evocada, ``g(x)`` é um objeto diferente, embora relacionado, que pode
     67ser usado para criar gráficos, ou ser diferenciado, integrado, etc.,
     68embora com algumas ressalvas: veja o item 5 abaixo.
     69
     70.. link
     71
     72::
     73
     74       sage: g(x)
     75       x^2
     76       sage: type(g(x))
     77       <type 'sage.symbolic.expression.Expression'>
     78       sage: g(x).derivative()
     79       2*x
     80       sage: plot(g(x), 0, 2)
     81
     823. Use uma função pré-definida. Essas podem ser representadas em
     83gráfico, e com uma pequena ajuda, diferenciadas e integradas.
     84
     85::
     86
     87       sage: type(sin)
     88       <class 'sage.functions.trig.Function_sin'>
     89       sage: plot(sin, 0, 2)
     90       sage: type(sin(x))
     91       <type 'sage.symbolic.expression.Expression'>
     92       sage: plot(sin(x), 0, 2)
     93       
     94Por si só, ``sin`` não pode ser diferenciado, pelo menos não para
     95produzir ``cos``.
     96
     97::
     98
     99       sage: f = sin   
     100       sage: f.derivative()
     101       Traceback (most recent call last):
     102       ...
     103       AttributeError: ...
     104
     105Usando ``f = sin(x)`` no lugar de ``sin`` funciona, mas é ainda melhor
     106usar ``f(x) = sin(x)`` para definir uma expressão simbólica que pode
     107ser evocada.
     108
     109::
     110   
     111       sage: S(x) = sin(x)
     112       sage: S.derivative()
     113       x |--> cos(x)
     114       
     115Aqui estão alguns problemas comuns, com explicações:
     116
     117\4. Cálculo acidental.
     118
     119::
     120
     121       sage: def h(x):
     122       ...       if x<2:
     123       ...           return 0
     124       ...       else:
     125       ...           return x-2
     126
     127O problema: ``plot(h(x), 0, 4)`` cria o gráfico da reta `y=x-2`, não
     128da função definida por ``h``. O motivo? No comando ``plot(h(x), 0,
     1294)``, primeiro ``h(x)`` é calculada: isso significa substituir ``x``
     130na função ``h``, o que significa que ``x<2`` é calculado.
     131
     132.. link
     133
     134::
     135
     136       sage: type(x<2)
     137       <type 'sage.symbolic.expression.Expression'>
     138
     139Quando uma equação simbólica é calculada, como na definição de ``h``,
     140se ela não é obviamente verdadeira, então ela retorna False. Logo
     141``h(x)`` é calculada como ``x-2``, e essa é a função que será
     142representada no gráfico.
     143
     144A solução: não use ``plot(h(x), 0, 4)``; em vez disso, use
     145
     146.. link
     147
     148::
     149
     150       sage: plot(h, 0, 4)
     151
     152\5. Acidentalmente produzindo uma constante em vez de uma função.
     153
     154::
     155
     156       sage: f = x
     157       sage: g = f.derivative()
     158       sage: g
     159       1
     160
     161O problema: ``g(3)``, por exemplo, retorna o erro "ValueError: the
     162number of arguments must be less than or equal to 0."
     163
     164.. link
     165
     166::
     167
     168       sage: type(f)
     169       <type 'sage.symbolic.expression.Expression'>
     170       sage: type(g)
     171       <type 'sage.symbolic.expression.Expression'>
     172       
     173``g`` não é uma função, é uma constante, logo não possui variáveis
     174associadas, e você não pode substituir nenhum valor em ``g``.
     175
     176Solução: existem vária opções.
     177
     178- Defina ``f`` inicialmente como uma expressão simbólica.
     179
     180::
     181
     182         sage: f(x) = x        # instead of 'f = x'
     183         sage: g = f.derivative()
     184         sage: g
     185         x |--> 1
     186         sage: g(3)
     187         1
     188         sage: type(g)
     189         <type 'sage.symbolic.expression.Expression'>
     190
     191- Ou com ``f`` como definida originalmente, defina ``g`` como uma
     192  expressão simbólica.
     193
     194::
     195
     196         sage: f = x
     197         sage: g(x) = f.derivative()  # instead of 'g = f.derivative()'
     198         sage: g
     199         x |--> 1
     200         sage: g(3)
     201         1
     202         sage: type(g)
     203         <type 'sage.symbolic.expression.Expression'>
     204
     205- Ou com ``f`` e ``g`` como definidas originalmente, especifique a
     206  variável para a qual você está substituindo.
     207
     208::
     209
     210         sage: f = x
     211         sage: g = f.derivative()
     212         sage: g
     213         1
     214         sage: g(x=3)    # instead of 'g(3)'
     215         1
     216
     217Finalmente, aqui vai mais uma forma de saber a diferença entre as
     218derivadas de ``f = x`` e ``f(x) = x``.
     219
     220::
     221
     222       sage: f(x) = x
     223       sage: g = f.derivative()
     224       sage: g.variables()  # the variables present in g
     225       ()
     226       sage: g.arguments()  # the arguments which can be plugged into g
     227       (x,)
     228       sage: f = x
     229       sage: h = f.derivative()
     230       sage: h.variables()
     231       ()
     232       sage: h.arguments()
     233       ()
     234       
     235Como esse exemplo procura ilustrar, ``h`` não aceita argumentos, e é
     236por isso que ``h(3)`` retorna um erro.
  • new file doc/pt/tutorial/tour_groups.rst

    diff --git a/doc/pt/tutorial/tour_groups.rst b/doc/pt/tutorial/tour_groups.rst
    new file mode 100644
    - +  
     1Grupos Finitos, Grupos Abelianos
     2================================
     3
     4O Sage possui suporte para fazer cálculos com grupos de permutação,
     5grupos finitos clássicos (tais como :math:`SU(n,q)`), grupos
     6matriciais finitos (com os seus próprios geradores), e grupos
     7abelianos (até mesmo infinitos). A maior parte disso é implementada
     8usando a interface com o GAP.
     9
     10Por exemplo, para criar um grupo de permutação, forneça uma lista de
     11geradores, como no seguinte exemplo.
     12
     13::
     14
     15    sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)'])
     16    sage: G
     17    Permutation Group with generators [(3,4), (1,2,3)(4,5)]
     18    sage: G.order()
     19    120
     20    sage: G.is_abelian()
     21    False
     22    sage: G.derived_series()           # random-ish output
     23    [Permutation Group with generators [(1,2,3)(4,5), (3,4)],
     24     Permutation Group with generators [(1,5)(3,4), (1,5)(2,4), (1,3,5)]]
     25    sage: G.center()
     26    Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()]
     27    sage: G.random_element()           # random output
     28    (1,5,3)(2,4)
     29    sage: print latex(G)
     30    \langle (3,4), (1,2,3)(4,5) \rangle
     31
     32Você pode também obter a tabela de caracteres (em formato LaTeX) no
     33Sage:
     34
     35::
     36
     37    sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]])
     38    sage: latex(G.character_table())
     39    \left(\begin{array}{rrrr}
     40    1 & 1 & 1 & 1 \\
     41    1 & 1 & -\zeta_{3} - 1 & \zeta_{3} \\
     42    1 & 1 & \zeta_{3} & -\zeta_{3} - 1 \\
     43    3 & -1 & 0 & 0
     44    \end{array}\right)
     45
     46O Sage também inclui grupos clássicos matriciais sobre corpos finitos:
     47
     48::
     49
     50    sage: MS = MatrixSpace(GF(7), 2)
     51    sage: gens = [MS([[1,0],[-1,1]]),MS([[1,1],[0,1]])]
     52    sage: G = MatrixGroup(gens)
     53    sage: G.conjugacy_class_representatives()
     54        [
     55        [1 0]
     56        [0 1],
     57        [0 1]
     58        [6 1],
     59        ...
     60        [6 0]
     61        [0 6]
     62        ]
     63    sage: G = Sp(4,GF(7))
     64    sage: G._gap_init_()
     65    'Sp(4, 7)'
     66    sage: G
     67    Symplectic Group of rank 2 over Finite Field of size 7
     68    sage: G.random_element()             # random output
     69    [5 5 5 1]
     70    [0 2 6 3]
     71    [5 0 1 0]
     72    [4 6 3 4]
     73    sage: G.order()
     74    276595200
     75
     76Você também pode fazer cálculos usando grupos abelianos (finitos ou
     77infinitos):
     78
     79::
     80
     81    sage: F = AbelianGroup(5, [5,5,7,8,9], names='abcde')
     82    sage: (a, b, c, d, e) = F.gens()
     83    sage: d * b**2 * c**3
     84    b^2*c^3*d
     85    sage: F = AbelianGroup(3,[2]*3); F
     86    Multiplicative Abelian Group isomorphic to C2 x C2 x C2
     87    sage: H = AbelianGroup([2,3], names="xy"); H
     88    Multiplicative Abelian Group isomorphic to C2 x C3
     89    sage: AbelianGroup(5)
     90    Multiplicative Abelian Group isomorphic to Z x Z x Z x Z x Z
     91    sage: AbelianGroup(5).order()
     92    +Infinity
  • new file doc/pt/tutorial/tour_help.rst

    diff --git a/doc/pt/tutorial/tour_help.rst b/doc/pt/tutorial/tour_help.rst
    new file mode 100644
    - +  
     1.. _chapter-help:
     2
     3Obtendo ajuda
     4=============
     5
     6O Sage possui vasta documentação, acessível digitando o nome de uma
     7função ou constante (por exemplo), seguido pelo ponto de interrogação:
     8
     9.. skip
     10
     11::
     12
     13    sage: tan?
     14    Type:        <class 'sage.calculus.calculus.Function_tan'>
     15    Definition:  tan( [noargspec] )
     16    Docstring:
     17   
     18        The tangent function
     19   
     20        EXAMPLES:
     21            sage: tan(pi)
     22            0
     23            sage: tan(3.1415)
     24            -0.0000926535900581913
     25            sage: tan(3.1415/4)
     26            0.999953674278156
     27            sage: tan(pi/4)
     28            1
     29            sage: tan(1/2)
     30            tan(1/2)
     31            sage: RR(tan(1/2))
     32            0.546302489843790
     33    sage: log2?
     34    Type:        <class 'sage.functions.constants.Log2'>
     35    Definition:  log2( [noargspec] )
     36    Docstring:
     37   
     38        The natural logarithm of the real number 2.
     39       
     40        EXAMPLES:
     41            sage: log2
     42            log2
     43            sage: float(log2)
     44            0.69314718055994529
     45            sage: RR(log2)
     46            0.693147180559945
     47            sage: R = RealField(200); R
     48            Real Field with 200 bits of precision
     49            sage: R(log2)
     50            0.69314718055994530941723212145817656807550013436025525412068
     51            sage: l = (1-log2)/(1+log2); l
     52            (1 - log(2))/(log(2) + 1)
     53            sage: R(l)
     54            0.18123221829928249948761381864650311423330609774776013488056
     55            sage: maxima(log2)
     56            log(2)
     57            sage: maxima(log2).float()
     58            .6931471805599453
     59            sage: gp(log2)
     60            0.6931471805599453094172321215             # 32-bit
     61            0.69314718055994530941723212145817656807   # 64-bit
     62    sage: sudoku?
     63    File:        sage/local/lib/python2.5/site-packages/sage/games/sudoku.py
     64    Type:        <type 'function'>
     65    Definition:  sudoku(A)
     66    Docstring:
     67   
     68        Solve the 9x9 Sudoku puzzle defined by the matrix A.
     69   
     70        EXAMPLE:
     71            sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0,
     72        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,
     73        0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0,   0,3,0, 0,0,2,
     74        0,0,0, 4,9,0, 0,5,0, 0,0,3])
     75            sage: A
     76            [5 0 0 0 8 0 0 4 9]
     77            [0 0 0 5 0 0 0 3 0]
     78            [0 6 7 3 0 0 0 0 1]
     79            [1 5 0 0 0 0 0 0 0]
     80            [0 0 0 2 0 8 0 0 0]
     81            [0 0 0 0 0 0 0 1 8]
     82            [7 0 0 0 0 4 1 5 0]
     83            [0 3 0 0 0 2 0 0 0]
     84            [4 9 0 0 5 0 0 0 3]
     85            sage: sudoku(A)
     86            [5 1 3 6 8 7 2 4 9]
     87            [8 4 9 5 2 1 6 3 7]
     88            [2 6 7 3 4 9 5 8 1]
     89            [1 5 8 4 6 3 9 7 2]
     90            [9 7 4 2 1 8 3 6 5]
     91            [3 2 6 7 9 5 4 1 8]
     92            [7 8 2 9 3 4 1 5 6]
     93            [6 3 5 1 7 2 8 9 4]
     94            [4 9 1 8 5 6 7 2 3]
     95
     96O Sage também fornece completamento tab: digite as primeiras letras de
     97uma função e então pressione a tecla tab. Por exemplo, se você digitar
     98``ta`` seguido de ``TAB``, o Sage vai imprimir ``tachyon, tan, tanh,
     99taylor``. Essa é uma boa forma de encontrar nomes de funções e outras
     100estruturas no Sage.
     101
     102
     103.. _section-functions:
     104
     105Funções, Tabulação, e Contagem
     106===============================
     107
     108Para definir uma nova função no Sage, use o comando ``def`` e dois
     109pontos após a lista de nomes das variáveis. Por exemplo:
     110
     111::
     112
     113    sage: def is_even(n):
     114    ...       return n%2 == 0
     115    ...
     116    sage: is_even(2)
     117    True
     118    sage: is_even(3)
     119    False
     120
     121Observação: Dependendo da versão do tutorial que você está lendo,
     122você pode ver três pontos ``...`` na segunda linha desse exemplo. Não
     123digite esses pontos; eles são apenas para enfatizar que o código está
     124tabulado. Se for esse o caso, pressione [Enter] uma vez após o fim do
     125bloco de código para inserir uma linha em branco e concluir a
     126definição da função.
     127
     128Você não especifica o tipo de dado de nenhum dos argumentos da função.
     129É possível especificar argumentos múltiplos, cada um dos quais pode
     130ter um valor opcional padrão. Por exemplo, a função abaixo usa o valor
     131padrão ``divisor=2`` se ``divisor`` não é especificado.
     132
     133::
     134
     135    sage: def is_divisible_by(number, divisor=2):
     136    ...       return number%divisor == 0
     137    sage: is_divisible_by(6,2)
     138    True
     139    sage: is_divisible_by(6)
     140    True
     141    sage: is_divisible_by(6, 5)
     142    False
     143
     144Você também pode especificar explicitamente um ou mais argumentos
     145quando evocar uma função; se você especificar os argumentos
     146explicitamente, você pode fazê-lo em qualquer ordem:
     147
     148.. link
     149
     150::
     151
     152    sage: is_divisible_by(6, divisor=5)
     153    False
     154    sage: is_divisible_by(divisor=2, number=6)
     155    True
     156
     157Em Python, blocos de código não são indicados por colchetes ou blocos
     158de início e fim, como em outras linguagens. Em vez disso, blocos de
     159código são indicados por tabulação, que devem estar alinhadas
     160exatamente. Por exemplo, o seguinte código possui um erro de sintaxe
     161porque o comando ``return`` não possui a mesma tabulação da linha que
     162inicia o seu bloco de código.
     163
     164.. skip
     165
     166::
     167
     168    sage: def even(n):
     169    ...       v = []
     170    ...       for i in range(3,n):
     171    ...           if i % 2 == 0:
     172    ...               v.append(i)
     173    ...      return v
     174    Syntax Error:
     175           return v
     176
     177Se você corrigir a tabulação, a função fica correta:
     178
     179::
     180
     181    sage: def even(n):
     182    ...       v = []
     183    ...       for i in range(3,n):
     184    ...           if i % 2 == 0:
     185    ...               v.append(i)
     186    ...       return v
     187    sage: even(10)
     188    [4, 6, 8]
     189
     190Não é necessário inserir ponto-e-vírgula no final da linha. Todavia,
     191você pode inserir múltiplos comandos em uma mesma linha separados por
     192ponto-e-vírgula:
     193
     194::
     195
     196    sage: a = 5; b = a + 3; c = b^2; c
     197    64
     198
     199Se você quiser que uma única linha de comando seja escrita em mais de
     200uma linha, use a barra invertida para quebrar a linha:
     201
     202::
     203
     204    sage: 2 + \
     205    ...      3
     206    5
     207
     208Em Sage, a contagem é feita iterando sobre um intervalo de inteiros.
     209Por exemplo, a primeira linha abaixo é equivalente a ``for(i=0; i<3;
     210i++)`` em C++ ou Java:
     211
     212::
     213
     214    sage: for i in range(3):
     215    ...       print i
     216    0
     217    1
     218    2
     219
     220A primeira linha abaixo é equivalente a ``for(i=2; i<5; i++)``.
     221
     222::
     223
     224    sage: for i in range(2,5):
     225    ...       print i
     226    2
     227    3
     228    4
     229
     230O Terceiro argumento controla o passo. O comando abaixo é equivalente
     231a ``for(i=1; i<6; i+=2)``.
     232
     233::
     234
     235    sage: for i in range(1,6,2):
     236    ...       print i
     237    1
     238    3
     239    5
     240
     241Frequentemente deseja-se criar uma tabela para visualizar resultados
     242calculados com o Sage. Uma forma fácil de fazer isso é utilizando
     243formatação de strings. Abaixo, criamos três colunas cada uma com
     244largura exatamente 6, e fazemos uma tabela com quadrados e cubos de
     245alguns números.
     246
     247::
     248
     249    sage: for i in range(5):
     250    ...       print '%6s %6s %6s'%(i, i^2, i^3)
     251         0      0      0
     252         1      1      1
     253         2      4      8
     254         3      9     27
     255         4     16     64
     256
     257A estrutura de dados mais básica em Sage é a lista, que é -- como o
     258nome sugere -- simplesmente uma lista de objetos arbitrários. Por
     259exemplo, o comando ``range`` que usamos acima cria uma lista:
     260
     261::
     262
     263    sage: range(2,10)
     264    [2, 3, 4, 5, 6, 7, 8, 9]
     265
     266Abaixo segue uma lista mais complicada:
     267
     268::
     269
     270    sage: v = [1, "hello", 2/3, sin(x^3)]
     271    sage: v
     272    [1, 'hello', 2/3, sin(x^3)]
     273
     274Listas são indexadas começando do 0, como em várias linguagens de
     275programação.
     276
     277.. link
     278
     279::
     280
     281    sage: v[0]
     282    1
     283    sage: v[3]
     284    sin(x^3)
     285
     286Use ``len(v)`` para obter o comprimento de ``v``, use
     287``v.append(obj)`` para inserir um novo objeto no final de ``v``, e use
     288``del v[i]`` para remover o :math:`i`-ésimo elemento de ``v``:
     289
     290.. link
     291
     292::
     293
     294    sage: len(v)
     295    4
     296    sage: v.append(1.5)
     297    sage: v
     298    [1, 'hello', 2/3, sin(x^3), 1.50000000000000]
     299    sage: del v[1]
     300    sage: v
     301    [1, 2/3, sin(x^3), 1.50000000000000]
     302
     303Outra importante estrutura de dados é o dicionário (ou lista
     304associativa). Ele funciona como uma lista, exceto que pode ser
     305indexado por vários tipos de objeto (os índices devem ser imutáveis):
     306
     307::
     308
     309    sage: d = {'hi':-2,  3/8:pi,   e:pi}
     310    sage: d['hi']
     311    -2
     312    sage: d[e]
     313    pi
     314
     315Você pode também definir novos tipos de dados usando classes.
     316Encapsular objetos matemáticos usando classes é uma técnica poderosa
     317que pode ajudar a simplificar e organizar os seus programas em Sage.
     318Abaixo, definimos uma nova classe que representa a lista de inteiros
     319pares positivos até *n*; essa classe é derivada do tipo ``list``.
     320
     321::
     322
     323    sage: class Evens(list):
     324    ...       def __init__(self, n):
     325    ...           self.n = n
     326    ...           list.__init__(self, range(2, n+1, 2))
     327    ...       def __repr__(self):
     328    ...           return "Even positive numbers up to n."
     329
     330O método ``__init__`` é evocado para inicializar o objeto quando ele é
     331criado; o método ``__repr__`` imprime o objeto. Nós evocamos o
     332construtor ``__init__`` do tipo ``list`` na segunda linha do método
     333``__init__``. Criamos um objeto da classe ``Evens`` da seguinte forma:
     334
     335.. link
     336
     337::
     338
     339    sage: e = Evens(10)
     340    sage: e
     341    Even positive numbers up to n.
     342
     343Note que ``e`` imprime usando o método ``__repr__`` que nós
     344definimos. Para ver a lista de números, use a função ``list``:
     345
     346.. link
     347
     348::
     349
     350    sage: list(e)
     351    [2, 4, 6, 8, 10]
     352
     353Podemos também acessar o atributo ``n`` ou tratar ``e`` como uma
     354lista.
     355
     356.. link
     357
     358::
     359
     360    sage: e.n
     361    10
     362    sage: e[2]
     363    6
  • new file doc/pt/tutorial/tour_linalg.rst

    diff --git a/doc/pt/tutorial/tour_linalg.rst b/doc/pt/tutorial/tour_linalg.rst
    new file mode 100644
    - +  
     1.. _section-linalg:
     2
     3Álgebra Linear
     4==============
     5
     6O Sage fornece os objetos usuais em álgebra linear, por exemplo, o
     7polinômio característico, matriz escalonada, traço, decomposição,
     8etc., de uma matriz.
     9
     10Criar e multiplicar matrizes é fácil e natural:
     11
     12::
     13
     14    sage: A = Matrix([[1,2,3],[3,2,1],[1,1,1]])
     15    sage: w = vector([1,1,-4])
     16    sage: w*A
     17    (0, 0, 0)
     18    sage: A*w
     19    (-9, 1, -2)
     20    sage: kernel(A)
     21    Free module of degree 3 and rank 1 over Integer Ring
     22    Echelon basis matrix:
     23    [ 1  1 -4]
     24
     25Note que no Sage, o núcleo de uma matriz :math:`A` é o núcleo à
     26esquerda, i.e., o conjunto de vetores :math:`w` tal que :math:`wA=0`.
     27
     28Resolver equações matriciais é fácil usando o método ``solve_right``.
     29Calculando ``A.solve_right(Y)`` obtém-se uma matrix (ou vetor)
     30:math:`X` tal que :math:`AX=Y`:
     31
     32.. link
     33
     34::
     35
     36    sage: Y = vector([0, -4, -1])
     37    sage: X = A.solve_right(Y)
     38    sage: X
     39    (-2, 1, 0)
     40    sage: A * X   # checking our answer...
     41    (0, -4, -1)
     42
     43Uma barra invertida ``\`` pode ser usada no lugar de ``solve_right``;
     44use ``A \ Y`` no lugar de ``A.solve_right(Y)``.
     45
     46.. link
     47
     48::
     49
     50    sage: A \ Y
     51    (-2, 1, 0)
     52
     53Se não existir solução, o Sage retorna um erro:
     54
     55.. skip
     56
     57::
     58
     59    sage: A.solve_right(w)
     60    Traceback (most recent call last):
     61    ...
     62    ValueError: matrix equation has no solutions
     63
     64Similarmente, use ``A.solve_left(Y)`` para resolver para :math:`X` em
     65:math:`XA=Y`.
     66
     67O Sage também pode calcular autovalores e autovetores::
     68
     69    sage: A = matrix([[0, 4], [-1, 0]])
     70    sage: A.eigenvalues ()
     71    [-2*I, 2*I]
     72    sage: B = matrix([[1, 3], [3, 1]])
     73    sage: B.eigenvectors_left()
     74    [(4, [
     75    (1, 1)
     76    ], 1), (-2, [
     77    (1, -1)
     78    ], 1)]
     79
     80(A sintaxe para a resposta de ``eigenvectors_left`` é uma lista com
     81três componentes: (autovalor, autovetor, multiplicidade).) Autovalores
     82e autovetores sobre ``QQ`` ou ``RR`` também podem ser calculados
     83usando o Maxima (veja :ref:`section-maxima`).
     84
     85Como observado em :ref:`section-rings`, o anel sobre o qual a matriz
     86esta definida afeta alguma de suas propriedades. A seguir, o primeiro
     87argumento do comando ``matrix`` diz para o Sage considerar a matriz
     88como uma matriz de inteiros (o caso ``ZZ``), uma matriz de números
     89racionais (``QQ``), ou uma matriz de números reais (``RR``)::
     90
     91    sage: AZ = matrix(ZZ, [[2,0], [0,1]])
     92    sage: AQ = matrix(QQ, [[2,0], [0,1]])
     93    sage: AR = matrix(RR, [[2,0], [0,1]])
     94    sage: AZ.echelon_form()
     95    [2 0]
     96    [0 1]
     97    sage: AQ.echelon_form()
     98    [1 0]
     99    [0 1]
     100    sage: AR.echelon_form()
     101    [ 1.00000000000000 0.000000000000000]
     102    [0.000000000000000  1.00000000000000]
     103
     104Espaços de Matrizes
     105-------------------
     106
     107Agora criamos o espaço :math:`\text{Mat}_{3\times 3}(\QQ)` de matrizes
     108`3 \times 3` com entradas racionais::
     109
     110    sage: M = MatrixSpace(QQ,3)
     111    sage: M
     112    Full MatrixSpace of 3 by 3 dense matrices over Rational Field
     113
     114(Para especificar o espaço de matrizes 3 por 4, você usaria
     115``MatrixSpace(QQ,3,4)``. Se o número de colunas é omitido, ele é
     116considerado como igual ao número de linhas, portanto,
     117``MatrixSpace(QQ,3)`` é sinônimo de ``MatrixSpace(QQ,3,3)``.) O espaço
     118de matrizes possui uma base que o Sage armazena como uma lista:
     119
     120.. link
     121
     122::
     123
     124    sage: B = M.basis()
     125    sage: len(B)
     126    9
     127    sage: B[1]
     128    [0 1 0]
     129    [0 0 0]
     130    [0 0 0]
     131
     132Vamos criar uma matriz como um elemento de ``M``.
     133
     134.. link
     135
     136::
     137
     138    sage: A = M(range(9)); A
     139    [0 1 2]
     140    [3 4 5]
     141    [6 7 8]
     142
     143A seguir calculamos a sua forma escalonada e o núcleo.
     144
     145.. link
     146
     147::
     148
     149    sage: A.echelon_form()
     150    [ 1  0 -1]
     151    [ 0  1  2]
     152    [ 0  0  0]
     153    sage: A.kernel()
     154    Vector space of degree 3 and dimension 1 over Rational Field
     155    Basis matrix:
     156    [ 1 -2  1]
     157
     158Agora ilustramos o cálculo com matrizes definidas sobre um corpo
     159finito:
     160
     161::
     162
     163    sage: M = MatrixSpace(GF(2),4,8)
     164    sage: A = M([1,1,0,0, 1,1,1,1, 0,1,0,0, 1,0,1,1,
     165    ...          0,0,1,0, 1,1,0,1, 0,0,1,1, 1,1,1,0])
     166    sage: A
     167    [1 1 0 0 1 1 1 1]
     168    [0 1 0 0 1 0 1 1]
     169    [0 0 1 0 1 1 0 1]
     170    [0 0 1 1 1 1 1 0]
     171    sage: rows = A.rows()
     172    sage: A.columns()
     173    [(1, 0, 0, 0), (1, 1, 0, 0), (0, 0, 1, 1), (0, 0, 0, 1),
     174     (1, 1, 1, 1), (1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 0)]
     175    sage: rows
     176    [(1, 1, 0, 0, 1, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1),
     177     (0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 1, 1, 1, 1, 1, 0)]
     178
     179Criamos o subespaço sobre `\GF{2}` gerado pelas linhas acima.
     180
     181.. link
     182
     183::
     184
     185    sage: V = VectorSpace(GF(2),8)
     186    sage: S = V.subspace(rows)
     187    sage: S
     188    Vector space of degree 8 and dimension 4 over Finite Field of size 2
     189    Basis matrix:
     190    [1 0 0 0 0 1 0 0]
     191    [0 1 0 0 1 0 1 1]
     192    [0 0 1 0 1 1 0 1]
     193    [0 0 0 1 0 0 1 1]
     194    sage: A.echelon_form()
     195    [1 0 0 0 0 1 0 0]
     196    [0 1 0 0 1 0 1 1]
     197    [0 0 1 0 1 1 0 1]
     198    [0 0 0 1 0 0 1 1]
     199
     200A base de `S` usada pelo Sage é obtida a partir das linhas não-nulas
     201da forma escalonada da matriz de geradores de `S`.
     202
     203Álgebra Linear Esparsa
     204----------------------
     205
     206O Sage fornece suporte para álgebra linear esparsa.
     207
     208::
     209
     210    sage: M = MatrixSpace(QQ, 100, sparse=True)
     211    sage: A = M.random_element(density = 0.05)
     212    sage: E = A.echelon_form()                 
     213
     214O algoritmo multi-modular no Sage é bom para matrizes quadradas (mas
     215não muito bom para matrizes que não são quadradas):
     216
     217::
     218
     219    sage: M = MatrixSpace(QQ, 50, 100, sparse=True)
     220    sage: A = M.random_element(density = 0.05)
     221    sage: E = A.echelon_form()                 
     222    sage: M = MatrixSpace(GF(2), 20, 40, sparse=True)
     223    sage: A = M.random_element()
     224    sage: E = A.echelon_form()
     225
     226Note que o Python é sensível a maiúsculas e minúsculas:
     227
     228::
     229
     230    sage: M = MatrixSpace(QQ, 10,10, Sparse=True)
     231    Traceback (most recent call last):
     232    ...
     233    TypeError: MatrixSpace() got an unexpected keyword argument 'Sparse'
  • new file doc/pt/tutorial/tour_numtheory.rst

    diff --git a/doc/pt/tutorial/tour_numtheory.rst b/doc/pt/tutorial/tour_numtheory.rst
    new file mode 100644
    - +  
     1Teoria de Números
     2=================
     3
     4O Sage possui extensa funcionalidade para teoria de números. Por
     5exemplo, podemos fazer aritmética em :math:`\ZZ/N\ZZ` da seguinte
     6forma:
     7
     8::
     9
     10    sage: R = IntegerModRing(97)
     11    sage: a = R(2) / R(3)
     12    sage: a
     13    33
     14    sage: a.rational_reconstruction()
     15    2/3
     16    sage: b = R(47)
     17    sage: b^20052005
     18    50
     19    sage: b.modulus()
     20    97
     21    sage: b.is_square()
     22    True
     23
     24O Sage contém funções comuns em teoria de números. Por exemplo,
     25
     26::
     27
     28    sage: gcd(515,2005)
     29    5
     30    sage: factor(2005)
     31    5 * 401
     32    sage: c = factorial(25); c
     33    15511210043330985984000000
     34    sage: [valuation(c,p) for p in prime_range(2,23)]
     35    [22, 10, 6, 3, 2, 1, 1, 1]
     36    sage: next_prime(2005)
     37    2011
     38    sage: previous_prime(2005)
     39    2003
     40    sage: divisors(28); sum(divisors(28)); 2*28
     41    [1, 2, 4, 7, 14, 28]
     42    56
     43    56
     44
     45Perfeito!
     46
     47A função ``sigma(n,k)`` do Sage soma as :math:`k`-ésimas potências dos
     48divisores de ``n``:
     49
     50::
     51
     52    sage: sigma(28,0); sigma(28,1); sigma(28,2)
     53    6
     54    56
     55    1050
     56
     57A seguir ilustramos o algoritmo de Euclides estendido, a função
     58:math:`\phi` de Euler, e o teorema do resto Chinês:
     59
     60::
     61
     62    sage: d,u,v = xgcd(12,15)
     63    sage: d == u*12 + v*15
     64    True
     65    sage: n = 2005
     66    sage: inverse_mod(3,n)
     67    1337
     68    sage: 3 * 1337
     69    4011
     70    sage: prime_divisors(n)
     71    [5, 401]
     72    sage: phi = n*prod([1 - 1/p for p in prime_divisors(n)]); phi
     73    1600
     74    sage: euler_phi(n)
     75    1600
     76    sage: prime_to_m_part(n, 5)
     77    401
     78
     79Agora verificamos algo sobre o problema :math:`3n+1`.
     80
     81::
     82
     83    sage: n = 2005
     84    sage: for i in range(1000):
     85    ...       n = 3*odd_part(n) + 1
     86    ...       if odd_part(n)==1:
     87    ...           print i
     88    ...           break
     89    38
     90
     91Por fim, ilustramos o teorema do resto Chinês.
     92
     93::
     94
     95    sage: x = crt(2, 1, 3, 5); x   
     96    11
     97    sage: x % 3  # x mod 3 = 2
     98    2
     99    sage: x % 5  # x mod 5 = 1
     100    1
     101    sage: [binomial(13,m) for m in range(14)]
     102    [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1]
     103    sage: [binomial(13,m)%2 for m in range(14)]
     104    [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]
     105    sage: [kronecker(m,13) for m in range(1,13)]
     106    [1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1]
     107    sage: n = 10000; sum([moebius(m) for m in range(1,n)])
     108    -23
     109    sage: list(partitions(4))
     110    [(1, 1, 1, 1), (1, 1, 2), (2, 2), (1, 3), (4,)]
     111
     112Números :math:`p`-ádicos
     113------------------------
     114
     115O corpo dos números :math:`p`-ádicos está implementado em Sage. Note
     116que uma vez que um corpo :math:`p`-ádico é criado, você não pode
     117alterar a sua precisão.
     118
     119::
     120
     121    sage: K = Qp(11); K
     122    11-adic Field with capped relative precision 20
     123    sage: a = K(211/17); a
     124    4 + 4*11 + 11^2 + 7*11^3 + 9*11^5 + 5*11^6 + 4*11^7 + 8*11^8 + 7*11^9
     125      + 9*11^10 + 3*11^11 + 10*11^12 + 11^13 + 5*11^14 + 6*11^15 + 2*11^16
     126      + 3*11^17 + 11^18 + 7*11^19 + O(11^20)
     127    sage: b = K(3211/11^2); b
     128    10*11^-2 + 5*11^-1 + 4 + 2*11 + O(11^18)
     129
     130Muito trabalho foi feito implementando anéis de inteiros em corpos
     131:math:`p`-ádicos ou corpos numéricos além de `Z`. O leitor
     132interessado é convidado a perguntar mais detalhes aos especialistas na
     133lista ``sage-support`` no Google Groups.
     134
     135Diversos métodos relacionados já estão implementados na classe
     136NumberField.
     137
     138::
     139
     140    sage: R.<x> = PolynomialRing(QQ)
     141    sage: K = NumberField(x^3 + x^2 - 2*x + 8, 'a')
     142    sage: K.integral_basis()
     143    [1, 1/2*a^2 + 1/2*a, a^2]
     144
     145.. link
     146
     147::
     148
     149    sage: K.galois_group(type="pari")
     150    Galois group PARI group [6, -1, 2, "S3"] of degree 3 of the Number Field
     151    in a with defining polynomial x^3 + x^2 - 2*x + 8
     152
     153.. link
     154
     155::
     156
     157    sage: K.polynomial_quotient_ring()
     158    Univariate Quotient Polynomial Ring in a over Rational Field with modulus
     159    x^3 + x^2 - 2*x + 8
     160    sage: K.units()
     161    [3*a^2 + 13*a + 13]
     162    sage: K.discriminant()
     163    -503
     164    sage: K.class_group()
     165    Class group of order 1 of Number Field in a with
     166    defining polynomial x^3 + x^2 - 2*x + 8
     167    sage: K.class_number()
     168    1
  • new file doc/pt/tutorial/tour_plotting.rst

    diff --git a/doc/pt/tutorial/tour_plotting.rst b/doc/pt/tutorial/tour_plotting.rst
    new file mode 100644
    - +  
     1.. _section-plot:
     2
     3Gráficos
     4========
     5
     6O Sage pode produzir gráficos bidimensionais e tridimensionais.
     7
     8Gráficos Bidimensionais
     9-----------------------
     10
     11Em duas dimensões, o Sage pode desenhar círculos, linhas, e polígonos;
     12gráficos de funções em coordenadas retangulares, e também coordenadas
     13polares; gráficos de contorno e gráficos de campos vetoriais.
     14Apresentamos alguns exemplos desses gráficos aqui. Para mais exemplos
     15de gráficos com o Sage, veja :ref:`section-systems` e
     16:ref:`section-maxima`, e também a documentação `Sage Constructions
     17<http://www.sagemath.org/doc/constructions/>`_.
     18
     19Este comando produz um círculo amarelo de raio 1, centrado na origem.
     20
     21::
     22
     23    sage: circle((0,0), 1, rgbcolor=(1,1,0))
     24
     25Você pode também produzir um círculo preenchido:
     26
     27::
     28
     29    sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True)
     30
     31Outra possibilidade é criar um círculo atribuindo-o a uma variável;
     32isso não cria um gráfico:
     33
     34::
     35
     36    sage: c = circle((0,0), 1, rgbcolor=(1,1,0))
     37
     38Para criar o gráfico, use ``c.show()`` ou ``show(c)``, da seguinte
     39forma:
     40
     41.. link
     42
     43::
     44
     45    sage: c.show()
     46
     47Alternativamente, o comando ``c.save('filename.png')`` salva o gráfico
     48no arquivo citado.
     49
     50Agora, esses 'círculos' parecem mais elipses porque os eixos estão em
     51escalas diferentes. Você pode alterar isso:
     52
     53.. link
     54
     55::
     56
     57    sage: c.show(aspect_ratio=1)
     58
     59O comando ``show(c, aspect_ratio=1)`` produz o mesmo resultado, ou
     60você pode salvar a figura usando ``c.save('filename.png',
     61aspect_ratio=1)``.
     62
     63É fácil criar o gráfico de funções simples:
     64
     65::
     66
     67    sage: plot(cos, (-5,5))
     68
     69Após especificar uma variável, você também pode criar gráficos
     70paramétricos:
     71
     72::
     73
     74    sage: x = var('x')
     75    sage: parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
     76
     77É importante notar que os eixos dos gráficos vão se intersectar apenas
     78se a origem estiver no escopo do gráfico, e que valores grandes podem
     79ser representados usando notação científica.
     80
     81::
     82
     83    sage: plot(x^2,(x,300,500))
     84
     85Você pode combinar vários gráficos somando-os:
     86
     87::
     88
     89    sage: x = var('x')
     90    sage: p1 = parametric_plot((cos(x),sin(x)),(x,0,2*pi),rgbcolor=hue(0.2))
     91    sage: p2 = parametric_plot((cos(x),sin(x)^2),(x,0,2*pi),rgbcolor=hue(0.4))
     92    sage: p3 = parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6))
     93    sage: show(p1+p2+p3, axes=false)
     94
     95Uma boa forma de produzir figuras preenchidas é criar uma lista de
     96pontos (``L`` no exemplo abaixo) e então usar o comando ``polygon``
     97para fazer o gráfico do polígono formado por esses pontos. Por
     98exemplo, aqui está um "deltoid" verde:
     99
     100::
     101
     102    sage: L = [[-1+cos(pi*i/100)*(1+cos(pi*i/100)),\
     103    ...   2*sin(pi*i/100)*(1-cos(pi*i/100))] for i in range(200)]
     104    sage: p = polygon(L, rgbcolor=(1/8,3/4,1/2))
     105    sage: p
     106
     107Digite ``show(p, axes=false)`` para visualizar isso sem os eixos.
     108
     109Você pode adicionar texto ao gráfico:
     110
     111::
     112
     113    sage: L = [[6*cos(pi*i/100)+5*cos((6/2)*pi*i/100),\
     114    ...   6*sin(pi*i/100)-5*sin((6/2)*pi*i/100)] for i in range(200)]
     115    sage: p = polygon(L, rgbcolor=(1/8,1/4,1/2))
     116    sage: t = text("hypotrochoid", (5,4), rgbcolor=(1,0,0))
     117    sage: show(p+t)
     118
     119Professores de cálculo frequentemente desenham o seguinte gráfico na
     120lousa: não apenas um ramo do arco-seno, mas vários deles: isto é, o
     121gráfico de :math:`y=\sin(x)` para :math:`x` entre :math:`-2\pi` e
     122:math:`2\pi`, refletido com respeito a reta :math:`x=y`. Os seguintes
     123comandos fazem isso:
     124
     125::
     126
     127    sage: v = [(sin(x),x) for x in srange(-2*float(pi),2*float(pi),0.1)]
     128    sage: line(v)
     129
     130Como a função tangente possui imagem maior do que o seno, se você usar
     131o mesmo método para fazer o gráfico da função inversa da função
     132tangente, você deve alterar as coordenadas mínima e máxima para o eixo
     133*x*:
     134
     135::
     136
     137    sage: v = [(tan(x),x) for x in srange(-2*float(pi),2*float(pi),0.01)]
     138    sage: show(line(v), xmin=-20, xmax=20)
     139
     140O Sage também cria gráficos usando coordenadas polares, gráficos de
     141contorno e gráficos de campos vetoriais (para tipos especiais de
     142funções). Aqui está um exemplo de gráfico de contorno:
     143
     144::
     145
     146    sage: f = lambda x,y: cos(x*y)
     147    sage: contour_plot(f, (-4, 4), (-4, 4))
     148
     149Gráficos Tridimensionais
     150------------------------
     151
     152O Sage pode ser usado para criar gráficos tridimensionais. Tanto no
     153Sage Notebook, como no console (linha de comando), esses gráficos serão
     154exibidos usando o software de código aberto [Jmol]_, que permite girar
     155e ampliar a figura usando o mouse.
     156
     157Use ``plot3d`` para criar o gráfico de uma função da forma `f(x, y) =
     158z`:
     159
     160::
     161
     162    sage: x, y = var('x,y')
     163    sage: plot3d(x^2 + y^2, (x,-2,2), (y,-2,2))
     164
     165Alternativamente, você pode usar ``parametric_plot3d`` para criar o
     166gráfico de uma superfície onde cada coordenada `x, y, z` é determinada
     167por uma função de uma ou duas variáveis (os parâmetros, tipicamente
     168`u` e `v`). O gráfico anterior pode ser representado parametricamente
     169na forma:
     170
     171::
     172
     173    sage: u, v = var('u, v')
     174    sage: f_x(u, v) = u
     175    sage: f_y(u, v) = v
     176    sage: f_z(u, v) = u^2 + v^2
     177    sage: parametric_plot3d([f_x, f_y, f_z], (u, -2, 2), (v, -2, 2))
     178
     179A terceira forma de fazer um gráfico de uma superfície no Sage é
     180usando o comando ``implicit_plot3d``, que cria um gráfico de uma
     181superfície definida por uma equação `f(x, y, z) = 0` (isso define um
     182conjunto de pontos). Vamos fazer o gráfico de uma esfera usando a
     183expressão usual:
     184
     185::
     186
     187    sage: x, y, z = var('x, y, z')
     188    sage: implicit_plot3d(x^2 + y^2 + z^2 - 4, (x,-2, 2), (y,-2, 2), (z,-2, 2))
     189
     190Aqui estão mais alguns exemplos:
     191
     192`Yellow Whitney's umbrella <http://en.wikipedia.org/wiki/Whitney_umbrella>`__:
     193
     194::
     195
     196    sage: u, v = var('u,v')
     197    sage: fx = u*v
     198    sage: fy = u
     199    sage: fz = v^2
     200    sage: parametric_plot3d([fx, fy, fz], (u, -1, 1), (v, -1, 1),
     201    ...   frame=False, color="yellow")
     202
     203`Cross cap <http://en.wikipedia.org/wiki/Cross-cap>`__:
     204
     205::
     206
     207    sage: u, v = var('u,v')
     208    sage: fx = (1+cos(v))*cos(u)
     209    sage: fy = (1+cos(v))*sin(u)
     210    sage: fz = -tanh((2/3)*(u-pi))*sin(v)
     211    sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi),
     212    ...   frame=False, color="red")
     213
     214Toro retorcido:
     215
     216::
     217
     218    sage: u, v = var('u,v')
     219    sage: fx = (3+sin(v)+cos(u))*cos(2*v)
     220    sage: fy = (3+sin(v)+cos(u))*sin(2*v)
     221    sage: fz = sin(u)+2*cos(v)
     222    sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi),
     223    ...   frame=False, color="red")
     224
     225Lemniscata:
     226
     227::
     228
     229    sage: x, y, z = var('x,y,z')
     230    sage: f(x, y, z) = 4*x^2 * (x^2 + y^2 + z^2 + z) + y^2 * (y^2 + z^2 - 1)
     231    sage: implicit_plot3d(f, (x, -0.5, 0.5), (y, -1, 1), (z, -1, 1))
  • new file doc/pt/tutorial/tour_polynomial.rst

    diff --git a/doc/pt/tutorial/tour_polynomial.rst b/doc/pt/tutorial/tour_polynomial.rst
    new file mode 100644
    - +  
     1.. _section-poly:
     2
     3Polinômios
     4==========
     5
     6Nesta seção vamos ilustrar como criar e usar polinômios no Sage.
     7
     8
     9.. _section-univariate:
     10
     11Polinômios em Uma Variável
     12--------------------------
     13
     14Existem três formas de criar anéis de polinômios.
     15
     16::
     17
     18    sage: R = PolynomialRing(QQ, 't')
     19    sage: R
     20    Univariate Polynomial Ring in t over Rational Field
     21
     22Esse comando cria um anel de polinômios e diz para o Sage usar a letra
     23't' para representar a variável indeterminada quando imprimir na tela.
     24Todavia, isso não define o símbolo ``t`` para uso no Sage, logo você
     25não pode usá-lo para definir um polinômio (como :math:`t^2+1`)
     26pertencente a ``R``.
     27
     28Uma forma alternativa é
     29
     30.. link
     31
     32::
     33
     34    sage: S = QQ['t']
     35    sage: S == R
     36    True
     37
     38As mesmas observações com respeito a ``t`` valem também nesse caso.
     39
     40Uma terceira e conveniente forma de definir polinômios é
     41
     42::
     43
     44    sage: R.<t> = PolynomialRing(QQ)
     45
     46ou
     47
     48::
     49
     50    sage: R.<t> = QQ['t']
     51
     52ou ainda
     53
     54::
     55
     56    sage: R.<t> = QQ[]
     57
     58Isso tem o efeito colateral de definir a variável ``t`` como a
     59variável indeterminada do anel de polinômios, logo você pode
     60facilmente construir elementos de ``R`` da seguinte forma. (Note que
     61essa terceira alternativa é muito semelhante à notação usada em Magma,
     62e da mesma forma que no Magma ela pode ser usada para diversos tipos
     63de objetos.)
     64
     65.. link
     66
     67::
     68
     69    sage: poly = (t+1) * (t+2); poly
     70    t^2 + 3*t + 2
     71    sage: poly in R
     72    True
     73
     74Qualquer que seja o método usado para definir um anel de polinômios,
     75você pode recuperar a variável indeterminada como o :math:`0`-ésimo
     76gerador:
     77
     78::
     79
     80    sage: R = PolynomialRing(QQ, 't')
     81    sage: t = R.0
     82    sage: t in R
     83    True
     84
     85Note que uma construção similar funciona com os números complexos: os
     86números complexos podem ser vistos como sendo gerados pelo símbolo
     87``i`` sobre os números reais; logo temos o seguinte:
     88
     89::
     90
     91    sage: CC
     92    Complex Field with 53 bits of precision
     93    sage: CC.0  # 0th generator of CC
     94    1.00000000000000*I
     95
     96Para anel de polinômios, você pode obter tanto o anel como o seu
     97gerador, ou somente o gerador, no momento em que o anel for criado, da
     98seguinte forma:
     99
     100::
     101
     102    sage: R, t = QQ['t'].objgen()
     103    sage: t    = QQ['t'].gen()
     104    sage: R, t = objgen(QQ['t'])
     105    sage: t    = gen(QQ['t'])
     106
     107Finalmente apresentamos um pouco de aritmética em :math:`\QQ[t]`.
     108
     109::
     110
     111    sage: R, t = QQ['t'].objgen()
     112    sage: f = 2*t^7 + 3*t^2 - 15/19
     113    sage: f^2
     114    4*t^14 + 12*t^9 - 60/19*t^7 + 9*t^4 - 90/19*t^2 + 225/361
     115    sage: cyclo = R.cyclotomic_polynomial(7); cyclo
     116    t^6 + t^5 + t^4 + t^3 + t^2 + t + 1
     117    sage: g = 7 * cyclo * t^5 * (t^5 + 10*t + 2)
     118    sage: g
     119    7*t^16 + 7*t^15 + 7*t^14 + 7*t^13 + 77*t^12 + 91*t^11 + 91*t^10 + 84*t^9
     120           + 84*t^8 + 84*t^7 + 84*t^6 + 14*t^5
     121    sage: F = factor(g); F
     122    (7) * t^5 * (t^5 + 10*t + 2) * (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1)
     123    sage: F.unit()
     124    7
     125    sage: list(F)
     126    [(t, 5), (t^5 + 10*t + 2, 1), (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1, 1)]
     127
     128Note que a fatorização corretamente leva em conta e armazena a parte
     129unitária.
     130
     131Se você fosse usar, por exemplo, a função ``R.cyclotomic_polynomial``
     132intensamente para algum projeto de pesquisa, além de citar o Sage,
     133você deveria tentar descobrir qual componente do Sage é de fato usado
     134para calcular esses polinômios, e citá-lo também. Nesse caso, se você
     135digitar ``R.cyclotomic_polynomial??`` para ver o código fonte, você
     136irá facilmente ver uma linha ``f = pari.polcyclo(n)`` o que significa
     137que o PARI é usado para o cálculo dos polinômios ciclotrômicos. Cite o
     138PARI também no seu trabalho.
     139
     140Dividindo dois polinômios cria-se um elemento do corpo de frações (o
     141qual o Sage cria automaticamente).
     142
     143::
     144
     145    sage: x = QQ['x'].0
     146    sage: f = x^3 + 1; g = x^2 - 17
     147    sage: h = f/g;  h
     148    (x^3 + 1)/(x^2 - 17)
     149    sage: h.parent()
     150    Fraction Field of Univariate Polynomial Ring in x over Rational Field
     151
     152Usando-se a série de Laurent, pode-se calcular a expansão em série no
     153corpo de frações de ``QQ[x]``:
     154
     155::
     156
     157    sage: R.<x> = LaurentSeriesRing(QQ); R
     158    Laurent Series Ring in x over Rational Field
     159    sage: 1/(1-x) + O(x^10)
     160    1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10)
     161
     162Se nomearmos a variável de outra forma, obtemos um anel de polinômios
     163em uma variável diferente.
     164
     165::
     166
     167    sage: R.<x> = PolynomialRing(QQ)
     168    sage: S.<y> = PolynomialRing(QQ)
     169    sage: x == y
     170    False
     171    sage: R == S
     172    False
     173    sage: R(y)
     174    x
     175    sage: R(y^2 - 17)
     176    x^2 - 17
     177
     178O anel é determinado pela variável. Note que criar um outro anel com
     179variável indeterminada ``x`` não retorna um anel diferente.
     180
     181::
     182
     183    sage: R = PolynomialRing(QQ, "x")
     184    sage: T = PolynomialRing(QQ, "x")
     185    sage: R == T
     186    True     
     187    sage: R is T
     188    True
     189    sage: R.0 == T.0
     190    True
     191
     192O Sage também possui suporte para séries de potências e séries de
     193Laurent sobre um anel arbitrário. No seguinte exemplo, nós criamos um
     194elemento de :math:`\GF{7}[[T]]` e dividimos para criar um elemento de
     195:math:`\GF{7}((T))`.
     196
     197::
     198
     199    sage: R.<T> = PowerSeriesRing(GF(7)); R
     200    Power Series Ring in T over Finite Field of size 7
     201    sage: f = T  + 3*T^2 + T^3 + O(T^4)
     202    sage: f^3
     203    T^3 + 2*T^4 + 2*T^5 + O(T^6)
     204    sage: 1/f
     205    T^-1 + 4 + T + O(T^2)
     206    sage: parent(1/f)
     207    Laurent Series Ring in T over Finite Field of size 7
     208
     209Você também pode criar anéis de polinômios usando a notação de
     210colchetes duplos:
     211
     212::
     213
     214    sage: GF(7)[['T']]
     215    Power Series Ring in T over Finite Field of size 7
     216
     217Polinômios em Mais De Uma Variável
     218----------------------------------
     219
     220Para trabalhar com polinômios em várias variáveis, nós primeiro
     221declaramos o anel de polinômios e as variáveis.
     222
     223::
     224
     225    sage: R = PolynomialRing(GF(5),3,"z") # here, 3 = number of variables
     226    sage: R
     227    Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
     228
     229Da mesma forma como ocorre com polinômios em uma variável, existem
     230três maneiras de fazer isso:
     231
     232::
     233
     234    sage: GF(5)['z0, z1, z2']
     235    Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
     236    sage: R.<z0,z1,z2> = GF(5)[]; R
     237    Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5
     238
     239Se você quiser usar os nomes das variáveis com apenas uma letra, então
     240você pode usar os seguinte comando:
     241
     242::
     243
     244    sage: PolynomialRing(GF(5), 3, 'xyz')
     245    Multivariate Polynomial Ring in x, y, z over Finite Field of size 5
     246
     247A seguir fazemos um pouco de aritmética.
     248
     249::
     250
     251    sage: z = GF(5)['z0, z1, z2'].gens()
     252    sage: z
     253    (z0, z1, z2)
     254    sage: (z[0]+z[1]+z[2])^2
     255    z0^2 + 2*z0*z1 + z1^2 + 2*z0*z2 + 2*z1*z2 + z2^2
     256
     257Você também pode usar uma notação mais matemática para criar um anel
     258de polinômios.
     259
     260::
     261
     262    sage: R = GF(5)['x,y,z']
     263    sage: x,y,z = R.gens()
     264    sage: QQ['x']
     265    Univariate Polynomial Ring in x over Rational Field
     266    sage: QQ['x,y'].gens()
     267    (x, y)
     268    sage: QQ['x'].objgens()
     269    (Univariate Polynomial Ring in x over Rational Field, (x,))
     270
     271Polinômios em mais de uma variável são implementados no Sage usando
     272dicionários em Python e a "representação distribuída" de um polinômio.
     273O Sage usa o Singular [Si]_, por exemplo, para o cálculo do maior
     274divisor comum e bases de Gröbner para ideais algébricos.
     275
     276::
     277
     278    sage: R, (x, y) = PolynomialRing(RationalField(), 2, 'xy').objgens()
     279    sage: f = (x^3 + 2*y^2*x)^2
     280    sage: g = x^2*y^2
     281    sage: f.gcd(g)
     282    x^2
     283
     284A seguir criamos o ideal :math:`(f,g)` gerado por :math:`f` e
     285:math:`g`, simplesmente multiplicando ``(f,g)`` por ``R`` (nós
     286poderíamos também escrever ``ideal([f,g])`` ou ``ideal(f,g)``).
     287
     288.. link
     289
     290::
     291
     292    sage: I = (f, g)*R; I
     293    Ideal (x^6 + 4*x^4*y^2 + 4*x^2*y^4, x^2*y^2) of Multivariate Polynomial
     294    Ring in x, y over Rational Field
     295    sage: B = I.groebner_basis(); B
     296    [x^6, x^2*y^2]
     297    sage: x^2 in I
     298    False
     299
     300A base de Gröbner acima não é uma lista mas sim uma sequência
     301imutável. Isso implica que ela possui universo (universe) e parente
     302(parent), e não pode ser modificada (o que é bom pois ocasionaria
     303erros em outras rotinas que usam bases de Gröbner).
     304
     305.. link
     306
     307::
     308
     309    sage: B.parent()
     310    Category of sequences in Multivariate Polynomial Ring in x, y over Rational
     311    Field
     312    sage: B.universe()
     313    Multivariate Polynomial Ring in x, y over Rational Field
     314    sage: B[1] = x
     315    Traceback (most recent call last):
     316    ...
     317    ValueError: object is immutable; please change a copy instead.
     318
     319Um pouco (não tanto quanto gostaríamos) de álgebra comutativa está
     320disponível no Sage, implementado via Singular. Por exemplo, podemos
     321calcular a decomposição primaria e primos associados de :math:`I`:
     322
     323.. link
     324
     325::
     326
     327    sage: I.primary_decomposition()
     328    [Ideal (x^2) of Multivariate Polynomial Ring in x, y over Rational Field,
     329     Ideal (y^2, x^6) of Multivariate Polynomial Ring in x, y over Rational Field]
     330    sage: I.associated_primes()
     331    [Ideal (x) of Multivariate Polynomial Ring in x, y over Rational Field,
     332     Ideal (y, x) of Multivariate Polynomial Ring in x, y over Rational Field]
  • new file doc/pt/tutorial/tour_rings.rst

    diff --git a/doc/pt/tutorial/tour_rings.rst b/doc/pt/tutorial/tour_rings.rst
    new file mode 100644
    - +  
     1.. _section-rings:
     2
     3Anéis Básicos
     4=============
     5
     6Quando se define matrizes, vetores, ou polinômios, é as vezes útil, e
     7as vezes necessário, especificar o "anel" sobre o qual o objeto será
     8definido. Um *anel* é uma estrutura matemática na qual se tem noções
     9de adição e multiplicação bem definidas; se você nunca ouviu falar
     10sobre anéis, você provavelmente só precisa saber a respeito dos
     11seguintes exemplos:
     12
     13* os inteiros `\{..., -1, 0, 1, 2,... \}`, que são chamados ``ZZ`` no
     14  Sage.
     15* os números racionais -- i. e., frações, ou razões, de inteiros --
     16  que são chamados ``QQ`` no Sage.
     17* os números reais, chamados de ``RR`` no Sage.
     18* os números complexos, chamados de ``CC`` no Sage.
     19
     20Você pode precisar saber sobre essas distinções porque o mesmo
     21polinômio, por exemplo, pode ser tratado diferentemente dependendo do
     22anel sobre o qual está definido. A propósito, o polinômio `x^2-2`
     23possui duas raízes, `\pm \sqrt{2}`. Essas raízes não são racionais,
     24logo, se você esta lidando com polinômios com coeficientes racionais,
     25os polinômios não serão fatorados. Com coeficientes reais, eles serão.
     26Portanto você pode querer especificar o anel para garantir que você
     27vai obter a informação que deseja. Os dois comandos a seguir definem
     28os conjuntos de polinômios com coeficientes racionais e coeficientes
     29reais, respectivamente. Os conjuntos são chamados "ratpoly" e
     30"realpoly", mas esses nomes não são importantes aqui; todavia, note
     31que as strings ".<t>" e ".<z>" especificam o nome das variáveis
     32usadas em cada caso.
     33
     34::
     35
     36    sage: ratpoly.<t> = PolynomialRing(QQ)
     37    sage: realpoly.<z> = PolynomialRing(RR)
     38
     39Agora ilustramos a nossa discussão sobre fatorar `x^2-2`:
     40
     41.. link
     42
     43::
     44
     45    sage: factor(t^2-2)
     46    t^2 - 2
     47    sage: factor(z^2-2)
     48    (z - 1.41421356237310) * (z + 1.41421356237310)
     49
     50Comentários similares também se aplicam a matrizes: a forma reduzida
     51de uma matriz pode depender do anel sobre o qual ela esta definida,
     52como também pode os seus autovalores e autovetores. Para mais sobre
     53polinômios, veja :ref:`section-poly`, para mais sobre matrizes, veja
     54:ref:`section-linalg`.
     55
     56O símbolo ``I`` representa a raiz quadrada de :math:`-1`; ``i`` é um
     57sinônimo de ``I``. Obviamente, isso não é um número racional::
     58
     59    sage: i  # square root of -1
     60    I     
     61    sage: i in QQ
     62    False
     63
     64Nota: O código acima pode não funcionar como esperado se a variável
     65``i`` estiver atribuída a um outro valor, por exemplo, se ela for
     66usada como a variável de um laço (loop). Nesse caso, digite::
     67
     68    sage: reset('i')
     69
     70para restabelecer o valor original de ``i``.
     71
     72Há uma sutileza ao definir números complexos: como mencionado acima,
     73o símbolo ``i`` representa a raiz quadrada de `-1`, mas é uma raiz
     74quadrada de `-1` *formal* ou *simbólica*. Evocando ``CC(i)`` ou
     75``CC.0`` obtém-se a raiz de `-1` complexa. Aritmética envolvendo tipos
     76diferentes de números é possível graças ao que se chama de coação,
     77veja :ref:`section-coercion`.
     78
     79::
     80
     81    sage: i = CC(i)       # floating point complex number
     82    sage: i == CC.0
     83    True
     84    sage: a, b = 4/3, 2/3
     85    sage: z = a + b*i
     86    sage: z
     87    1.33333333333333 + 0.666666666666667*I
     88    sage: z.imag()        # imaginary part
     89    0.666666666666667
     90    sage: z.real() == a   # automatic coercion before comparison
     91    True
     92    sage: a + b
     93    2
     94    sage: 2*b == a
     95    True
     96    sage: parent(2/3)
     97    Rational Field
     98    sage: parent(4/2)
     99    Rational Field
     100    sage: 2/3 + 0.1       # automatic coercion before addition
     101    0.766666666666667
     102    sage: 0.1 + 2/3       # coercion rules are symmetric in SAGE
     103    0.766666666666667
     104
     105Aqui estão mais exemplos de anéis básicos em Sage. Como observado
     106acima, o anel dos números racionais pode ser referido usando ``QQ``,
     107ou também ``RationalField()`` (um *corpo*, ou *field* em inglês, é um
     108anel no qual a operação de multiplicação é comutativa, e todo elemento
     109não-nulo possui um elemento inverso com respeito à operação de
     110multiplicação. Logo, os racionais formam um corpo, mas os inteiros
     111não)::
     112
     113    sage: RationalField()
     114    Rational Field
     115    sage: QQ
     116    Rational Field
     117    sage: 1/2 in QQ
     118    True
     119
     120O número decimal ``1.2`` é considerado como um elemento de ``QQ``:
     121número decimais que são também racionais podem ser coagidos ao conjunto de
     122números racionais (veja :ref:`section-coercion`). Os números `\pi` e
     123`\sqrt{2}` não são racionais, todavia::
     124
     125    sage: 1.2 in QQ
     126    True
     127    sage: pi in QQ
     128    False
     129    sage: pi in RR
     130    True
     131    sage: sqrt(2) in QQ
     132    False
     133    sage: sqrt(2) in CC
     134    True
     135
     136Para uso em matemática mais avançada, o Sage também pode especificar
     137outros anéis, como corpos finitos, inteiros `p`-ádicos, o anel dos
     138números algébricos, anéis de polinômios, e anéis de matrizes. Aqui
     139está a construção de alguns deles::
     140
     141    sage: GF(3)
     142    Finite Field of size 3
     143    sage: GF(27, 'a')  # need to name the generator if not a prime field
     144    Finite Field in a of size 3^3
     145    sage: Zp(5)
     146    5-adic Ring with capped relative precision 20
     147    sage: sqrt(3) in QQbar # algebraic closure of QQ
     148    True