# HG changeset patch # User Gustavo de Oliveira # 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 --- /dev/null +++ b/doc/pt/tutorial/afterword.rst @@ -0,0 +1,181 @@ +******** +Posfacio +******** + +Por quê o Python? +================= + +Vantagens do Python +------------------- + +A primeira linguagem de implementação do Sage é o Python (veja [Py]_), +embora rotinas que precisam ser muito rápidas são implementadas em uma +linguagem compilada. O Python possui várias vantagens: + +- **Salvar objetos** é bem suportado em Python. Existe suporte + extenso em Python para salvar (na grande maioria dos casos) objetos + arbitrários em arquivos em disco ou em uma base de dados. + +- Suporte excelente para **documentação** de funções e pacotes no + código fonte, incluindo extração automática de documentação e teste + automático de todos os exemplos. Os exemplos são automaticamente + testados regularmente para garantir que funcionam como indicado. + +- **Gerenciamento de memória:** O Python agora possui um sistema de + gerenciamento de memória e "garbage collector" muito bem pensados e + robustos que lidam corretamente com referências circulares, e + permitem variáveis locais em arquivos. + +- O Python possui **diversos pacotes** disponíveis que podem ser de + grande interesse para os usuários do Sage: análise numérica e + álgebra linear, visualização 2D e 3D, comunicação via rede (para + computação distribuída e servidores, por exemplo, via twisted), + suporte a base de dados, etc. + +- **Portabilidade:** O Python é fácil de compilar a partir do código + fonte em poucos minutos na maioria das arquiteturas. + +- **Manuseamento de exceções:** O Python possui um sofisticado e bem + pensado sistema de manuseamento de exceções, através do qual + programas podem facilmente se recuperar mesmo se ocorrerem erros no + código que está sendo executado. + +- **Debugador:** O Python inclui um debugador, de modo que quando + alguma rotina falha por algum motivo, o usuário pode acessar + extensiva informação sobre a pilha de cálculos e inspecionar o + estado de todas as variáveis relevantes. + +- **Profiler:** Existe um profiler para o Python, o qual executa + programas e cria um relatório detalhando quantas vezes e por quando + tempo cada função foi executada. + +- **Uma Linguagem:** Em vez de escrever uma **nova linguagem** para + matemática como foi feito para o Magma, Maple, Mathematica, Matlab, + GP/PARI, GAP, Macaulay 2, Simath, etc., nós usamos a linguagem + Python, que é uma linguagem de programação popular que está + sendo desenvolvida e otimizada ativamente por centenas de + engenheiros de software qualificados. O Python é uma grande + história de sucesso em desenvolvimento com código aberto com um + processo de desenvolvimento maduro (veja [PyDev]_). + +.. _section-mathannoy: + +O Pré-Processador: Diferenças entre o Sage e o Python +----------------------------------------------------- + +Alguns aspectos matemáticos do Python podem ser confusos, logo o Sage +se comporta diferentemente do Python em diversas situações. + +- **Notação para exponenciação:** ``**`` versus ``^``. Em Python, + ``^`` significa "xor", não exponenciação, logo em Python temos + + :: + + >>> 2^8 + 10 + >>> 3^2 + 1 + >>> 3**2 + 9 + + Esse uso de ``^`` pode parecer estranho, e é ineficiente para + pesquisa em matemática pura, pois a função "ou exclusivo" é + raramente usada. Por conveniência, o Sage pre-processa todos as + linhas de comandos antes de passá-las para o Python, substituindo + ocorrências de ``^`` que não estão em strings por ``**``: + + :: + + sage: 2^8 + 256 + sage: 3^2 + 9 + sage: "3^2" + '3^2' + +- **Divisão por inteiros:** A expressão em Python ``2/3`` não se + comporta da forma que um matemático esperaria. Em Python, se ``m`` + e ``n`` são inteiros (int), então ``m/n`` também é um inteiro + (int), a saber, o quociente de ``m`` dividido por ``n``. Portanto + ``2/3=0``. Tem havido discussões na comunidade do Python para + modificar o Python de modo que ``2/3`` retorne um número de + precisão flutuante (float) ``0.6666...``, e ``2//3`` retorne ``0``. + + Nós lidamos com isso no interpretador Sage, encapsulando inteiros + literais em ``Integer()`` e fazendo a divisão um construtor para + números racionais. Por exemplo: + + :: + + sage: 2/3 + 2/3 + sage: (2/3).parent() + Rational Field + sage: 2//3 + 0 + sage: int(2)/int(3) + 0 + +- **Inteiros longos:** O Python possui suporte nativo para inteiros + com precisão arbitrária, além de int's do C. Esses são + significantemente mais lentos do que os fornecidos pela biblioteca + GMP, e têm a propriedade que eles são impressos com o sufixo ``L`` + para distingui-los de int's (e isso não será modificado no futuro + próximo). O Sage implementa inteiros com precisão arbitrária usando + a biblioteca C do GMP, e esses são impressos sem o sufixo ``L``. + +Em vez de modificar o interpretador Python (como algumas pessoas +fizeram para projetos internos), nós usamos a linguagem Python +exatamente com ela é, e escrevemos um pré-processador para o IPython de +modo que o comportamento da linha de comando seja o que um matemático +espera. Isso significa que qualquer programa existente em Python pode +ser usado no Sage. Todavia, deve-se obedecer as regras padrão do +Python para escrever programas que serão importados no Sage. + +(Para instalar uma biblioteca do Python, por exemplo uma que você +tenha encontrado na internet, siga as instruções, mas execute ``sage +-python`` em vez de ``python``. Frequentemente isso significa digitar +``sage -python setup.py install``.) + +Eu gostaria de contribuir de alguma forma. Como eu posso? +========================================================= + +Se você quiser contribuir para o Sage, a sua ajuda será muito bem +vinda! Ela pode variar desde substancial quantidade de código, até +contribuições com respeito à documentação ou notificação de defeitos +(bugs). + +Explore a página na web do Sage para informações para desenvolvedores; +entre outras coisas, você pode encontrar uma lista longa de projetos +relacionados ao Sage ordenados por prioridade e categoria. O `Guia +para desenvolvedores do Sage +`_ (em inglês) também possui +informações úteis, e você pode também visitar o grupo de discussões +``sage-devel`` no Google Groups. + +Como eu faço referência ao Sage? +================================ + +Se você escrever um artigo usando o Sage, por favor faça referência +aos cálculos feitos com o Sage incluindo + +:: + + [Sage] William A. Stein et al., Sage Mathematics Software (Version 4.3). + The Sage Development Team, 2009, http://www.sagemath.org. + +na sua bibliografia (substituindo 4.3 pela versão do Sage que você +está usando). Além disso, procure observar quais componentes do Sage +você está usando em seus cálculos, por exemplo, PARI, Singular, GAP, +Maxima, e também site esses sistemas. Se você está em dúvida sobre +qual software está sendo usado em seus cálculos, fique à vontade para +perguntar no grupo ``sage-devel`` do Google Groups. Veja +:ref:`section-univariate` para mais discussões sobre esse aspecto. + +------------ + +Se por acaso você leu este tutorial do começo ao fim em uma só vez, e +faz idéia de quanto tempo você levou, por favor nos informe no grupo +``sage-devel`` do Google Groups. + +Divirta-se com o Sage! diff --git a/doc/pt/tutorial/appendix.rst b/doc/pt/tutorial/appendix.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/appendix.rst @@ -0,0 +1,33 @@ +******** +Apêndice +******** + +.. _section-precedence: + +Precedência de operações aritméticas binárias +============================================= + +Quanto é ``3^2*4 + 2%5``? A resposta (38) é determinada pela "tabela +de precedência" abaixo. A tabela abaixo é baseada na tabela em § 5.14 +do *Python Language Reference Manual* by G. Rossum and F. Drake. As +operações estão listadas aqui em ordem crescente de precedência. + + +========================== ================= +Operadores Descrição +========================== ================= +or "ou" booleano +and "e" booleano +not "não" booleano +in, not in pertence +is, is not teste de identidade +>, <=, >, >=, ==, !=, <> comparação ++, - adição, subtração +\*, /, % multiplicação, divisão, resto +\*\*, ^ exponenciação +========================== ================= + +Portanto, para calcular ``3^2*4 + 2%5``, O Sage inclui parenteses de +precedência da seguinte forma: ``((3^2)*4) + (2%5)``. Logo, primeiro +calcula ``3^2``, que é ``9``, então calcula ``(3^2)*4`` e ``2%5``, e +finalmente soma os dois. diff --git a/doc/pt/tutorial/bibliography.rst b/doc/pt/tutorial/bibliography.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/bibliography.rst @@ -0,0 +1,52 @@ +************ +Bibliografia +************ + +.. [Cyt] Cython, http://www.cython.org. + +.. [Dive] Dive into Python, disponível gratuitamente na internet em + http://diveintopython.org. + +.. [GAP] The GAP Group, GAP - Groups, Algorithms, and + Programming, Version 4.4; 2005, http://www.gap-system.org + +.. [GAPkg] GAP Packages, + http://www.gap-system.org/Packages/packages.html + +.. [GP] PARI/GP http://pari.math.u-bordeaux.fr/. + +.. [Ip] The IPython shell http://ipython.scipy.org. + +.. [Jmol] Jmol: an open-source Java viewer for chemical + structures in 3D http://www.jmol.org/. + +.. [Mag] Magma http://magma.maths.usyd.edu.au/magma/. + +.. [Max] Maxima http://maxima.sf.net/ + +.. [NagleEtAl2004] Nagle, Saff, and Snider. + *Fundamentals of Differential Equations*. 6th edition, Addison-Wesley, + 2004. + +.. [Py] The Python language http://www.python.org/ + Reference Manual http://docs.python.org/ref/ref.html. + +.. [PyDev] Guido, Some Guys, and a Mailing List: How Python is + Developed, + http://www.python.org/dev/dev_intro.html. + +.. [Pyr] Pyrex, + http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/. + +.. [PyT] The Python Tutorial http://www.python.org/. + +.. [SA] Sage web site http://www.sagemath.org/. + +.. [Si] G.-M. Greuel, G. Pfister, and H. Schönemann. Singular + 3.0. A Computer Algebra System for Polynomial Computations. Center + for Computer Algebra, University of Kaiserslautern (2005). + http://www.singular.uni-kl.de. + +.. [SJ] William Stein, David Joyner, Sage: System for Algebra and + Geometry Experimentation, Comm. Computer Algebra {39}(2005)61-64. + diff --git a/doc/pt/tutorial/conf.py b/doc/pt/tutorial/conf.py new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/conf.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# +# Sage documentation build configuration file, based on the file created by +# sphinx-quickstart on Thu Aug 21 20:15:55 2008. +# +# This file is execfile()d with the current directory set to its containing dir. +# +# The contents of this file are pickled, so don't put values in the namespace +# that aren't pickleable (module imports are okay, they're removed automatically). +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +import sys, os +sys.path.append(os.environ['SAGE_DOC']) +from common.conf import * + +# General information about the project. +project = u"Tutorial Sage" +name = u'tutorial-pt' +language = "pt_BR" + +# The name for this set of Sphinx documents. If None, it defaults to +# " v documentation". +html_title = project + " v"+release + +# Output file base name for HTML help builder. +htmlhelp_basename = name + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, author, document class [howto/manual]). +latex_documents = [ + ('index', name+'.tex', project, + u'The Sage Group', 'manual'), +] diff --git a/doc/pt/tutorial/index.rst b/doc/pt/tutorial/index.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/index.rst @@ -0,0 +1,46 @@ +.. Sage documentation master file, created by sphinx-quickstart on Thu Aug 21 20:15:55 2008. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Bem-vindo ao Tutorial Sage! +=========================== + +Sage é um software de matemática gratuito, de código aberto, para uso +em ensino e pesquisa em álgebra, geometria, teoria de números, +criptografia, computação numérica, e áreas relacionadas. Tanto o +modelo de desenvolvimento como a tecnologia empregada no Sage se +distinguem pela forte ênfase em transparência, cooperação, e +colaboração: estamos desenvolvendo o carro, não reinventando a roda. O +objetivo maior do Sage é criar uma alternativa viável, gratuita, e de +código aberto aos programas Maple, Mathematica, Magma e MATLAB. + +Este tutorial é a melhor forma de se familiarizar com o Sage em apenas +algumas horas. Você pode lê-lo em versão HTML ou PDF, ou diretamente +no Notebook Sage (clique em ``Help``, e então clique em ``Tutorial`` +para percorrer o tutorial de forma iterativa diretamente do Sage). + +Este documento está sob a licença `Creative Commons CompartilhaIgual +3.0`__. + +__ http://creativecommons.org/licenses/by-sa/3.0/deed.pt + +.. toctree:: + :maxdepth: 2 + + introduction + tour + interactive_shell + interfaces + latex + programming + sagetex + afterword + appendix + bibliography + +Índices e tabelas +================= + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/doc/pt/tutorial/interactive_shell.rst b/doc/pt/tutorial/interactive_shell.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/interactive_shell.rst @@ -0,0 +1,1024 @@ +.. _chapter-interactive_shell: + +***************************** +A Linha de Comando Interativa +***************************** +Na maior parte deste tutorial, assumimos que você iniciou o +interpretador Sage usando o comando ``sage``. Isso inicia uma versão +personalizada da linha de comando IPython, e importa diversas funções +e classes de modo que elas fiquem prontas para serem usadas a partir +da linha de comando. Configuração adicional é possível editando o +arquivo ``$SAGE_ROOT/ipythonrc``. Assim que você inicia o Sage, você +obtém o seguinte: + +.. skip + +:: + + ---------------------------------------------------------------------- + | SAGE Version 3.1.1, Release Date: 2008-05-24 | + | Type notebook() for the GUI, and license() for information. | + ---------------------------------------------------------------------- + sage: + +Para sair do Sage pressione Ctrl-D ou digite ``quit`` ou ``exit``. + +.. skip + +:: + + sage: quit + Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s) + +O wall time é o tempo que passou no relógio "pendurado na sua parede". +Isso é relevante, pois o tempo CPU não conta o tempo usado por +subprocessos como GAP ou Singular. + +(Evite terminar um processo do Sage usando ``kill -9`` a partir de um +terminal, pois o Sage pode não terminal seus subprocessos, por +exemplo, subprocessos do Maple, ou limpeza de arquivos temporários em +``$HOME/.sage/tmp``.) + +A Sua Sessão no Sage +==================== + +A sessão é a sequência de entradas e saídas de dados desde o momento em +que você inicia até o momento em que você termina o Sage. O Sage grava +todas as entradas de dados, através do IPython. De fato, se você está +usando a linha de comando (não o Notebook), então a qualquer momento +você pode digitar ``%history`` (ou ``%hist``) para obter uma lista de +todas as linhas digitadas até então. Você pode digitar ``?`` no prompt +do Sage para aprender mais sobre o IPython, por exemplo, "IPython +offers numbered prompts ... with input and output caching. All input +is saved and can be retrieved as variables (besides the usual arrow +key recall). The following GLOBAL variables always exist (so don't +overwrite them!)": + +:: + + _: previous input (interactive shell and notebook) + __: next previous input (interactive shell only) + _oh : list of all inputs (interactive shell only) + +Aqui vai um exemplo: + +.. skip + +:: + + sage: factor(100) + _1 = 2^2 * 5^2 + sage: kronecker_symbol(3,5) + _2 = -1 + sage: %hist #This only works from the interactive shell, not the notebook. + 1: factor(100) + 2: kronecker_symbol(3,5) + 3: %hist + sage: _oh + _4 = {1: 2^2 * 5^2, 2: -1} + sage: _i1 + _5 = 'factor(ZZ(100))\n' + sage: eval(_i1) + _6 = 2^2 * 5^2 + sage: %hist + 1: factor(100) + 2: kronecker_symbol(3,5) + 3: %hist + 4: _oh + 5: _i1 + 6: eval(_i1) + 7: %hist + +Vamos omitir a numeração das linhas no restante deste tutorial e em +outras documentações do Sage. + +Você também pode salvar uma lista de comandos em uma macro. + +.. skip + +:: + + sage: E = EllipticCurve([1,2,3,4,5]) + sage: M = ModularSymbols(37) + sage: %hist + 1: E = EllipticCurve([1,2,3,4,5]) + 2: M = ModularSymbols(37) + 3: %hist + sage: %macro em 1-2 + Macro `em` created. To execute, type its name (without quotes). + + +.. skip + +:: + + sage: E + Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over + Rational Field + sage: E = 5 + sage: M = None + sage: em + Executing Macro... + sage: E + Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over + Rational Field + +Quando se usa a linha de comando, qualquer comando UNIX pode ser +executado a partir do Sage inserindo um ponto de exclamação ``!`` como +prefixo. Por exemplo, + +.. skip + +:: + + sage: !ls + auto example.sage glossary.tex t tmp tut.log tut.tex + +fornece a lista de arquivos do atual diretório. + +O ``PATH`` possui o diretório bin do Sage em primeiro, portanto se +você digitar ``p``, ``gap``, ``singular``, ``maxima``, etc., você +executa a versão incluída no Sage. + +.. skip + +:: + + sage: !gp + Reading GPRC: /etc/gprc ...Done. + + GP/PARI CALCULATOR Version 2.2.11 (alpha) + i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version + ... + sage: !singular + SINGULAR / Development + A Computer Algebra System for Polynomial Computations / version 3-0-1 + 0< + by: G.-M. Greuel, G. Pfister, H. Schoenemann \ October 2005 + FB Mathematik der Universitaet, D-67653 Kaiserslautern \ + +Gravando Entradas e Saídas de dados +=================================== + +Gravar a sua sessão no Sage não é o mesmo que salvá-la (veja +:ref:`section-save`). Para gravar a entrada de dados (e opcionalmente +a saída) use o comando ``logstart``. Digite ``logstart?`` para mais +detalhes. Você pode usar esse comando para gravar tudo o que você +digita, toda a saída de dados, e até mesmo usar essa entrada de dados +que você guardou em uma sessão futura (simplesmente importando o +arquivo log). + +.. skip + +:: + + was@form:~$ sage + ---------------------------------------------------------------------- + | SAGE Version 3.0.2, Release Date: 2008-05-24 | + | Type notebook() for the GUI, and license() for information. | + ---------------------------------------------------------------------- + + sage: logstart setup + Activating auto-logging. Current session state plus future input saved. + Filename : setup + Mode : backup + Output logging : False + Timestamping : False + State : active + sage: E = EllipticCurve([1,2,3,4,5]).minimal_model() + sage: F = QQ^3 + sage: x,y = QQ['x,y'].gens() + sage: G = E.gens() + sage: + Exiting SAGE (CPU time 0m0.61s, Wall time 0m50.39s). + was@form:~$ sage + ---------------------------------------------------------------------- + | SAGE Version 3.0.2, Release Date: 2008-05-24 | + | Type notebook() for the GUI, and license() for information. | + ---------------------------------------------------------------------- + + sage: load "setup" + Loading log file one line at a time... + Finished replaying log file + sage: E + Elliptic Curve defined by y^2 + x*y = x^3 - x^2 + 4*x + 3 over Rational + Field + sage: x*y + x*y + sage: G + [(2 : 3 : 1)] + +Se você usa o Sage no terminal ``konsole`` do Linux KDE, então você +pode gravar a sessão da seguinte forma: após iniciar o Sage no +``konsole``, selecione "settings", então "history...", então "set +unlimited". Quando você estiver pronto para guardar a sua sessão, +selecione "edit" e então "save history as..." e digite um nome para +salvar o texto de sua sessão em seu computador. Após salvar esse +arquivo, você poderia abri-lô em um editor, tal como o xemacs, e +imprimi-lo. + +Colar Texto Ignora Prompts +========================== + +Suponha que você está lendo uma sequência de comandos em Sage ou +Python e quer copiá-los no Sage. Mas eles têm os irritantes prompts +``>>>`` ou ``sage:`` para te aborrecer. De fato, você pode copiar e +colar um exemplo, incluindo os prompts se você quiser, no Sage. Em +outras palavras, automaticamente o Sage remove os caracteres ``>>>`` +ou ``sage:`` antes de colar o conteúdo no Python. Por exemplo, + +.. skip + +:: + + sage: 2^10 + 1024 + sage: sage: sage: 2^10 + 1024 + sage: >>> 2^10 + 1024 + +Comandos de Tempo +================= + +Se você colocar o comando ``%time`` no começo de uma linha de comando, +o tempo que o comando leva para ser executado vai aparecer após a +saída de dados. Por exemplo, nós podemos comparar o tempo de execução +para certas operações de exponenciação de várias formas. Os tempos +abaixo vão ser provavelmente muito diferentes para o seu computador, +ou até mesmo para versões diferentes do Sage. Primeiro, usando o +Python + +.. skip + +:: + + sage: %time a = int(1938)^int(99484) + CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s + Wall time: 0.66 + +Isso significa que levou 0.66 segundos no total, e o wall time, isto +é, a quantidade de tempo que passou no seu relógio de parede, é também +0.66 segundos. Se o seu computador está executado outros programas o +wall time pode ser muito maior do que o tempo de CPU. + +A seguir verificamos o tempo de exponenciação usando o tipo Integer do +Sage, o qual é implementado (em Cython) usando a biblioteca GMP: + +.. skip + +:: + + sage: %time a = 1938^99484 + CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s + Wall time: 0.04 + +Usando a biblioteca C do PARI: + +.. skip + +:: + + sage: %time a = pari(1938)^pari(99484) + CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s + Wall time: 0.05 + +A GMP é melhor, mas por pouco (como esperado, pois a versão do PARI +contida no Sage usa a GMP para aritmética de inteiros). + +Você pode também contar o tempo de um bloco de comandos usado o +comando ``cputime``, como ilustrado abaixo: + +:: + + sage: t = cputime() + sage: a = int(1938)^int(99484) + sage: b = 1938^99484 + sage: c = pari(1938)^pari(99484) + sage: cputime(t) # somewhat random output + 0.64 + +.. skip + +:: + + sage: cputime? + ... + Return the time in CPU second since SAGE started, or with optional + argument t, return the time since time t. + INPUT: + t -- (optional) float, time in CPU seconds + OUTPUT: + float -- time in CPU seconds + +O comando ``walltime`` se comporta como o comando ``cputime``, exceto +que ele conta o tempo do relógio. + +Nós podemos também calcular a potência acima em alguns softwares de +álgebra incluídos no Sage. Em cada caso executamos um comando trivial +no sistema de modo a inicializar o servidor para aquele programa. O +tempo mais relevante é o tempo do relógio. Todavia, se houver uma +diferença significativa entre o wall time e o CPU time então isso pode +indicar algum problema de performance que vale a pena investigar. + +.. skip + +:: + + sage: time 1938^99484; + CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s + Wall time: 0.01 + sage: gp(0) + 0 + sage: time g = gp('1938^99484') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 0.04 + sage: maxima(0) + 0 + sage: time g = maxima('1938^99484') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 0.30 + sage: kash(0) + 0 + sage: time g = kash('1938^99484') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 0.04 + sage: mathematica(0) + 0 + sage: time g = mathematica('1938^99484') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 0.03 + sage: maple(0) + 0 + sage: time g = maple('1938^99484') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 0.11 + sage: gap(0) + 0 + sage: time g = gap.eval('1938^99484;;') + CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s + Wall time: 1.02 + +Note que o GAP e o Maxima são os mais lentos neste teste (isso foi +executado no computador ``sage.math.washington.edu``). Devido ao +"overhead" da interface pexpect, talvez não seja apropriado comparar +esses resultados com o Sage, que é o mais rápido. + +Outras Dicas para o IPython +=========================== + +Como observado acima, o Sage usa o IPython como interface, logo você +pode usar quaisquer comandos e recursos do IPython. Você pode ler a +`Documentação completa do IPython +`_ (em inglês). + +- Você pode usar ``%bg`` para executar um comando no background, e + então usar ``jobs`` para acessar os resultados, da seguinte forma. + (Os comentários ``not tested`` estão aqui porque a sintaxe ``%bg`` + não funciona bem com o sistema de testes automáticos do Sage. Se + você digitar esses comandos, eles devem funcionar. Isso é obviamente + mais útil com comandos que demoram para serem completados.) + + :: + + sage: def quick(m): return 2*m + sage: %bg quick(20) # not tested + Starting job # 0 in a separate thread. + sage: jobs.status() # not tested + Completed jobs: + 0 : quick(20) + sage: jobs[0].result # the actual answer, not tested + 40 + + Note que os comandos executados no background não usam o + pre-processador (preparser) do Sage -- veja :ref:`section-mathannoy` + para mais informações. Uma forma (estranha talvez) de contornar esse + problema seria executar :: + + sage: %bg eval(preparse('quick(20)')) # not tested + + É mais seguro e simples, todavia, usar ``%bg`` apenas em comandos + que não requerem o pre-processador (preparser). + +- Você pode usar ``%edit`` (ou ``%ed`` ou ``ed``) para abrir um + editor, se você desejar digitar algum código mais complexo. Antes de + iniciar o Sage, certifique-se de que a variável de environment + :envvar:`EDITOR` está definida com o seu editor favorito (colocando + ``export EDITOR=/usr/bin/emacs`` ou ``export EDITOR=/usr/bin/vim`` + or algo similar no lugar apropriado, como um arquivo ``.profile``). + A partir do prompt do Sage, o comando ``%edit`` irá abrir o editor + escolhido. Então usando o editor você pode definir uma função:: + + def some_function(n): + return n**2 + 3*n + 2 + + Salve e feche o editor. No restante da sua sessão do Sage, você pode + usar então a função ``some_function``. Se você quiser modificá-la, + digite ``%edit some_function`` no prompt do Sage. + +- Se você for calcular algo e quiser modificar o resultado para outro + uso, execute o cálculo e então digite ``%rep``: isso irá colocar o + resultado do comando anterior no prompt do Sage, pronto para ser + editado.:: + + sage: f(x) = cos(x) + sage: f(x).derivative(x) + -sin(x) + + A esta altura, se você digitar ``%rep`` no prompt do Sage, você irá + obter um novo prompt, seguido de ``-sin(x)``, com o cursor no final + da linha. + +Para mais informações, digite ``%quickref`` para ver um guia rápido de +referência do IPython. Quando este tutorial foi escrito (April 2011), +o Sage usa a versão 0.9.1 do IPython, e a `documentation for its magic +commands `_ +está disponível na internet. + + +Erros e Exceções +================ + +Quando algo errado ocorre, você usualmente verá uma "exceção" do +Python. O Python até mesmo tenta sugerir o que ocasionou a exceção, +por exemplo, ``NameError`` ou ``ValueError`` (veja o Manual de +Referência do Python [Py]_ para uma lista completa de exceções). Por +exemplo, + +.. skip + +:: + + sage: 3_2 + ------------------------------------------------------------ + File "", line 1 + ZZ(3)_2 + ^ + SyntaxError: invalid syntax + + sage: EllipticCurve([0,infinity]) + ------------------------------------------------------------ + Traceback (most recent call last): + ... + TypeError: Unable to coerce Infinity () to Rational + +O debugador interativo é as vezes útil para entender o que houve de +errado. Você pode ativá-lo e desativá-lo usando ``%pdb`` (o padrão é +desativado). O prompt ``ipdb>`` aparece se uma exceção é levantada e o +debugador está ativado. A partir do debugador, você pode imprimir o +estado de qualquer variável local, e mover a pilha de execução para +cima e para baixo. Por exemplo, + +.. skip + +:: + + sage: %pdb + Automatic pdb calling has been turned ON + sage: EllipticCurve([1,infinity]) + --------------------------------------------------------------------------- + Traceback (most recent call last) + ... + + ipdb> + +Para uma lista de comandos do debugador, digite ``?`` no prompt +``ipbd>``: + +:: + + ipdb> ? + + Documented commands (type help ): + ======================================== + EOF break commands debug h l pdef quit tbreak + a bt condition disable help list pdoc r u + alias c cont down ignore n pinfo return unalias + args cl continue enable j next pp s up + b clear d exit jump p q step w + whatis where + + Miscellaneous help topics: + ========================== + exec pdb + + Undocumented commands: + ====================== + retval rv + +Digite Ctrl-D ou ``quit`` para retornar ao Sage. + +.. _section-tabcompletion: + +Busca Reversa e Completamento Tab +================================== + +Busca reversa: Digite o começo de um comando, e então ``Ctrl-p`` (ou +tecle a seta para cima) para voltar para cada linha que você digitou +que começa daquela forma. Isso funciona mesmo se você encerrou o Sage +e iniciou novamente mais tarde. Você também pode fazer uma busca +reversa ao longo da história usando ``Ctrl-r``. Todos esses recursos +usam o pacote ``readline``, que está disponível no Linux. + +Para ilustrar a busca reversa, primeiro crie o e espaço vetorial +tri-dimensional :math:`V=\QQ^3` da seguinte forma: + +:: + + sage: V = VectorSpace(QQ,3) + sage: V + Vector space of dimension 3 over Rational Field + +Você pode usar a seguinte notação mais compacta: + +:: + + sage: V = QQ^3 + +Então é fácil listar todas as funções para :math:`V` usando +completamento. Digite ``V``, e então pressione a tecla ``[tab]`` no +seu teclado: + +.. skip + +:: + + sage: V.[tab key] + V._VectorSpace_generic__base_field + ... + V.ambient_space + V.base_field + V.base_ring + V.basis + V.coordinates + ... + V.zero_vector + +Se você digitar as primeiras letras de uma função, e então a tecla +``[tab]``, você obtém apenas funções que começam conforme indicado. + +.. skip + +:: + + sage: V.i[tab key] + V.is_ambient V.is_dense V.is_full V.is_sparse + +Se você gostaria de saber o que uma função faz, por exemplo, a função +coordinates, digite ``V.coordinates?`` para ajuda ou +``V.coordinates??`` para ver o código fonte, como explicado na próxima +sessão. + + + +Sistema de Ajuda Integrado +========================== + +O Sage possui um sistema de ajuda integrado. Digite o nome da função +seguido de ? para ver informações sobre a função. + +.. skip + +:: + + sage: V = QQ^3 + sage: V.coordinates? + Type: instancemethod + Base Class: + String Form: + Namespace: Interactive + File: /home/was/s/local/lib/python2.4/site-packages/sage/modules/f + ree_module.py + Definition: V.coordinates(self, v) + Docstring: + Write v in terms of the basis for self. + + Returns a list c such that if B is the basis for self, then + + sum c_i B_i = v. + + If v is not in self, raises an ArithmeticError exception. + + EXAMPLES: + sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens() + sage: W = M.submodule([M0 + M1, M0 - 2*M1]) + sage: W.coordinates(2*M0-M1) + [2, -1] + +Como mostrado acima, o comando de ajuda mostra o tipo do objeto, o +arquivo no qual ele é definido, e uma descrição útil da função com +exemplos que você pode colar na sua sessão atual. Quase todos esses +exemplos são regularmente testados automaticamente para certificar que +eles se comportam exatamente como esperado. + +Outro recurso que vai muito na direção do espírito de código aberto do +Sage é que se ``f`` é uma função do Python, então o comando ``f??`` +mostra o código fonte que define ``f``. Por exemplo, + +.. skip + +:: + + sage: V = QQ^3 + sage: V.coordinates?? + Type: instancemethod + ... + Source: + def coordinates(self, v): + """ + Write $v$ in terms of the basis for self. + ... + """ + return self.coordinate_vector(v).list() + +Isso nos diz que tudo que a função ``coordinates`` faz é chamar a +função ``coordinate_vector`` e converter o resultado para uma lista. O +que a função ``coordinate_vector`` faz? + +.. skip + +:: + + sage: V = QQ^3 + sage: V.coordinate_vector?? + ... + def coordinate_vector(self, v): + ... + return self.ambient_vector_space()(v) + +A função ``coordinate_vector`` coage a sua entrada em um espaço +ambiente, o que tem o efeito de calcular o vetor de coeficientes de +:math:`v` em termos de :math:`V`. O espaço :math:`V` já é o espaço +ambiente pois é simplesmente :math:`\QQ^3`. Existe também uma função +``coordinate_vector`` para subespaços, que é diferente. Vamos criar um +subespaço e ver: + +.. skip + +:: + + sage: V = QQ^3; W = V.span_of_basis([V.0, V.1]) + sage: W.coordinate_vector?? + ... + def coordinate_vector(self, v): + """ + ... + """ + # First find the coordinates of v wrt echelon basis. + w = self.echelon_coordinate_vector(v) + # Next use transformation matrix from echelon basis to + # user basis. + T = self.echelon_to_user_matrix() + return T.linear_combination_of_rows(w) + +(Se você acha que a implementação é ineficiente, por favor junte-se a +nós para ajudar a optimizar as funções de álgebra linear.) + +Você também pode digitar ``help(command_name)`` ou ``help(class)`` +para ler um arquivo de ajuda sobre determinada classe. + +.. skip + +:: + + sage: help(VectorSpace) + Help on class VectorSpace ... + + class VectorSpace(__builtin__.object) + | Create a Vector Space. + | + | To create an ambient space over a field with given dimension + | using the calling syntax ... + : + : + +Quando você digita ``q`` para sair do sistema de ajuda, a sua sessão +aparece na tela da mesma forma que anteriormente. O texto de ajuda não +fica permanentemente em sua tela, ao contrário da saída de +``function_name?`` que as vezes fica. É partircularmente útil digitar +``help(module_name)``. Por exemplo, espaços vetoriais são definidos em +``sage.modules.free_module``, então digite +``help(sage.modules.free_module)`` para obter documentação sobre esse +módulo. Quando visualizando documentação usando a ajuda, você pode +procurar no texto digitando ``/`` e na ordem reversa digitando ``?``. + +Salvando e Carregando Objetos Individuais +========================================= + +Suponha que você calcule uma matriz, ou pior ainda, um espaço +complicado de símbolos, e gostaria de salvá-los para uso posterior. O +que você pode fazer? Existem várias estratégias que os sistemas +computacionais de álgebra adotam para salvar objetos individuais. + +#. **Salve seus cálculos:** Suportam apenas salvar e carregar uma + sessão completa (por exemplo, GAP, Magma). + +#. **Entrada e Saída Unificadas:** Faz com que cada objeto seja + impresso de uma forma que possa ser lido novamente (GP/PARI). + +#. **Eval:** Torna fácil processar um código arbitrário no + interpretador (por exemplo, Singular, PARI). + + + +Como o Sage usa o Python, ele adota uma estratégia diferente, que se +baseia no fato de que qualquer objeto pode ser "serializado", isto é, +transformado em uma string a partir da qual o objeto pode ser +recuperado. Isso segue o espírito da estratégia unificada de entrada e +saída do PARI, exceto que não possue a desvantagem que os objetos são +impressos na tela em uma forma muito complicada. Além disso, o suporte +para salvar e recuperar é (na maior parte dos casos) completamente +automática, não requerendo nenhuma programação extra; é simplesmente um +recurso do Python que foi implementado na linguagem desde o início de +seu desenvolvimento. + +Quase todos os objetos ``x`` podem ser armazenados em disco de forma +comprimida usando ``save(x, filename)`` (ou em muitos casos +``x.save(filename)``). Para carregar o objeto de volta no Sage use +``load(filename)``. + +.. skip + +:: + + sage: A = MatrixSpace(QQ,3)(range(9))^2 + sage: A + [ 15 18 21] + [ 42 54 66] + [ 69 90 111] + sage: save(A, 'A') + +Você deve agora sair do Sage e reiniciá-lo. Então você pode obter +``A`` de volta: + +.. skip + +:: + + sage: A = load('A') + sage: A + [ 15 18 21] + [ 42 54 66] + [ 69 90 111] + +Você pode fazer o mesmo com objetos mais complicados, por exemplo, +curvas elípticas. Todos os dados sobre o objeto são guardados e +restaurados com o objeto. Por exemplo, + +.. skip + +:: + + sage: E = EllipticCurve('11a') + sage: v = E.anlist(100000) # takes a while + sage: save(E, 'E') + sage: quit + +A versão em disco de ``E`` ocupa 153 kilobytes, pois ela guarda os +primeiros 1000000 :math:`a_n` com ela. + +.. skip + +:: + + ~/tmp$ ls -l E.sobj + -rw-r--r-- 1 was was 153500 2006-01-28 19:23 E.sobj + ~/tmp$ sage [...] + sage: E = load('E') + sage: v = E.anlist(100000) # instant! + +(Em Python, salvar e restaurar é feito usando o módulo ``cPickle``. Em +particular, um objeto ``x`` do Sage pode ser salvado usando +``cPickle.dumps(x, 2)``. Note o ``2``!) + +O sage não pode salvar e carregar objetos criados em algum outro +sistema computacional de álgebra, por exemplo, GAP, Singular, Maxima, +etc. Eles são carregados em um estado "inválido". Em GAP, embora +muitos objetos podem ser impressos de uma forma que eles podem ser +reconstruídos, muitos não, logo reconstrução a partir de suas +representações impressas não é permitido. + +.. skip + +:: + + sage: a = gap(2) + sage: a.save('a') + sage: load('a') + Traceback (most recent call last): + ... + ValueError: The session in which this object was defined is no longer + running. + +Objetos do GP/PARI também podem ser salvados e carregados pois suas +representações em forma impressa são suficientes para reconstruí-los. + +.. skip + +:: + + sage: a = gp(2) + sage: a.save('a') + sage: load('a') + 2 + +Objetos que foram salvados podem ser abertos posteriormente em +computadores com arquiteturas e sistemas operacionais diferentes, por +exemplo, você poderia salvar uma matriz muito grande em um OS X de +32-bits e abri-lo em um Linux de 64-bits, encontrar a forma reduzida, +e movê-lo de volta. Além disso, em muitos casos você pode até mesmo +abrir objetos em versões do Sage diferentes daquela no qual o objeto +foi salvo, desde que o código para aquele objeto não seja muito +diferente. Todos os atributos do objetos são armazendos, assim como a +classe (mas não o código fonte) que define o objeto. Se aquela classe +não existir mais em uma nova versão do Sage, então o objeto não pode +ser reaberto nessa versão. Mas você poderia abri-lo em uma versão mais +antiga, obter o dicionário do objeto (com ``x.__dict__``), salvar o +dicionário, e abri-lo em uma versão mais nova. + +Salvando como Texto +------------------- + +Você também pode salvar a representação em texto (ASCII) de objetos em +um arquivo, simplesmente abrindo um arquivo em modo de escrita, e +escrevendo a string que representa o objeto no arquivo (você pode +salvar mais de um objeto dessa forma). Quando você terminar de +escrever os objetos, feche o arquivo. + +.. skip + +:: + + sage: R. = PolynomialRing(QQ,2) + sage: f = (x+y)^7 + sage: o = open('file.txt','w') + sage: o.write(str(f)) + sage: o.close() + +.. _section-save: + +Salvando e Abrindo Sessões Completas +==================================== + +O Sage é flexível para salvar e abrir sessões completas. + +O comando ``save_session(sessionname)`` salva todas as variáveis que +você definiu na sessão atual como um dicionário com o nome +``sessionname``. (No caso raro de uma variável não poder ser salva, +ela simplesmente não aparece no dicionário.) O resultado é um arquivo +``.sobj`` que pode ser aberto como qualquer outro objeto que foi +salvado. Quando você abre os objetos que foram salvados em uma sessão, +você obtém um dicionário cujas chaves (keys) são os nomes das +variáveis e os valores são os objetos. + +Você pode usar o comando ``load_session(sessionname)`` para carregar +na presente sessão as variáveis definidas em ``sessioname``. Note que +isso não remove as variáveis já definidas na presente sessão; em vez +disso, as duas sessões são combinadas. + +Primeiro iniciamos o Sage e definimos algumas variáveis. + +.. skip + +:: + + sage: E = EllipticCurve('11a') + sage: M = ModularSymbols(37) + sage: a = 389 + sage: t = M.T(2003).matrix(); t.charpoly().factor() + _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2 + +A seguir nós salvamos a nossa sessão, o que armazena cada uma das +variáveis acima em um arquivo. Então visualizamos o arquivo, que tem +por volta de 3K bytes. + +.. skip + +:: + + sage: save_session('misc') + Saving a + Saving M + Saving t + Saving E + sage: quit + was@form:~/tmp$ ls -l misc.sobj + -rw-r--r-- 1 was was 2979 2006-01-28 19:47 misc.sobj + +Por fim reiniciamos o Sage, definimos algumas variáveis extra, e +carregamos a sessão que foi salva anteriormente. + +.. skip + +:: + + sage: b = 19 + sage: load_session('misc') + Loading a + Loading M + Loading E + Loading t + +Cada variável que foi salva está de novo disponível. Além disso, a +variável ``b`` não foi redefinida. + +.. skip + +:: + + sage: M + Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0 + and dimension 5 over Rational Field + sage: E + Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational + Field + sage: b + 19 + sage: a + 389 + + + +.. _section-notebook: + +A Interface do Notebook +======================= + +O Sage Notebook é iniciado digitando + +.. skip + +:: + + sage: notebook() + +na linha de comando do Sage. Isso inicia o Notebook e abre o seu +browser padrão para visualizá-lo. Os arquivos de estado do servidor +são armazenados em ``$HOME/.sage/sage\_notebook``. + +Outras opções incluem: + +.. skip + +:: + + sage: notebook("directory") + +a qual inicia um novo servidor para o Notebook usando arquivos em um +dado diretório, em vez do diretório padrão +``$HOME/.sage/sage_notebook``. Isso pode ser útil se você quiser ter +uma coleção de folhas de trabalho (worksheets) associadas com um +projeto específico, ou executar vários Notebooks separadamente ao +mesmo tempo. + +Quando você inicia o Notebook, ele primeiro cria os seguintes arquivos +em ``$HOME/.sage/sage_notebook``: + +:: + + nb.sobj (the notebook SAGE object file) + objects/ (a directory containing SAGE objects) + worksheets/ (a directory containing SAGE worksheets). + +Após criar os arquivos acima, o Notebook inicia o servidor web. + +Um "Notebook" é uma coleção de contas de usuário, cada qual pode ter +várias folhas de trabalho (worksheets). Quando você cria uma nova +folha de trabalho, os dados dela são armazenados no diretórios +``worksheets/username/number``. Em cada diretório desse há um arquivo +texto ``worksheet.txt`` - se algum problema ocorrer com as suas +folhas de trabalho, ou com o Sage, esse arquivo texto contém toda +informação necessária para reconstruir a folha de trabalho. + +A partir do Sage, digite ``notebook?`` para mais informações sobre +como iniciar um servidor. + +O seguinte diagrama ilustra a arquitetura do Notebook Sage: + +:: + + ---------------------- + | | + | | + | firefox/safari | + | | + | javascript | + | program | + | | + | | + ---------------------- + | ^ + | AJAX | + V | + ---------------------- + | | + | sage | SAGE process 1 + | web | ------------> SAGE process 2 (Python processes) + | server | pexpect SAGE process 3 + | | . + | | . + ---------------------- . + +Para ajuda sobre as teclas de atalho disponíveis no Notebook, clique +no link ``Help``. diff --git a/doc/pt/tutorial/interfaces.rst b/doc/pt/tutorial/interfaces.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/interfaces.rst @@ -0,0 +1,341 @@ +.. linkall + +********** +Interfaces +********** + +Uma característica central do Sage é que ele permite fazer cálculos +com objetos em vários sistemas de álgebra computacional usando uma +interface comum e uma linguagem de programação clara. + +Os métodos console e interact de uma interface executam tarefas bem +diferentes. Por exemplo, usando GAP: + +#. ``gap.console()``: Isso abre um console do GAP - o controle é + transferido para o GAP. Aqui o Sage não é nada mais do que uma + forma conveniente de executar um programa, similar à shell Bash do + Linux. + +#. ``gap.interact()``: Essa é uma forma de interagir com uma instância + do GAP que pode estar cheia de objetos do Sage. Você pode + importar objetos nessa seção do GAP (até mesmo a partir da + interface interativa), etc. + + +.. index: PARI; GP + +GP/PARI +======= + +O PARI é um programa em C muito compacto, maduro, e extremamente +otimizado cujo foco primário é teoria de números. Existem duas +interfaces distintas que podem ser usadas no Sage: + + +- ``gp`` - o "**G** do **P** ARI" interpretador, e + +- ``pari`` - a biblioteca C do PARI. + +Por exemplo, os seguintes comandos são duas formas de realizar a mesma +coisa. Eles parecem idênticos, mas o resultado é na verdade +diferente, e o que acontece por trás da cena é bastante diferente. + +:: + + sage: gp('znprimroot(10007)') + Mod(5, 10007) + sage: pari('znprimroot(10007)') + Mod(5, 10007) + +No primeiro caso, uma cópia separada do interpretador GP é iniciada +como um servidor, e a string ``´znprimroot(10007)'`` é enviada, +calculada pelo GP, e o resultado é armazenado em uma variável no GP +(que ocupa espaço na memória dos processos do GP que não serão +liberados). Então o valor dessa variável é exibido. No segundo caso, +nenhum programa separado é iniciado, e a string +``´znprimroot(10007)'`` é calculada por uma certa função da biblioteca +C do PARI. O resultado é armazenado na memória em uso pelo Python, que +é liberada quando a variável não for mais referenciada. Os objetos +possuem tipos diferentes: + +:: + + sage: type(gp('znprimroot(10007)')) + + sage: type(pari('znprimroot(10007)')) + + +Então qual eu devo usar? Depende do que você está fazendo. A interface +GP pode fazer absolutamente tudo o que você poderia fazer na linha de +comando do GP/PARI, pois está simplesmente executando esse programa. +Em particular, você pode carregar programas complicados em PARI e +executá-los. Por outro lado, a interface do PARI (via a biblioteca C) +é muito mais restritiva. Primeiro, nem todas as funções foram +implementadas. Segundo, bastante código, por exemplo, envolvendo +integração numérica, não irá funcionar através da interface PARI. +Todavia, a interface PARI pode ser significamente mais rápida e mais +robusta do que a interface GP. + +(Se a interface GP ficar sem memória para calcular algum comando, ela +irá silenciosamente e automaticamente duplicar a memória alocada e +repetir o comando solicitado. Então os seus cálculos não irão ser +interrompidos se você não antecipou corretamente a quantidade de +memória que seria necessária. Esse é um truque útil que a interface +usual do GP não parece fornecer. Com respeito à interface da +biblioteca C do PARI, ela imediatamente copia cada objeto criado para +fora da pilha de memória, logo essa pilha nunca irá crescer. Contudo, +cada objeto não deve exceder 100MB de tamanho, ou a pilha irá estourar +quando o objeto for criado. Essa procedimento de cópia impõe uma leve +pena sobre a performace.) + +Em resumo, o Sage usa a biblioteca C do pari para fornecer +funcionalidade similar à fornecida pelo interpretador GP/PARI, exceto +que com um gerenciamento sofisticado de memória e a linguagem de +programação Python. + +Primeiro criamos uma lista do PARI a partir de uma lista do Python. + +:: + + sage: v = pari([1,2,3,4,5]) + sage: v + [1, 2, 3, 4, 5] + sage: type(v) + + +Cada objeto do PARI é do tipo ``py_pari_gem``. O tipo PARI do objeto +subjacente pode ser obtido usando a função ``type``. + +:: + + sage: v.type() + 't_VEC' + +Em PARI, para criar uma curva elíptica digitamos +``ellinit([1,2,3,4,5])``. Em Sage é similar, exceto que ``ellnint`` é +um método que pode ser chamado em qualquer objeto do PARI, por +exemplo, ``t\_VEC v``. + +:: + + sage: e = v.ellinit() + sage: e.type() + 't_VEC' + sage: pari(e)[:13] + [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351] + +Agora que temos um objeto de curva elíptica, podemos calcular algumas +coisas a respeito dele. + +:: + + sage: e.elltors() + [1, [], []] + sage: e.ellglobalred() + [10351, [1, -1, 0, -1], 1] + sage: f = e.ellchangecurve([1,-1,0,-1]) + sage: f[:5] + [1, -1, 0, 4, 3] + +.. index: GAP + +.. _section-gap: + +GAP +=== + +O Sage vem com o GAP 4.4.10 para matemática discreta computacional, +especialmente teoria de grupos. + +Aqui está um exemplo com a função ``IdGroup`` do GAP, a qual usa a +base de dados opcional sobre grupos que precisa ser instalada +separadamente, como explicado abaixo. + +:: + + sage: G = gap('Group((1,2,3)(4,5), (3,4))') + sage: G + Group( [ (1,2,3)(4,5), (3,4) ] ) + sage: G.Center() + Group( () ) + sage: G.IdGroup() # requires optional database_gap package + [ 120, 34 ] + sage: G.Order() + 120 + +Podemos realizar os mesmos cálculos no Sage sem explicitamente evocar +a interface do GAP da seguinte forma: + +:: + + sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) + sage: G.center() + Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()] + sage: G.group_id() # requires optional database_gap package + [120, 34] + sage: n = G.order(); n + 120 + +(Para alguns recursos adicionais do GAP, você deve instalar dois +pacotes opcionais. Digite ``sage -optional`` para uma lista e escolha +o pacote da forma ``gap\_packages-x.y.z``, então digite ``sage -i +gap\_packages-x.y.z``. Faça o mesmo para ``database\_gap-x.y.z``. +Alguns pacotes do GAP sem licensa GPL podem ser obtidos no site do GAP +[GAPkg]_, e copiados em ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg``.) + +Singular +======== + +O Singular fornece uma biblioteca massiva e madura para bases de +Gröbner, máximo divisor comum para poliômios em várias variaveis, +bases de espaços de Riemann-Roch de uma curva plana, e fatorização, +entre outras coisas. Vamos ilustrar a fatorização de polinômios em +várias variáveis usando a interface do Sage para o Singular (não +digite ``...``): + +:: + + sage: R1 = singular.ring(0, '(x,y)', 'dp') + sage: R1 + // characteristic : 0 + // number of vars : 2 + // block 1 : ordering dp + // : names x y + // block 2 : ordering C + sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \ + ... 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 - \ + ... 9*x^12*y^3 - 18*x^13*y^2 + 9*x^16') + +Agora que definimos :math:`f`, vamos imprimi-lo e fatorá-lo. + +:: + + sage: f + 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 + sage: f.parent() + Singular + sage: F = f.factorize(); F + [1]: + _[1]=9 + _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4 + _[3]=-x^5+y^2 + [2]: + 1,1,2 + sage: F[1][2] + x^6-2*x^3*y^2-x^2*y^3+y^4 + +Como com o exemplo para o GAP em :ref:`section-gap`, podemos calcular +a fatorização acima sem explicitamente usar a inteface do Singular +(todavia, implicitamente o Sage usa a interface do Singular para os +cálculos). Não digite ``...``: + +:: + + sage: x, y = QQ['x, y'].gens() + 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\ + ... + 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\ + ... - 18*x^13*y^2 + 9*x^16 + sage: factor(f) + (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4) + +.. _section-maxima: + +Maxima +====== + +O Maxima está incluido no Sage, assim como uma implementação do Lisp. +O pacote gnuplot (que o Maxima usa para criar gráficos) é distribuído +como um pacote adicional do Sage. Entre outras coisas, o Maxima +executa manipulações simbólicas. Ele pode integrar e diferenciar +funções simbolicamente, resolver EDOs de primeira ordem, grande parte +das EDOs lineares de segunda ordem, e tem implementado o método da +transformada de Laplace para EDOs lineares de qualquer ordem. O Maxima +também suporta uma série de funções especiais, é capaz de criar +gráficos via gnuplot, e possui métodos para resolver equações +polinômiais e manipular matrizes (por exemplo, escalonar e calcular +autovalores e autovetores). + +Nós ilustramos a interface Sage/Maxima construíndo uma matriz cuja +entrada :math:`i,j` é :math:`i/j`, para :math:`i,j=1,\ldots,4`. + +:: + + sage: f = maxima.eval('ij_entry[i,j] := i/j') + sage: A = maxima('genmatrix(ij_entry,4,4)'); A + 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]) + sage: A.determinant() + 0 + sage: A.echelon() + matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0]) + sage: A.eigenvalues() + [[0,4],[3,1]] + sage: A.eigenvectors() + [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]] + +Aqui vai outro exemplo: + +:: + + sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])") + sage: eigA = A.eigenvectors() + sage: V = VectorSpace(QQ,3) + sage: eigA + [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]] + sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0] + sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1] + sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2] + + sage: M = MatrixSpace(QQ,3,3) + sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]]) + sage: b1 = v1.base_ring() + sage: AA*v1 == b1(lambda1)*v1 + True + sage: b2 = v2.base_ring() + sage: AA*v2 == b2(lambda2)*v2 + True + sage: b3 = v3.base_ring() + sage: AA*v3 == b3(lambda3)*v3 + True + +Por fim, apresentamos um exemplo de como usar o Sage para criar +gráficos usando ``openmath``. Alguns desses exemplos são modificações +de exemplos do manual de referência do Maxima. + +Um gráfico em duas dimensões de diversas funções (não digite ``...``): + +:: + + sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]',\ + ... '[plot_format,openmath]') # not tested + +Um gráfico em 3D que você pode mover com o seu mouse: + +:: + + sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]",\ + ... '[plot_format, openmath]') # not tested + sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]",\ + ... "[grid, 50, 50]",'[plot_format, openmath]') # not tested + +O próximo gráfico é a famosa faixa de Möbious: + +:: + + sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)),\ + ... y*sin(x/2)]", "[x, -4, 4]", "[y, -4, 4]",\ + ... '[plot_format, openmath]') # not tested + +E agora a famosa garrafa de Klein: + +:: + + sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\ + ... - 10.0") + 5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0 + sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)") + -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0) + sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))") + 5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y)) + sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]",\ + ... "[y, -%pi, %pi]", "['grid, 40, 40]",\ + ... '[plot_format, openmath]') # not tested diff --git a/doc/pt/tutorial/introduction.rst b/doc/pt/tutorial/introduction.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/introduction.rst @@ -0,0 +1,165 @@ +********** +Introdução +********** + +Este tutorial leva no máximo de 3 a 4 horas para ser percorrido. Você +pode lê-lo em versão HTML ou PDF, ou a partir do Notebook Sage (clique +em ``Help``, então clique em ``Tutorial`` para percorrer o tutorial de +forma interativa). + +Embora grande parte do Sage seja implementado em Python, nenhum +conhecimento de Python é necessário para a leitura deste tutorial. +Você vai querer aprender Python (uma linguagem muito divertida!) em +algum momento, e existem diversas opções gratuitas disponíveis para +isso, entre elas [PyT]_ e [Dive]_ (em inglês). Se você quiser +experimentar o Sage rapidamente, este tutorial é o lugar certo para +começar. Por exemplo: + +:: + + sage: 2 + 2 + 4 + sage: factor(-2007) + -1 * 3^2 * 223 + + sage: A = matrix(4,4, range(16)); A + [ 0 1 2 3] + [ 4 5 6 7] + [ 8 9 10 11] + [12 13 14 15] + + sage: factor(A.charpoly()) + x^2 * (x^2 - 30*x - 80) + + sage: m = matrix(ZZ,2, range(4)) + sage: m[0,0] = m[0,0] - 3 + sage: m + [-3 1] + [ 2 3] + + sage: E = EllipticCurve([1,2,3,4,5]); + sage: E + Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 + over Rational Field + sage: E.anlist(10) + [0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3] + sage: E.rank() + 1 + + sage: k = 1/(sqrt(3)*I + 3/4 + sqrt(73)*5/9); k + 1/(I*sqrt(3) + 5/9*sqrt(73) + 3/4) + sage: N(k) + 0.165495678130644 - 0.0521492082074256*I + sage: N(k,30) # 30 "bits" + 0.16549568 - 0.052149208*I + sage: latex(k) + \frac{1}{i \, \sqrt{3} + \frac{5}{9} \, \sqrt{73} + \frac{3}{4}} + +.. _installation: + +Instalação +========== + +Se você não tem o Sage instalado em um computador e quer apenas +experimentar alguns comandos, use o Sage através do site +http://www.sagenb.org. + +Veja o guia de instalação do Sage na seção de documentação na página +principal do Sage [SA]_ para instruções de como instalar o Sage no seu +computador. Aqui faremos apenas alguns comentários. + +#. O arquivo para download do Sage vem com "baterias incluídas". Em + outras palavras, embora o Sage use o Python, IPython, PARI, GAP, + Singular, Maxima, NTL, GMP, e uma série de outros programas, você + não precisa instalá-los separadamente pois eles estão incluídos no + Sage. Todavia, para usar alguns recursos, por exemplo, o Macaulay + ou o KASH, você precisa instalar pacotes de software adicionais ou + ter os programas necessários já instalados no seu computador. O + Macaulay e o KASH estão disponíveis como pacotes adicionais do Sage + (para uma lista de pacotes adicionais, digite ``sage -optional``, + ou visite a seção "Download" na página do Sage na internet). + +#. A versão pré-compilada do Sage (disponível na página do Sage na + internet) pode ser mais fácil e rápida para instalar do que a + versão obtida compilando o código fonte. + +#. Se você quiser usar o pacote SageTeX (que permite inserir + cálculos do Sage em um arquivo LaTeX), você deve tornar + o SageTex disponível para a sua distribuição TeX. Para fazer isso, + consulte a seção "Make SageTex known to TeX" no `Sage installation + guide `_. O procedimento é bem + simples; você precisa apenas definir algumas variáveis no seu + sistema ou copiar um arquivo para um diretório onde o TeX poderá + encontrá-lo. + + A documentação para usar o SageTex está disponível em + ``$SAGE_ROOT/local/share/texmf/tex/generic/sagetex/``, onde + ``$SAGE_ROOT`` refere-se ao diretório onde você instalou o Sage + -- por exemplo, ``/opt/sage-4.2.1``. + +Formas de usar o Sage +===================== + +Você pode usar o Sage de diversas formas. + + +- **Interface gráfica Notebook:** veja a seção sobre o Notebook em + :ref:`section-notebook`, + +- **Linha de comando interativa:** veja + :ref:`chapter-interactive_shell`, + +- **Programas:** escrevendo programas interpretados e compilados em + Sage (veja :ref:`section-loadattach` e :ref:`section-compile`), e + +- **Scripts:** escrevendo scripts em Python que usam a biblioteca do + Sage (veja :ref:`section-standalone`). + + +Objetivos do Sage a longo prazo +=============================== + +- **Útil**: O público alvo do Sage são estudantes de matemática + (desde o ensino médio até a pós-graduação), professores, e + pesquisadores em matemática. O objetivo é fornecer um software que + possa ser usado para explorar e experimentar construções matemáticas + em álgebra, geometria, teoria de números, cálculo, computação + numérica, etc. O Sage torna mais fácil a experimentação com objetos + matemáticos de forma interativa. + +- **Eficiente:** Ser rápido. O Sage usa software bastante otimizado + como o GMP, PARI, GAP, e NTL, e portanto é muito rápido em certas + operações. + +- **Gratuito e de código aberto:** O código fonte deve ser amplamente + disponível e legível, de modo que os usuários possam entender o que + o software realmente faz e possam facilmente estendê-lo. Da mesma + forma que matemáticos ganham entendimento sobre um teorema lendo + cuidadosamente a sua demonstração, as pessoas que fazem cálculos + deveriam poder entender como os cálculos são feitos lendo o código + fonte e seus comentários. Se você usar o Sage para fazer cálculos em + um artigo que seja publicado, você pode ter certeza que os leitores + sempre terão livre acesso ao Sage e seu código fonte, e você tem até + mesmo permissão para arquivar e redistribuir a versão do Sage que + você utilizou. + +- **Fácil de compilar:** O Sage deve ser fácil de compilar a partir + do código fonte para usuários de Linux, OS X e Windows. Isso + fornece mais flexibilidade para os usuários modificarem o sistema. + +- **Cooperação:** Fornecer uma interface robusta para outros sistemas + computacionais, incluindo PARI, GAP, Singular, Maxima, KASH, Magma, + Maple e Mathematica. O Sage foi concebido para unificar e estender + outros softwares de matemática existentes. + +- **Bem documentado:** Tutorial, guia de programação, manual de + referência, e how-to, com inúmeros exemplos e discussão sobre + conceitos matemáticos relacionados. + +- **Estensível:** Ser capaz de definir novos tipos de dados ou + derivá-los a partir dos tipos de dados existentes, e usar programas + escritos em diversas outras linguagens. + +- **Fácil de usar:** Deve ser fácil entender quais recursos estão + disponíveis para um determinado objeto e consultar a documentação e + o código fonte. diff --git a/doc/pt/tutorial/latex.rst b/doc/pt/tutorial/latex.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/latex.rst @@ -0,0 +1,515 @@ +********************************* +Sage, LaTeX e Companheiros +********************************* + +AUTOR: Rob Beezer (2010-05-23) + +O Sage e o dialeto LaTeX do TeX tem um relacionamento sinergético +intenso. Esta seção tem como objetivo introduzir as diversas formas de +interação entre eles, começado pelas mais básicas e indo até as menos +usuais. (Logo você pode não querer ler esta seção inteira na sua +primeira passagem por este tutorial.) + +Panorama Geral +============== + +Pode ser mais fácil entender os vários usos do LaTeX com um panorama +geral sobre os três principais métodos usados pelo Sage. + +#. Todo objeto no Sage possui uma representação em LaTeX. Você + pode acessar essa representação executando, no Notebook ou na + linha de comando do Sage, ``latex(foo)`` where ``foo`` é algum + objeto no Sage. O resultado é uma string que deve fornecer uma + representação razoável de ``foo`` no modo matemático em LaTeX + (por exemplo, quando cercado por um par de símbolos $). Alguns + exemplos disso seguem abaixo. + + Dessa forma, o Sage pode ser usado efetivamente para construir + partes de um documento LaTeX: crie ou calcule um objeto no + Sage, imprima ``latex()`` do objeto e copie-e-cole o resultado + no seu documento. + +#. A interface Notebook é configurada para usar o `jsMath + `_ para representar + fórmulas matemáticas de forma clara em um web browser. O jsMath é + uma coleção de rotinas em JavaScript e fontes associadas. + Tipicamente esses fontes ficam armazenadas em um servidor e são + enviadas para o browser juntamente com a página onde elas estão + sendo usadas. No caso do Sage, o Notebook está sempre conectado a + um servidor usado para executar os comando do Sage, e esse servidor + também fornece as fontes do jsMath necessárias. Logo não é + necessário configurar nada mais para ter formulas matemáticas + representadas no seu browser quando você usa o Notebook do Sage. + + O jsMath é implementado para representar um subconjunto grande, + mas não completo, do TeX. Ele não suporta objetos como, por + exemplo, tabelas complicadas e seções, e é focado para + representar acuradamente pequenas fórmulas em TeX. A + representação automática de fórmulas matemáticas no Notebook é + obtida convertendo a representação ``latex()`` de um objeto + (como descrito acima) em uma forma de HTML mais adequada ao + jsMath. + + Como o jsMath usa as suas próprias fontes de tamanho variável, + ele é superior a outros métodos que convertem equações, ou + outros pequenos trechos de TeX, em imagens estáticas. + + O jsMath muito provavelmente vai ser substituído pelo MathJAX, + uma tecnologia similar do mesmo autor, que possui suporte + extenso de editoras técnicas e sociedades profissionais. + +#. Na linha de comando do Sage, ou no Notebook quando o código em + LaTeX é complicado demais para o jsMath processar, uma + instalação local do LaTeX pode ser usada. O Sage inclui quase + tudo que você precisa para compilar e usar o Sage, mas uma + exceção significativa é o TeX. Então nessas situações você + precisa ter o TeX instalado, juntamente com algumas ferramentas + de conversão, para usar os recursos completos. + +Aqui nós demonstramos alguns usos básicos da função ``latex()``. :: + + sage: var('z') + z + sage: latex(z^12) + z^{12} + sage: latex(integrate(z^4, z)) + \frac{1}{5} \, z^{5} + sage: latex('a string') + \verb|a|\phantom{x}\verb|string| + sage: latex(QQ) + \Bold{Q} + sage: latex(matrix(QQ, 2, 3, [[2,4,6],[-1,-1,-1]])) + \left(\begin{array}{rrr} + 2 & 4 & 6 \\ + -1 & -1 & -1 + \end{array}\right) + +A funcionalidade básica do jsMath é em sua maior parte automática no +Notebook, mas nós podemos demonstrar esse suporte parcialmente com a +classe ``jsMath``. A função ``eval`` dessa classe converte um objeto +do Sage em sua representação LaTeX e adiciona HTML que por sua vez +evoca a classe "matemática" do CSS, a qual então emprega o jsMath. :: + + sage: from sage.misc.latex import JSMath + sage: js = JSMath() + sage: var('z') + z + sage: js(z^12) +
\newcommand{\Bold}[1]{\mathbf{#1}}z^{12}
+ sage: js(QQ) +
\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}
+ sage: js(ZZ[x]) +
\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Z}[x]
+ sage: js(integrate(z^4, z)) +
\newcommand{\Bold}[1]{\mathbf{#1}}\frac{1}{5} \, z^{5}
+ +Uso Básico +========== + +Como indicado acima, a forma mais simples de explorar o suporte do +Sage para o LaTeX é usando a função ``latex()`` para criar código +LaTeX para representar objetos matemáticos. Essas strings podem então +ser incorporadas em documentos LaTeX. Isso funciona igualmente no +Notebook ou na linha de comando do Sage. + +No outro extremo está o comando ``view()``. Na linha de comando do +Sage o comando ``view(foo)`` irá criar a representação em LaTeX de +``foo``, incorporar isso em um documento simples em LaTeX, e então +processar o documento usando o LaTeX em seu sistema. Por fim, o +visualizador apropriado será aberto para apresentar o documento +gerado. Qual versão do TeX é usada, e portanto as opções para a saída +e visualizador, podem ser personalizados (veja +:ref:`sec-custom-processing`). + +No Notebook, o comando ``view(foo)`` cria uma combinação apropriada de +HTML e CSS para que o jsMath mostre a representação em LaTeX na folha +de trabalho. Para o usuário, ele simplesmente cria uma versão +cuidadosamente formatada do resultado, distinta da saída padrão em +modo texto do Sage. Nem todo objeto no Sage possui uma representação +em LaTeX adequada às capacidades limitadas do jsMath. Nesses casos, a +interpretação pelo jsMath pode ser deixada de lado, e com isso o LaTeX +do sistema é chamado, e o resultado dessa chamada é convertido em uma +imagem que é inserida na folha de trabalho. Como alterar e controlar +esse processo é discutido abaixo na seção +:ref:`sec-custom-generation`. + +O comando interno ``pretty_print()`` ilustra a conversão de objetos do +Sage para HTML que emprega o jsMath no Notebook. :: + + sage: from sage.misc.latex import pretty_print + sage: pretty_print(x^12) + \newcommand{\Bold}[1]{\mathbf{#1}}x^{12} + sage: pretty_print(integrate(sin(x), x)) + \newcommand{\Bold}[1]{\mathbf{#1}}-\cos\left(x\right) + +O Notebook tem outros dois recursos para empregar o TeX. O primeiro é +o botão "Typeset" bem acima da primeira célula da folha de trabalho, à +direita dos quatro menus de opções. Quando selecionado, o resultado de +qualquer cálculo vai ser interpretado pelo jsMath. Note que esse +efeito não é retroativo -- células calculadas anteriormente precisam +ser recalculadas para ter o resultado representado pelo jsMath. +Essencialmente, selecionar o botão "Typeset" é equivalente a aplicar o +comando ``view()`` ao resultado de cada célula. + +Um segundo recurso disponível no Notebook é possibilidade de inserir +código TeX para fazer anotações na folha de trabalho. Quando o cursos +esta posicionado entre células de modo que uma barra azul fica +visível, então shift-click irá abrir um mini processador de texto, +TinyMCE. Isso permite digitar texto, usando um editor WSISYG para +criar HTML e CSS. Logo é possível inserir texto formatado para +complementar a folha de trabalho. Todavia, texto entre símbolos $, ou +$$, é interpretado pelo jsMath como "inline" ou "display math" +espectivamente. + +.. _sec-custom-generation: + +Personalizando a Criação de Código LaTeX +======================================== + +Exitem várias formas de personalizar o código LaTeX gerado pelo +comando ``latex()``. No Notebook e na linha de comando existe um +objeto pré-definido chamado ``latex`` que possui diversos métodos, os +quais você pode listar digitando ``latex.``, seguido da tecla tab +(note a presença do ponto). + +Um bom exemplo é o método ``latex.matrix_delimiters``. Ele pode ser +usado para alterar a notação de matrizes -- parênteses grandes, +colchetes, barras verticais. Nenhuma noção de estilo é enfatizada, +você pode configurar como desejado. Observe como as barras invertidas +usadas em LaTeX requerem uma barra adicional de modo que elas possam +ser interpretadas (escaped) corretamente em uma string do Python. :: + + sage: A = matrix(ZZ, 2, 2, range(4)) + sage: latex(A) + \left(\begin{array}{rr} + 0 & 1 \\ + 2 & 3 + \end{array}\right) + sage: latex.matrix_delimiters(left='[', right=']') + sage: latex(A) + \left[\begin{array}{rr} + 0 & 1 \\ + 2 & 3 + \end{array}\right] + sage: latex.matrix_delimiters(left='\\{', right='\\}') + sage: latex(A) + \left\{\begin{array}{rr} + 0 & 1 \\ + 2 & 3 + \end{array}\right\} + +O método ``latex.vector_delimiters`` funciona de forma similar. + +A forma como anéis e corpos comuns podem ser representados pode ser +controlada pelo método ``latex.blackboard_bold``. Esses conjuntos são +representados por padrão em negrito, mas podem opcionalmente ser +escritos em letras duplas como é comum em trabalhos escritos. Isso é +obtido redefinindo a macro ``\Bold{}`` que faz parte do Sage. :: + + sage: latex(QQ) + \Bold{Q} + sage: from sage.misc.latex import JSMath + sage: js=JSMath() + sage: js(QQ) +
\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}
+ sage: latex.blackboard_bold(True) + sage: js(QQ) +
\newcommand{\Bold}[1]{\mathbb{#1}}\Bold{Q}
+ sage: latex.blackboard_bold(False) + +É possível aproveitar os recursos do TeX adicionando novas macros e +novos pacotes. Primeiro, macros individuais podem ser adicionadas para +serem usadas quando o jsMath interpreta pequenos trechos de códigos +TeX no Notebook. :: + + sage: latex.extra_macros() + '' + sage: latex.add_macro("\\newcommand{\\foo}{bar}") + sage: latex.extra_macros() + '\\newcommand{\\foo}{bar}' + sage: var('x y') + (x, y) + sage: latex(x+y) + x + y + sage: from sage.misc.latex import JSMath + sage: js=JSMath() + sage: js(x+y) +
\newcommand{\Bold}[1]{\mathbf{#1}}\newcommand{\foo}{bar}x + y
+ +Macros adicionais usadas dessa forma serão também usadas eventualmente +se a versão do TeX no seu sistema for usada para lidar com algo muito +complicado para o jsMath. O comando ``latex_extra_preamble`` é usado +para construir o preambulo de um documento completo em LaTeX. +Ilustramos a seguir como fazer isso. Novamente note a necessidade de +barras invertidas duplas nas strings do Python. :: + + + sage: latex.extra_macros('') + sage: latex.extra_preamble('') + sage: from sage.misc.latex import latex_extra_preamble + sage: print latex_extra_preamble() + \newcommand{\ZZ}{\Bold{Z}} + ... + \newcommand{\Bold}[1]{\mathbf{#1}} + sage: latex.add_macro("\\newcommand{\\foo}{bar}") + sage: print latex_extra_preamble() + \newcommand{\ZZ}{\Bold{Z}} + ... + \newcommand{\Bold}[1]{\mathbf{#1}} + \newcommand{\foo}{bar} + +Novamente, para expressões grandes ou mais complicadas do LaTeX, é +possível adicionar pacotes (ou qualquer outra coisa) ao preambulo do +arquivo LaTeX. Qualquer coisa pode ser incorporada no preambulo com o +comando ``latex.add_to_preamble``, e o comando mais especializado +``latex.add_package_to_preamble_if_available`` irá primeiro verificar +se certo pacote está realmente disponível antes de adicioná-lo ao +preambulo + +Agora adicionamos o pacote geometry ao preambulo e usamos ele para +definir o tamanho da região na página que o TeX vai usar +(efetivamente definido as margens). Novamente, observe a necessidade +de barras duplas nas strings do Python. :: + + + sage: from sage.misc.latex import latex_extra_preamble + sage: latex.extra_macros('') + sage: latex.extra_preamble('') + sage: latex.add_to_preamble('\\usepackage{geometry}') + sage: latex.add_to_preamble('\\geometry{letterpaper,total={8in,10in}}') + sage: latex.extra_preamble() + '\\usepackage{geometry}\\geometry{letterpaper,total={8in,10in}}' + sage: print latex_extra_preamble() + \usepackage{geometry}\geometry{letterpaper,total={8in,10in}} + \newcommand{\ZZ}{\Bold{Z}} + ... + \newcommand{\Bold}[1]{\mathbf{#1}} + +Um pacote pode ser adicionado juntamente com a verificação de sua +existência, da seguinte forma. Como um exemplo, nós ilustramos uma +tentativa de adicionar ao preambulo um pacote que supostamente não +existe. :: + + sage: latex.extra_preamble('') + sage: latex.extra_preamble() + '' + sage: latex.add_to_preamble('\\usepackage{foo-bar-unchecked}') + sage: latex.extra_preamble() + '\\usepackage{foo-bar-unchecked}' + sage: latex.add_package_to_preamble_if_available('foo-bar-checked') + sage: latex.extra_preamble() + '\\usepackage{foo-bar-unchecked}' + +.. _sec-custom-processing: + +Personalizando o Processamento em LaTeX +======================================= + +É também possível controlar qual variação do TeX é usada quando a +versão do sistema for evocada, logo influenciando também o resultado. +De forma similar, é também possível controlar quando o Notebook irá +usar o jsMath (trechos simples em TeX) ou a versão do TeX do sistema +(expressões mais complicadas). + +O comando ``latex.engine()`` pode ser usado para controlar de os +executáveis ``latex``, ``pdflatex`` ou ``xelatex`` do sistema são +usados para processar expressões mais complicadas. Quando ``view()`` é +chamado na linha de comando do Sage e o processador é definido como +``latex``, um arquivo dvi é produzido e o Sage vai usar um +visualizador de dvi (como o xdvi) para apresentar o resultado. Por +outro lado, usando ``view()`` na linha de comando do Sage, quando o +processador é definido como ``pdflatex``, irá produzir um PDF e o Sage vai +executar o programa disponível no seu sistema para visualizar arquivos +PDF (acrobat, okular, evince, etc.). + +No Notebook, é necessário interver na decisão de se o jsMath vai +interpretar trechos em TeX, ou se o LaTeX do sistema deve fazer o +trabalho se o código em LaTeX for complicado demais. O dispositivo é +uma lista de strings, que se forem encontradas em um trecho de código +LaTeX sinalizam para o Notebook usar o LaTeX (ou qualquer executável +que for definido pelo comando ``latex.engine()``). Essa lista é +gerenciada pelos comandos ``latex.add_to_jsmath_avoid_list`` e +``latex.jsmath_avoid_list``. :: + + sage: latex.jsmath_avoid_list([]) + sage: latex.jsmath_avoid_list() + [] + sage: latex.jsmath_avoid_list(['foo', 'bar']) + sage: latex.jsmath_avoid_list() + ['foo', 'bar'] + sage: latex.add_to_jsmath_avoid_list('tikzpicture') + sage: latex.jsmath_avoid_list() + ['foo', 'bar', 'tikzpicture'] + sage: latex.jsmath_avoid_list([]) + sage: latex.jsmath_avoid_list() + [] + +Suponha que uma expressão em LaTeX é produzida no Notebook com o +comando ``view()`` ou enquanto o botão "Typeset" está selecionado, e +então reconhecida, através da "lista de comandos a serem evitados no +jsMath", como necessitando a versão do LaTeX no sistema. Então o +executável selecionado (como especificado por ``latex.engine()``) irá +processar o código em LaTeX. Todavia, em vez de então abrir um +visualizador externo (o que é o comportamento na linha de comando), o +Sage irá tentar converter o resultado em uma imagem, que então é +inserida na folha de trabalho como o resultado da célula. + +Exatamente como essa conversão é feita depende de vários fatores -- +qual executável você especificou como processador e quais utilitários +de conversão estão disponíveis no seu sistema. Quatro conversores +usuais que irão cobrir todas as ocorrências são o ``dvips``, +``ps2pdf``, e ``dvipng``, e do pacote ``ImageMagick``, o ``convert``. +O objetivo é produzir um arquivo PNG para ser inserido de volta na +folha de trabalho. Quando uma expressão em LaTeX pode ser convertida +com sucesso em um arquivo dvi pelo processador LaTeX, então o dvipng +deve dar conta da conversão. Se a expressão em LaTeX e o processador +especificado criarem um arquivo dvi com conteúdo especial que o dvipng +não pode converter, então o dvips vai criar um arquivo PostScript. +Esse arquivo PostScript, ou um PDF criado por pelo processador +``pdflatex``, é então convertido em um arquivo dvi pelo programa +``convert``. A presença de dois desses conversores pode ser testado +com as rotinas ``have_dvipng()`` e ``have_convert()``. + +Essas conversões são feitas automaticamente se você tiver os +conversores necessários instalados; se não, então uma mensagem de erro +é impressa dizendo o que está faltando e onde obter. + +Para um exemplo concreto de como expressões complicadas em LaTeX podem +ser processadas, veja o exemplo na próxima seção +(:ref:`sec-tkz-graph`) para usar o pacote ``tkz-graph`` para produzir +ilustrações de grafos combinatoriais de alta qualidade. Para outros +exemplos, existem alguns casos teste incluídos no Sage. Para usá-los, +é necessário importar o objeto ``sage.misc.latex.latex_examples``, que +é uma instância da classe ``sage.misc.latex.LatexExamples``, como +mostrado abaixo. Essa classe possui exemplos de diagramas comutativos, +grafos combinatoriais, teoria de nós e pstricks, os quais +respectivamente testam os seguintes pacotes: xy, tkz-graph, xypic, +pstricks. Após importar o objeto, use completamento tab em +``latex_examples`` para ver os exemplos disponíveis. Ao carregar um +exemplo você irá obter explicações sobre o que é necessário para fazer +o conteúdo do exemplo ser exibido corretamente. Para de fato ver os +exemplos, é necessário usar ``view()`` (uma vez que o preambulo, +processador, etc. estão configurados corretamente). + +:: + + sage: from sage.misc.latex import latex_examples + sage: latex_examples.diagram() + LaTeX example for testing display of a commutative diagram produced + by xypic. + + To use, try to view this object -- it won't work. Now try + 'latex.add_to_preamble("\\usepackage[matrix,arrow,curve,cmtip]{xy}")', + and try viewing again -- it should work in the command line but not + from the notebook. In the notebook, run + 'latex.add_to_jsmath_avoid_list("xymatrix")' and try again -- you + should get a picture (a part of the diagram arising from a filtered + chain complex). + +.. _sec-tkz-graph: + +Exemplo: Grafos Combinatoriais com tkz-graph +============================================ + +Ilustrações de alta qualidade de grafos combinatoriais (daqui por +diante, simplesmente grafos) são possíveis com o pacote ``tkz-graph``. +Esse pacote baseia-se no ``tikz`` front-end da biblioteca ``pgf``. +Logo todos esses componentes precisam ser parte de uma instalação +completa do LaTeX em seu sistema, e pode acontecer que alguns desses +componentes não estejam em sua versão mais recente em algumas +distribuições do TeX. Logo, para melhores resultados, seria necessário +ou recomendável instalar esses pacotes como parte do seu diretório +texmf pessoal. Criar, manter e personalizar uma instalação do TeX no +sistema ou em um diretório pessoal vai além do escopo deste documento, +mas deve ser fácil encontrar instruções para isso. Os arquivos +necessários estão listados em :ref:`sec-system-wide-tex`. + +Portanto, para começar precisamos nos certificar que os pacotes +relevantes estão incluídos adicionando-os ao preambulo do eventual +documento LaTeX. As imagens dos grafos não são formadas corretamente +quando um arquivo dvi é usando como formato intermediário, logo é +melhor definir o processador do LaTeX como ``pdflatex``. A esta altura +um comando como ``view(graphs.CompleteGraph(4))`` deve funcionar na +linha de comando do Sage e produzir um PDF com a imagem completa do +grafo `K_4`. + +Para uma experiência semelhante no Notebook, é necessário desabilitar +o processador jsMath para o código LaTeX do grafo usando a "lista de +comandos a serem evitados pelo jsMath". Grafos são criados usando o +environment ``tikzpicture``, logo essa uma boa escolha para uma string +a ser incluída na lista que acabamos de mencionar. Agora, +``view(graphs.CompleteGraph(4))`` em uma folha de trabalho deve +executar o pdflatex para criar um PDF e então o programa ``convert`` +para obter um gráfico PNG que vai ser inserido na folha de trabalho. +Os seguintes comandos ilustram os passos para obter grafos processados +pelo LaTeX no Notebook. :: + + sage: from sage.graphs.graph_latex import setup_latex_preamble + sage: setup_latex_preamble() + sage: latex.extra_preamble() # random - depends on system's TeX installation + '\\usepackage{tikz}\n\\usepackage{tkz-graph}\n\\usepackage{tkz-berge}\n' + sage: latex.engine('pdflatex') + sage: latex.add_to_jsmath_avoid_list('tikzpicture') + sage: latex.jsmath_avoid_list() + ['tikzpicture'] + +Agora, um comando como ``view(graphs.CompleteGraph(4))`` deve produzir +um gráfico do grafo no Notebook, tendo usado ``pdflatex`` para +processar os comandos do ``tkz-graph`` para construir o grafo. Note +que há diversas opções que afetam o resultado do gráfico obtido usando +o LaTeX via ``tkz-graph``, o que mais uma vez está além do escopo +desta seção (veja a seção do Manual de Referência com título "Opções +do LaTeX para Grafos" para instruções e detalhes). + +.. _sec-system-wide-tex: + +Uma Instalação Completa do TeX +============================== +Vários dos recursos avançados de integração do TeX com o Sage requerem +uma instalação do TeX em seu sistema. Várias versões do Linux possuem +pacotes do TeX baseados no TeX-live, para o OSX existe o TeXshop e +para o windows existe o MikTex. O utilitário ``convert`` é parte do +`ImageMagick `_ (que deve ser um pacote +na sua versão do Linux ou ser fácil de instalar), e os três programas +``dvipng``, ``ps2pdf``, e ``dvips`` podem estar incluídos na sua +distribuição do TeX. Os dois primeiros podem também ser obtidos em, +respectivamente, http://sourceforge.net/projects/dvipng/ e como parte +do `Ghostscript `_. + +A criação de grafos combinatoriais requer uma versão recente da +biblioteca PGF, e os arquivos ``tkz-graph.sty``, ``tkz-arith.sty`` e +talvez ``tkz-berge.sty``, que estão disponíveis em `Altermundus site +`_. + +Programas Externos +================== + +Existem três programas disponíveis para integrar ainda mais o TeX e o +Sage. O primeiro é o sagetex. Uma descrição concisa do sagetex é que +ele é uma coleção de macros do TeX que permitem incluir em um +documento LaTeX instruções para usar o Sage para calcular vários +objetos, e/ou formatar objetos usando o comando ``latex()`` existente +no Sage. Logo, como um passo intermediário para compilar um documento +LaTeX, todos os recursos computacionais e de formatação do Sage podem +ser executados automaticamente. Como um exemplo, um exame matemático +pode manter uma correspondência entre questões e respostas usando o +sagetex para fazer cálculos com o Sage. Veja :ref:`sec-sagetex` para +mais informações. + +O tex2sws começa com um documento LaTeX, mas define environments +adicionais para inserir código em Sage. Quando processado com as +ferramentas adequadas, o resultado é uma folha de trabalho do Sage, +com conteúdo apropriadamente formatado para o jsMath e com código em +Sage incorporado como células de entrada. Então um livro texto ou +artigo pode ser criado em LaTeX, ter blocos de código em Sage +incluídos, e o documento todo pode ser transformado em uma folha de +trabalho do Sage onde o texto matemático é bem formatado e os blocos +de código em Sage podem ser facilmente executados. Atualmente em +desenvolvimento, veja `tex2sws @ BitBucket +`_ para mais informações. + +O sws2tex reverte o processo partindo de uma folha de trabalho do Sage +e convertendo o conteúdo para LaTeX para ser posteriormente processado +com as ferramentas disponíveis para documentos em LaTeX. Atualmente em +desenvolvimento, veja `sws2tex @ BitBucket +`_ para mais informações. diff --git a/doc/pt/tutorial/programming.rst b/doc/pt/tutorial/programming.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/programming.rst @@ -0,0 +1,850 @@ +*********** +Programação +*********** + +.. _section-loadattach: + +Carregando e Anexando Arquivos do Sage +====================================== + +A seguir ilustramos como carregar no Sage programas escritos em um +arquivo separado. Crie um arquivo chamado ``example.sage`` com o +seguinte conteúdo: + +.. skip + +:: + + print "Hello World" + print 2^3 + +Você pode ler e executar o arquivo ``example.sage`` usando o comando +``load``. + +.. skip + +:: + + sage: load "example.sage" + Hello World + 8 + +Você também pode anexar um arquivo em Sage à sessão em execução usando +o comando ``attach``. + +.. skip + +:: + + sage: attach "example.sage" + Hello World + 8 + +Agora se você alterar ``example.sage`` e adicionar uma linha em branco +(por exemplo), então o conteúdo de ``example.sage`` será +automaticamente recarregado no Sage. + +Em particular, ``attach`` automaticamente recarrega um arquivo toda +vez que ele for modificado, o que é útil para desenvolver e testar um +programa, enquanto ``load`` carrega o arquivo apenas uma vez. + +Quando o Sage carrega ``example.sage`` ele converte esse arquivo para +o Python, o qual é então executado pelo interpretador do Python. Essa +conversão é mínima; ela essencialmente consiste em encapsular inteiros +em ``Integer()``, números float em ``RealNumber()``, substituir ``^`` +por ``**``, e substituir, por exemplo, ``R.2`` por ``R.gen(2)``. A +versão convertida de ``example.sage`` é armazenada no mesmo diretório +de ``example.sage`` e é chamada ``example.sage.py``. Esse arquivo +contém o seguinte código: + +:: + + print "Hello World" + print Integer(2)**Integer(3) + +Inteiros literais são encapsulados e ``^`` é substituído por ``**``. +(Em Python, ``^`` significa "ou exclusivo" e ``**`` significa +"exponenciação".) + +Esse "preparsing" está implementado em ``sage/misc/interpreter.py``.) + +Você pode colar código tabulado com muitas linhas no Sage desde que +existam linhas em branco separando blocos de código (isso não é +necessário em arquivos). Todavia, a melhor forma de adicionar tal +código a uma sessão do Sage é salvá-lo em um arquivo e usar +``attach``, como descrito anteriormente. + + +.. _section-compile: + +Criando Código Compilado +======================== + +Velocidade é crucial em cálculos matemáticos. Embora o Python seja uma +linguagem conveniente de alto nível, certos cálculos podem ser várias +vezes mais rápidos do que em Python se eles forem implementados usando +tipos estáticos em uma linguagem compilada. Alguns aspectos do Sage +seriam muito lentos se eles fossem escritos inteiramente em Python. +Para lidar com isso, o Sage suporta uma "versão" compilada do Python +chamada Cython ([Cyt]_ and [Pyr]_). O Cython é simultaneamente similar +ao Python e ao C. A maior parte das construções em Python, incluindo +"list comprehensions", expressões condicionais, código como ``+=`` são +permitidos; você também pode importar código que você escreveu em +outros módulos em Python. Além disso, você pode declarar variáveis em +C arbitrárias, e qualquer chamada de bibliotecas em C pode ser feita +diretamente. O código resultante é convertido para C e compilado +usando um compilador para C. + +Para criar o seu próprio código compilado em Sage, nomeie o arquivo +com uma extensão ``.spyx`` (em vez de ``.sage``). Se você está +trabalhando na linha de comando, você pode anexar e carregar código +compilado exatamente como se faz com código interpretado (no momento, +anexar e carregar código em Cython não é suportado no Notebook). A +compilação é realizada implicitamente sem que você tenha que fazer +qualquer coisa explicitamente. Veja +``$SAGE_ROOT/examples/programming/sagex/factorial.spyx`` para um +exemplo de uma implementação compilada para a função fatorial que usa +diretamente a biblioteca GMP em C. Experimente o seguinte, usando cd, +vá para o diretório ``$SAGE_ROOT/examples/programming/sagex/``, e +então faça o seguinte: + +.. skip + +:: + + sage: load "factorial.spyx" + *************************************************** + Recompiling factorial.spyx + *************************************************** + sage: factorial(50) + 30414093201713378043612608166064768844377641568960512000000000000L + sage: time n = factorial(10000) + CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s + Wall time: 0.03 + +Aqui o sufixo L indica um "long integer" do Python (veja +:ref:`section-mathannoy`). + +Note que o Sage vai recompilar ``factorial.spyx`` se você encerrar e +reiniciar o Sage. A biblioteca compilada e compartilhada é armazenada +em ``$HOME/.sage/temp/hostname/pid/spyx``. Esses arquivos são +excluídos quando você encerra o Sage. + +Nenhum pré-processador (preparsing) é aplicado em arquivos spyx, por +exemplo, ``1/3`` vai resultar em 0 em um arquivo spyx em vez do número +racional :math:`1/3`. Se ``foo`` é uma função da biblioteca Sage, para +usá-la em um arquivo spyx importe ``sage.all`` e use ``sage.all.foo``. + +:: + + import sage.all + def foo(n): + return sage.all.factorial(n) + +Acessando Funções em C em Arquivos Separados +-------------------------------------------- + +É fácil também acessar funções em C definidas em arquivos \*.c +separados. Aqui vai um exemplo. Crie os arquivos ``test.c`` e +``test.spyx`` no mesmo diretório contendo: + +Código C puro: ``test.c`` + +:: + + int add_one(int n) { + return n + 1; + } + +Código Cython: ``test.spyx``: + +:: + + cdef extern from "test.c": + int add_one(int n) + + def test(n): + return add_one(n) + +Então o seguinte funciona: + +.. skip + +:: + + sage: attach "test.spyx" + Compiling (...)/test.spyx... + sage: test(10) + 11 + +Se uma biblioteca ``foo`` adicional é necessária para compilar código +em C gerado a partir de um arquivo em Cython, adicione a linha ``clib +foo`` no arquivo fonte em Cython. De forma similar, um arquivo em C +adicional ``bar`` pode ser incluído na compilação declarando ``cfile +bar``. + +.. _section-standalone: + +Scripts Independentes em Python/Sage +==================================== + +O seguinte script em Sage fatora inteiros, polinômios, etc: + +:: + + #!/usr/bin/env sage -python + + import sys + from sage.all import * + + if len(sys.argv) != 2: + print "Usage: %s "%sys.argv[0] + print "Outputs the prime factorization of n." + sys.exit(1) + + print factor(sage_eval(sys.argv[1])) + +Para usar esse script, sua ``SAGE_ROOT`` precisa estar na sua variável +PATH. Se o script acima for chamado ``factor``, aqui está um exemplo +de como usá-lo: + +:: + + bash $ ./factor 2006 + 2 * 17 * 59 + bash $ ./factor "32*x^5-1" + (2*x - 1) * (16*x^4 + 8*x^3 + 4*x^2 + 2*x + 1) + +Tipo de Dados +============= + +Cada objeto em Sage possui um tipo bem definido. O Python possui +diversos tipos de dados, e a biblioteca do Sage adiciona ainda mais. +Os tipos de dados de Python incluem strings, listas, tuplas, inteiros +e floats, como ilustrado: + +:: + + sage: s = "sage"; type(s) + + sage: s = 'sage'; type(s) # you can use either single or double quotes + + sage: s = [1,2,3,4]; type(s) + + sage: s = (1,2,3,4); type(s) + + sage: s = int(2006); type(s) + + sage: s = float(2006); type(s) + + +Além disso, o Sage acrescenta vários outros tipos. Por exemplo, +espaços vetoriais: + +:: + + sage: V = VectorSpace(QQ, 1000000); V + Vector space of dimension 1000000 over Rational Field + sage: type(V) + + +Apenas certas funções podem ser aplicadas sobre ``V``. Em outros +softwares de matemática, essas seriam chamadas usando a notação +"funcional" ``foo(V,...)``. Em Sage, algumas funções estão anexadas ao +tipo (ou classe) de ``V``, e são chamadas usando uma sintaxe orientada +a objetos como em Java ou C++, por exemplo, ``V.foo()``. Isso ajuda a +manter o espaço de variáveis global sem milhares de funções, e permite +que várias funções diferentes com comportamento diferente possam ser +chamadas foo, sem a necessidade de usar um mecanismo de identificação +de tipos (ou casos) para decidir qual chamar. Além disso, se você +reutilizar o nome de uma função, essa função continua ainda disponível +(por exemplo, se você chamar algo ``zeta``, e então quiser calcular o +valor da função zeta de Riemann em 0.5, você continua podendo digitar +``s=.5; s.zeta()``). + +:: + + sage: zeta = -1 + sage: s=.5; s.zeta() + -1.46035450880959 + +Em alguns casos muito comuns, a notação funcional usual é também +suportada por conveniência e porque expressões matemáticas podem +parecer confusas usando a notação orientada a objetos. Aqui vão alguns +exemplos. + +:: + + sage: n = 2; n.sqrt() + sqrt(2) + sage: sqrt(2) + sqrt(2) + sage: V = VectorSpace(QQ,2) + sage: V.basis() + [ + (1, 0), + (0, 1) + ] + sage: basis(V) + [ + (1, 0), + (0, 1) + ] + sage: M = MatrixSpace(GF(7), 2); M + Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7 + sage: A = M([1,2,3,4]); A + [1 2] + [3 4] + sage: A.charpoly('x') + x^2 + 2*x + 5 + sage: charpoly(A, 'x') + x^2 + 2*x + 5 + +Para listar todas as funções para :math:`A`, use completamento tab. +Simplesmente digite ``A.``, então tecle ``[tab]`` no seu teclado, como +descrito em :ref:`section-tabcompletion`. + +Listas, Tuplas e Sequências +=========================== + +O tipo de dados lista armazena elementos de um tipo arbitrário. Como +em C, C++, etc. (mas diferentemente da maioria dos sistemas de álgebra +computacional), os elementos da lista são indexados a partir do +:math:`0`: + +:: + + sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v + [2, 3, 5, 'x', Symmetric group of order 3! as a permutation group] + sage: type(v) + + sage: v[0] + 2 + sage: v[2] + 5 + +(Quando se indexa uma lista, é permitido que o índice não seja um int +do Python!) Um Inteiro do Sage (ou Racional, ou qualquer objeto que +possua um método ``__index__``) também ira funcionar. + +:: + + sage: v = [1,2,3] + sage: v[2] + 3 + sage: n = 2 # SAGE Integer + sage: v[n] # Perfectly OK! + 3 + sage: v[int(n)] # Also OK. + 3 + +A função ``range`` cria uma lista de int's do Python (não Inteiros do +Sage): + +:: + + sage: range(1, 15) + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] + +Isso é útil quando se usa "list comprehensions" para construir listas: + +:: + + sage: L = [factor(n) for n in range(1, 15)] + sage: print L + [1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7] + sage: L[12] + 13 + sage: type(L[12]) + + sage: [factor(n) for n in range(1, 15) if is_odd(n)] + [1, 3, 5, 7, 3^2, 11, 13] + +Para mais sobre como criar listas usando "list comprehensions", veja +[PyT]_. + +Fatiamento de lista (list slicing) é um recurso fantástico. Se ``L`` é +uma lista, então ``L[m:n]`` retorna uma sub-lista de ``L`` obtida +começando do :math:`m`-ésimo elemento e terminando no +:math:`(n-1)`-ésimo elemento, como ilustrado abaixo. + +:: + + sage: L = [factor(n) for n in range(1, 20)] + sage: L[4:9] + [5, 2 * 3, 7, 2^3, 3^2] + sage: print L[:4] + [1, 2, 3, 2^2] + sage: L[14:4] + [] + sage: L[14:] + [3 * 5, 2^4, 17, 2 * 3^2, 19] + +Tuplas são semelhantes à listas, exceto que elas são imutáveis: uma +vez criadas elas não podem ser alteradas. + +:: + + sage: v = (1,2,3,4); v + (1, 2, 3, 4) + sage: type(v) + + sage: v[1] = 5 + Traceback (most recent call last): + ... + TypeError: 'tuple' object does not support item assignment + +Sequências são um terceiro tipo de dados do Sage semelhante a listas. +Diferentemente de listas e tuplas, Sequence não é um tipo de dados +nativo do Python. Por definição, uma sequência é mutável, mas usando o +método ``set_immutable`` da classe ``Sequence`` elas podem ser feitas +imutáveis, como mostra o exemplo a seguir. Todos os elementos da +sequência possuem um parente comum, chamado o universo da sequência. + +:: + + sage: v = Sequence([1,2,3,4/5]) + sage: v + [1, 2, 3, 4/5] + sage: type(v) + + sage: type(v[1]) + + sage: v.universe() + Rational Field + sage: v.is_immutable() + False + sage: v.set_immutable() + sage: v[0] = 3 + Traceback (most recent call last): + ... + ValueError: object is immutable; please change a copy instead. + +Sequências são derivadas de listas e podem ser usadas em qualquer +lugar que listas são usadas. + +:: + + sage: v = Sequence([1,2,3,4/5]) + sage: isinstance(v, list) + True + sage: list(v) + [1, 2, 3, 4/5] + sage: type(list(v)) + + +Como um outro exemplo, bases para espaços vetoriais são sequências +imutáveis, pois é importante que elas não sejam modificadas. + +:: + + sage: V = QQ^3; B = V.basis(); B + [ + (1, 0, 0), + (0, 1, 0), + (0, 0, 1) + ] + sage: type(B) + + sage: B[0] = B[1] + Traceback (most recent call last): + ... + ValueError: object is immutable; please change a copy instead. + sage: B.universe() + Vector space of dimension 3 over Rational Field + +Dicionários +=========== + +Um dicionário (também chamado as vezes de lista associativa) é um +mapeamento de objetos "hashable" em objetos arbitrários. (Exemplos de +objetos "hashable" são strings e números; veja a documentação Python +em http://docs.python.org/tut/node7.html e +http://docs.python.org/lib/typesmapping.html para detalhes). + +:: + + sage: d = {1:5, 'sage':17, ZZ:GF(7)} + sage: type(d) + + sage: d.keys() + [1, 'sage', Integer Ring] + sage: d['sage'] + 17 + sage: d[ZZ] + Finite Field of size 7 + sage: d[1] + 5 + +A terceira chave (key) ilustra como os índices de um dicionário podem +ser complicados, por exemplo, um anel de inteiros. + +Você pode transformar o dicionário acima em uma lista com os mesmos +dados: + +.. link + +:: + + sage: d.items() + [(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)] + +É comum iterar sobre os pares em um dicionário: + +:: + + sage: d = {2:4, 3:9, 4:16} + sage: [a*b for a, b in d.iteritems()] + [8, 27, 64] + +Um dicionário não possui ordem, como o exemplo acima mostra. + +Conjuntos +========= + +O Python possui um tipo set (conjuntos) nativo. O principal recurso +que ele oferece é a rápida verificação se um objeto está ou não em um +conjunto, juntamente com as operações comuns em conjuntos. + +:: + + sage: X = set([1,19,'a']); Y = set([1,1,1, 2/3]) + sage: X + set(['a', 1, 19]) + sage: Y + set([1, 2/3]) + sage: 'a' in X + True + sage: 'a' in Y + False + sage: X.intersection(Y) + set([1]) + +O Sage também possui o seu próprio tipo de dados para conjuntos que é +(em alguns casos) implementado usando o tipo nativo do Python, mas +possuir algumas funcionalidades adicionais. Crie um conjunto em Sage +usando ``Set(...)``. Por exemplo, + +:: + + sage: X = Set([1,19,'a']); Y = Set([1,1,1, 2/3]) + sage: X + {'a', 1, 19} + sage: Y + {1, 2/3} + sage: X.intersection(Y) + {1} + sage: print latex(Y) + \left\{1, \frac{2}{3}\right\} + sage: Set(ZZ) + Set of elements of Integer Ring + +Iteradores +========== + +Iteradores foram adicionados recentemente ao Python e são +particularmente úteis em aplicações matemáticas. Aqui estão vários +exemplos; veja [PyT]_ para mais detalhes. Vamos criar um iterador +sobre o quadrados dos números inteiros até :math:`10000000`. + +:: + + sage: v = (n^2 for n in xrange(10000000)) + sage: v.next() + 0 + sage: v.next() + 1 + sage: v.next() + 4 + +Criamos agora um iterador sobre os primos da forma :math:`4p+1` com +:math:`p` também primo, e observamos os primeiros valores. + +:: + + sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1)) + sage: w # in the next line, 0xb0853d6c is a random 0x number + + sage: w.next() + 13 + sage: w.next() + 29 + sage: w.next() + 53 + +Certos anéis, por exemplo, corpos finitos e os inteiros possuem +iteradores associados a eles: + +:: + + sage: [x for x in GF(7)] + [0, 1, 2, 3, 4, 5, 6] + sage: W = ((x,y) for x in ZZ for y in ZZ) + sage: W.next() + (0, 0) + sage: W.next() + (0, 1) + sage: W.next() + (0, -1) + +Laços, Funções, Enunciados de Controle e Comparações +==================================================== + +Nós já vimos alguns exemplos de alguns usos comuns de laços (loops) +``for``. Em Python, um laço ``for`` possui uma estrutura tabulada, tal +como + +:: + + >>> for i in range(5): + print(i) + + 0 + 1 + 2 + 3 + 4 + +Note que os dois pontos no final do enunciado (não existe "do" ou "od" +como no GAP ou Maple), e a identação antes dos comandos dentro do +laço, isto é, ``print(i)``. A tabulação é importante. No Sage, a +tabulação é automaticamente adicionada quando você digita ``enter`` +após ":", como ilustrado abaixo. + +:: + + sage: for i in range(5): + ... print(i) # now hit enter twice + 0 + 1 + 2 + 3 + 4 + +O símbolo ``=`` é usado para atribuição. +O símbolo ``==`` é usado para verificar igualdade: + +:: + + sage: for i in range(15): + ... if gcd(i,15) == 1: + ... print(i) + 1 + 2 + 4 + 7 + 8 + 11 + 13 + 14 + +Tenha em mente como a tabulação determina a estrutura de blocos para +enunciados ``if``, ``for``, e ``while``: + +:: + + sage: def legendre(a,p): + ... is_sqr_modp=-1 + ... for i in range(p): + ... if a % p == i^2 % p: + ... is_sqr_modp=1 + ... return is_sqr_modp + + sage: legendre(2,7) + 1 + sage: legendre(3,7) + -1 + +Obviamente essa não é uma implementação eficiente do símbolo de +Legendre! O objetivo é ilustrar vários aspectos da programação em +Python/Sage. A função {kronecker}, que já vem com o Sage, calcula o +símbolo de Legendre eficientemente usando uma biblioteca em C do PARI. + +Finalmente, observamos que comparações, tais como ``==``, ``!=``, +``<=``, ``>=``, ``>``, ``<``, entre números irão automaticamente +converter ambos os números para o mesmo tipo, se possível: + +:: + + sage: 2 < 3.1; 3.1 <= 1 + True + False + sage: 2/3 < 3/2; 3/2 < 3/1 + True + True + +Quase todos pares de objetos podem ser comparados; não se supõe que os +objetos estejam equipados com uma ordem total. + +:: + + sage: 2 < CC(3.1,1) + True + sage: 5 < VectorSpace(QQ,3) # output can be somewhat random + True + +Use bool para desigualdades simbólicas: + +:: + + sage: x < x + 1 + x < x + 1 + sage: bool(x < x + 1) + True + +Quando se compara objetos de tipos diferentes no Sage, na maior parte +dos casos o Sage tenta encontrar uma coação canônica para ambos os +objetos em um parente comum (veja :ref:`section-coercion` para mais +detalhes). Se isso for bem sucedido, a comparação é realizada entre os +objetos que foram coagidos; se não for bem sucedido, os objetos são +considerados diferentes. Para testar se duas variáveis fazem +referência ao mesmo objeto use ``is``. Como se vê no próximo exemplo, +o int ``1`` do Python é único, mas o Inteiro ``1`` do Sage não é. + +:: + + sage: 1 is 2/2 + False + sage: int(1) is int(2)/int(2) + True + sage: 1 is 1 + False + sage: 1 == 2/2 + True + +Nas duas linhas seguintes, a primeira igualdade é falsa (``False``) +porque não existe um morfismo canônico :math:`QQ\to \GF{5}`, logo +não há uma forma de comparar o :math:`1` em :math:`\GF{5}` com o +:math:`1 \in \QQ`. Em contraste, existe um mapa canônico entre +:math:`\ZZ \to \GF{5}`, logo a segunda comparação é verdadeira +(``True``) + +:: + + sage: GF(5)(1) == QQ(1); QQ(1) == GF(5)(1) + False + False + sage: GF(5)(1) == ZZ(1); ZZ(1) == GF(5)(1) + True + True + sage: ZZ(1) == QQ(1) + True + +ATENÇÃO: Comparação no Sage é mais restritiva do que no Magma, o qual +declara :math:`1 \in \GF{5}` igual a :math:`1 \in \QQ`. + +:: + + sage: magma('GF(5)!1 eq Rationals()!1') # optional magma required + true + +Otimização (Profiling) +====================== + +Autor desta seção: Martin Albrecht (malb@informatik.uni-bremen.de) + + "Premature optimization is the root of all evil." - Donald Knuth + +As vezes é útil procurar por gargalos em programas para entender quais +partes gastam maior tempo computacional; isso pode dar uma boa ideia +sobre quais partes otimizar. Python e portanto Sage fornecem várias +opções de "profiling" (esse é o nome que se dá ao processo de +otimização). + +O mais simples de usar é o comando ``prun`` na linha de comando +interativa. Ele retorna um sumário sobre o tempo computacional +utilizado por cada função. Para analisar (a atualmente lenta! -- na +versão 1.0) multiplicação de matrizes sobre corpos finitos, por +exemplo, faça o seguinte: + +:: + + sage: k,a = GF(2**8, 'a').objgen() + sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)]) + +.. skip + +:: + + sage: %prun B = A*A + 32893 function calls in 1.100 CPU seconds + + Ordered by: internal time + + ncalls tottime percall cumtime percall filename:lineno(function) + 12127 0.160 0.000 0.160 0.000 :0(isinstance) + 2000 0.150 0.000 0.280 0.000 matrix.py:2235(__getitem__) + 1000 0.120 0.000 0.370 0.000 finite_field_element.py:392(__mul__) + 1903 0.120 0.000 0.200 0.000 finite_field_element.py:47(__init__) + 1900 0.090 0.000 0.220 0.000 finite_field_element.py:376(__compat) + 900 0.080 0.000 0.260 0.000 finite_field_element.py:380(__add__) + 1 0.070 0.070 1.100 1.100 matrix.py:864(__mul__) + 2105 0.070 0.000 0.070 0.000 matrix.py:282(ncols) + ... + +Aqui ``ncalls`` é o números de chamadas, ``tottime`` é o tempo total +gasto por uma determinada função (excluíndo o tempo gasto em chamadas +de subfunções), ``percall`` é o quociente de ``tottime`` dividido por +``ncalls``. ``cumtime`` é o tempo total gasto nessa e em todas as +subfunções (isto é, desde o início até o término da execução da +função), ``percall`` é o quociente de ``cumtime`` dividido pelas +chamadas primitivas, e ``filename:lineno(function)`` fornece os dados +respectivos para cada função. A regra prática aqui é: Quanto mais no +topo uma função aparece nessa lista, mais custo computacional ela +acarreta. Logo é mais interessante para ser optimizada. + +Como usual, ``prun?`` fornece detalhes sobre como usar o "profiler" e +como entender a saída de dados. + +A saída de dados pode ser escrita em um objeto para permitir uma +análise mais detalhada: + +.. skip + +:: + + sage: %prun -r A*A + sage: stats = _ + sage: stats? + +Note: digitando ``stats = prun -r A\*A`` obtém-se um erro de sintaxe +porque prun é um comando do IPython, não uma função comum. + +Para uma representação gráfica dos dados do "profiling", você pode +usar o "hotspot profiler", um pequeno script chamado +``hotshot2cachetree`` e o programa ``kcachegrind`` (apenas no Unix). O +mesmo exemplo agora com o "hotspot profiler": + +.. skip + +:: + + sage: k,a = GF(2**8, 'a').objgen() + sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)]) + sage: import hotshot + sage: filename = "pythongrind.prof" + sage: prof = hotshot.Profile(filename, lineevents=1) + +.. skip + +:: + + sage: prof.run("A*A") + + sage: prof.close() + +Isso resulta em um arquivo ``pythongrind.prof`` no diretório de +trabalho atual. Ele pode ser convertido para o formato cachegrind para +visualização. + +Em uma linha de comando do sistema, digite + +.. skip + +:: + + hotshot2calltree -o cachegrind.out.42 pythongrind.prof + +O arquivo de saída ``cachegrind.out.42`` pode ser examinado com +``kcachegrind``. Note que a convenção de nomes ``cachegrind.out.XX`` +precisa ser obedecida. diff --git a/doc/pt/tutorial/sagetex.rst b/doc/pt/tutorial/sagetex.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/sagetex.rst @@ -0,0 +1,112 @@ +.. _sec-sagetex: + +**************** +Usando o SageTeX +**************** + +O pacote SageTeX permite que você insira resultados de cálculos feitos +com o Sage em um documento LaTeX. Esse pacote já vem com o Sage. Para +usá-lo, você precisa "instalá-lo" em seu sistema LaTeX local; aqui +instalar significa copiar um simples arquivo. Veja :ref:`installation` +neste tutorial e a seção "Make SageTeX known to TeX" do `Guia de +instalação do Sage `_ +(em inglês) (`este link <../installation/index.html>`_ deve levá-lo a +uma cópia local do guia de instalação para mais informações de como +proceder. + +Aqui vai um breve exemplo de como usar o SageTeX. A documentação +completa pode ser encontrada em +``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``, onde +``SAGE_ROOT`` é o diretório onde se encontra a sua instalação. Esse +diretório contém a documentação, um arquivo de exemplo, e alguns +scripts em Python possivelmente úteis. + +Para ver como o SageTeX funciona, siga as instruções para instalar o +SageTeX (em :ref:`installation`) e copie o seguinte texto em um +arquivo chamado ``st_example.tex``, por exemplo. + +.. warning:: + + O texto abaixo vai apresentar diversos erros sobre "unknown control + sequences" se você está visualizando isto na ajuda "live". Use a + versão estática para ver o texto corretamente. + +.. code-block:: latex + + \documentclass{article} + \usepackage{sagetex} + + \begin{document} + + Using Sage\TeX, one can use Sage to compute things and put them into + your \LaTeX{} document. For example, there are + $\sage{number_of_partitions(1269)}$ integer partitions of $1269$. + You don't need to compute the number yourself, or even cut and paste + it from somewhere. + + Here's some Sage code: + + \begin{sageblock} + f(x) = exp(x) * sin(2*x) + \end{sageblock} + + The second derivative of $f$ is + + \[ + \frac{\mathrm{d}^{2}}{\mathrm{d}x^{2}} \sage{f(x)} = + \sage{diff(f, x, 2)(x)}. + \] + + Here's a plot of $f$ from $-1$ to $1$: + + \sageplot{plot(f, -1, 1)} + + \end{document} + +Execute o LaTeX em ``st_example.tex`` da forma usual. Note que o LaTeX +vai reclamar sobre algumas coisas, entre elas:: + + Package sagetex Warning: Graphics file + sage-plots-for-st_example.tex/plot-0.eps on page 1 does not exist. Plot + command is on input line 25. + + Package sagetex Warning: There were undefined Sage formulas and/or + plots. Run Sage on st_example.sage, and then run LaTeX on + st_example.tex again. + +Observe que, além dos arquivos usuais produzidos pelo LaTeX, existe um +arquivo chamado ``st_example.sage``. Esse é um script em Sage +produzido quando você executa o LaTeX em ``st_example.tex``. A +mensagem de alerta pede para você executar o LaTeX em +``st_example.sage``, então siga essa sugestão e faça isso. Você vai +receber uma mensagem para executar o LaTeX em ``st_example.tex`` +novamente, mas antes que você faça isso, observe que um novo arquivo +foi criado: ``st_example.sout``. Esse arquivo contém os resultados dos +cálculos feitos pelo Sage, em um formato que o LaTeX pode usar para +inserir em seu texto. Um novo diretório contendo um arquivo EPS do seu +gráfico também foi criado. Execute o LaTeX novamente e você vai ver +que tudo que foi calculado, incluindo os gráficos, foi incluído em seu +documento. + +As macros utilizadas acima devem ser fáceis de entender. Um +environment ``sageblock`` insere código "verbatim" (exatamente como é +digitado) e também executa o código quando você executa o Sage. Quando +você insere ``\sage{foo}``, é incluído em seu documento o resultado +que você obteria executando ``latex(foo)`` no Sage. Comandos para +fazer gráficos são um pouco mais complicados, mas em sua forma mais +simples, ``\sageplot{foo}`` insere a imagem que você obtêm usando +``foo.save('filename.eps')``. + +Em geral, a rotina é a seguinte: + + - execute o LaTeX no seu arquivo .tex; + - execute o Sage no arquivo .sage que foi gerado; + - execute o LaTeX novamente. + +Você pode omitir a execução do Sage desde que você não tenha alterado +os comandos em Sage em seu documento. + +Há muito mais sobre o SageTeX, e como tanto o Sage como o LaTeX são +ferramentas complexas e poderosas, é uma boa idéia ler a documentação +para o SageTeX que se encontra em +``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``. diff --git a/doc/pt/tutorial/tour.rst b/doc/pt/tutorial/tour.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour.rst @@ -0,0 +1,31 @@ +***************** +Um passeio guiado +***************** + +Esta seção é um passeio guiado pelo que está disponível no Sage. Para +diversos outros exemplos, veja "Construções em Sage", que tem como +objetivo responder à questão geral "Como eu construo ...?". Veja +também o "Sage Reference Manual", que possui centenas de outros +exemplos. Note que é também possível percorrer este tutorial no Sage +Notebook clicando no link ``Help``. + +(Se você está acessando este tutorial no Sage Notebook, pressione +``shift-enter`` para processar qualquer célula de entrada. Você pode +até editar a célula antes de pressionar ``shift-enter``. Em alguns +Macs pode ser necessário pressionar ``shift-return`` em vez de +``shift-enter``.) + +.. toctree:: + + tour_assignment + tour_help + tour_algebra + tour_plotting + tour_functions + tour_rings + tour_linalg + tour_polynomial + tour_coercion + tour_groups + tour_numtheory + tour_advanced diff --git a/doc/pt/tutorial/tour_advanced.rst b/doc/pt/tutorial/tour_advanced.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_advanced.rst @@ -0,0 +1,548 @@ +Um Pouco Mais de Matemática Avançada +==================================== + +Geometria Algébrica +------------------- + +Você pode definir variedades algébricas arbitrárias no Sage, mas as +vezes alguma funcionalidade não-trivial é limitada a anéis sobre +:math:`\QQ` ou corpos finitos. Por exemplo, vamos calcular a união de +duas curvas planas afim, e então recuperar as curvas como as +componentes irredutíveis da união. + +:: + + sage: x, y = AffineSpace(2, QQ, 'xy').gens() + sage: C2 = Curve(x^2 + y^2 - 1) + sage: C3 = Curve(x^3 + y^3 - 1) + sage: D = C2 + C3 + sage: D + Affine Curve over Rational Field defined by + x^5 + x^3*y^2 + x^2*y^3 + y^5 - x^3 - y^3 - x^2 - y^2 + 1 + sage: D.irreducible_components() + [ + Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: + x^2 + y^2 - 1, + Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: + x^3 + y^3 - 1 + ] + +Você também pode encontrar todos os pontos de interseção das duas +curvas, intersectando-as, e então calculando as componentes +irredutíveis. + +.. link + +:: + + sage: V = C2.intersection(C3) + sage: V.irreducible_components() + [ + Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: + y - 1, + x, + Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: + y, + x - 1, + Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: + x + y + 2, + 2*y^2 + 4*y + 3 + ] + +Portanto, por exemplo, :math:`(1,0)` e :math:`(0,1)` estão em ambas as +curvas (o que é claramente visível), como também estão certos pontos +(quadráticos) cuja coordenada :math:`y` satisfaz :math:`2y^2 + 4y + +3=0`. + +O Sage pode calcular o ideal toroidal da cúbica torcida no espaço-3 +projetivo: + +:: + + sage: R. = PolynomialRing(QQ, 4) + sage: I = ideal(b^2-a*c, c^2-b*d, a*d-b*c) + sage: F = I.groebner_fan(); F + Groebner fan of the ideal: + Ideal (b^2 - a*c, c^2 - b*d, -b*c + a*d) of Multivariate Polynomial Ring + in a, b, c, d over Rational Field + sage: F.reduced_groebner_bases () + [[-c^2 + b*d, -b*c + a*d, -b^2 + a*c], + [c^2 - b*d, -b*c + a*d, -b^2 + a*c], + [c^2 - b*d, b*c - a*d, -b^2 + a*c, -b^3 + a^2*d], + [c^2 - b*d, b*c - a*d, b^3 - a^2*d, -b^2 + a*c], + [c^2 - b*d, b*c - a*d, b^2 - a*c], + [-c^2 + b*d, b^2 - a*c, -b*c + a*d], + [-c^2 + b*d, b*c - a*d, b^2 - a*c, -c^3 + a*d^2], + [c^3 - a*d^2, -c^2 + b*d, b*c - a*d, b^2 - a*c]] + sage: F.polyhedralfan() + Polyhedral fan in 4 dimensions of dimension 4 + +Curvas Elípticas +---------------- + +A funcionalidade para curvas elípticas inclui a maior parte da +funcionalidade para curvas elípticas do PARI, acesso aos dados da base +de dados Cremona (isso requer um pacote adicional), os recursos do +mwrank, isto é, "2-descends" com cálculos do grupo de Mordell-Weil +completo, o algoritmo SEA (singla em inglês), cálculo de todas as +isogenias, bastante código novo para curvas sobre :math:`\QQ`, e parte +do software "algebraic descent" de Denis Simons. + +O comando ``EllipticCurve`` para criar curvas elípticas possui várias +formas: + + +- EllipticCurve([:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]): + Fornece a curva elíptica + + .. math:: y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6, + + + onde os :math:`a_i`'s são coagidos para os parentes de :math:`a_1`. + Se todos os :math:`a_i` possuem parente :math:`\ZZ`, então eles são + coagidos para :math:`\QQ`. + +- EllipticCurve([:math:`a_4`, :math:`a_6`]): Conforme acima, mas + :math:`a_1=a_2=a_3=0`. + +- EllipticCurve(label): Fornece a curva elíptica da base de dados + Cremona com o "label" (novo) dado. O label é uma string, tal como + ``"11a"`` ou ``"37b2"``. As letras devem ser minúsculas (para + distinguir dos labels antigos). + +- EllipticCurve(j): Fornece uma curva elíptica com invariante + :math:`j`. + +- EllipticCurve(R, + [:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]): + Cria uma curva elíptica sobre um anel :math:`R` com os + :math:`a_i`'s. + + +Agora ilustramos cada uma dessas construções: + +:: + + sage: EllipticCurve([0,0,1,-1,0]) + Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field + + sage: EllipticCurve([GF(5)(0),0,1,-1,0]) + Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5 + + sage: EllipticCurve([1,2]) + Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field + + sage: EllipticCurve('37a') + Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field + + sage: EllipticCurve_from_j(1) + Elliptic Curve defined by y^2 + x*y = x^3 + 36*x + 3455 over Rational Field + + sage: EllipticCurve(GF(5), [0,0,1,-1,0]) + Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5 + +O par :math:`(0,0)` é um ponto na curva elíptica :math:`E` definida +por :math:`y^2 + y = x^3 - x`. Para criar esse ponto digite +``E([0,0])``. O Sage pode somar pontos em uma curva elíptica +(lembre-se que é possível definir uma estrutura de grupo aditivo em +curvas elípticas onde o ponto no infinito é o elemento nulo, e a some +de três pontos colineares sobre a curva é zero): + +:: + + sage: E = EllipticCurve([0,0,1,-1,0]) + sage: E + Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field + sage: P = E([0,0]) + sage: P + P + (1 : 0 : 1) + sage: 10*P + (161/16 : -2065/64 : 1) + sage: 20*P + (683916417/264517696 : -18784454671297/4302115807744 : 1) + sage: E.conductor() + 37 + +As curvas elípticas sobre os números complexos são parametrizadas +pelo invariante :math:`j`. O Sage calcula o invariante :math:`j` da +seguinte forma: + +:: + + sage: E = EllipticCurve([0,0,0,-4,2]); E + Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field + sage: E.conductor() + 2368 + sage: E.j_invariant() + 110592/37 + +Se criarmos uma curva com o mesmo invariante :math:`j` que a curva +:math:`E`, ela não precisa ser isomórfica a :math:`E`. No seguinte +exemplo, as curvas não são isomórficas porque os seus condutores são +diferentes. + +:: + + sage: F = EllipticCurve_from_j(110592/37) + sage: F.conductor() + 37 + +Todavia, uma torção de :math:`F` por um fator 2 resulta em uma curva +isomórfica. + +.. link + +:: + + sage: G = F.quadratic_twist(2); G + Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field + sage: G.conductor() + 2368 + sage: G.j_invariant() + 110592/37 + +Nós podemos calcular os coeficientes :math:`a_n` de uma +série-:math:`L` ou forma modular :math:`\sum_{n=0}^\infty +a_nq^n` associada à curva elíptica. Esse cálculo usa a biblioteca C do +PARI. + +:: + + sage: E = EllipticCurve([0,0,1,-1,0]) + sage: print E.anlist(30) + [0, 1, -2, -3, 2, -2, 6, -1, 0, 6, 4, -5, -6, -2, 2, 6, -4, 0, -12, 0, -4, + 3, 10, 2, 0, -1, 4, -9, -2, 6, -12] + sage: v = E.anlist(10000) + +Leva apenas um segundo para calcular todos os :math:`a_n` para +:math:`n\leq 10^5`: + +.. skip + +:: + + sage: %time v = E.anlist(100000) + CPU times: user 0.98 s, sys: 0.06 s, total: 1.04 s + Wall time: 1.06 + +Curvas elípticas podem ser construídas usando o "label" da base de +dados Cremona. Isso importa a curva elíptica com informações prévias +sobre o seu posto, números de Tomagawa, regulador, etc. + +:: + + sage: E = EllipticCurve("37b2") + sage: E + Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational + Field + sage: E = EllipticCurve("389a") + sage: E + Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2*x over Rational Field + sage: E.rank() + 2 + sage: E = EllipticCurve("5077a") + sage: E.rank() + 3 + +Nós também podemos acessar a base de dados Cremona diretamente. + +:: + + sage: db = sage.databases.cremona.CremonaDatabase() + sage: db.curves(37) + {'a1': [[0, 0, 1, -1, 0], 1, 1], 'b1': [[0, 1, 1, -23, -50], 0, 3]} + sage: db.allcurves(37) + {'a1': [[0, 0, 1, -1, 0], 1, 1], + 'b1': [[0, 1, 1, -23, -50], 0, 3], + 'b2': [[0, 1, 1, -1873, -31833], 0, 1], + 'b3': [[0, 1, 1, -3, 1], 0, 3]} + +Os objetos obtidos pela base de dados não são do tipo +``EllipticCurve``. Eles são elementos de uma base de dados e possuem +alguns campos, e apenas isso. Existe uma versão básica da base de +dados Cremona, que já é distribuída na versão padrão do Sage, e contém +informações limitadas sobre curvas elípticas de condutor :math:`\leq +10000`. Existe também uma versão estendida opcional, que contém +informações extensas sobre curvas elípticas de condutor :math:`\leq +120000` (em outubro de 2005). Por fim, existe ainda uma versão (2GB) +opcional de uma base de dados para o Sage que contém centenas de +milhares de curvas elípticas na base de dados Stein-Watkins. + +Caracteres de Dirichlet +----------------------- + +Um *caractere de Dirichlet* é a extensão de um homomorfismo +:math:`(\ZZ/N\ZZ)* \to R^*`, para algum anel :math:`R`, para o mapa +:math:`\ZZ \to R` obtido mapeando os inteiros :math:`x` tais que +:math:`\gcd(N,x)>1` em 0. + +:: + + sage: G = DirichletGroup(12) + sage: G.list() + [Dirichlet character modulo 12 of conductor 1 mapping 7 |--> 1, 5 |--> 1, + Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1, + Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1, + Dirichlet character modulo 12 of conductor 12 mapping 7 |--> -1, 5 |--> -1] + sage: G.gens() + (Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1, + Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1) + sage: len(G) + 4 + +Tendo criado o grupo, a seguir calculamos um elemento e fazemos +cálculos com ele. + +.. link + +:: + + sage: G = DirichletGroup(21) + sage: chi = G.1; chi + Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6 + sage: chi.values() + [0, 1, zeta6 - 1, 0, -zeta6, -zeta6 + 1, 0, 0, 1, 0, zeta6, -zeta6, 0, -1, + 0, 0, zeta6 - 1, zeta6, 0, -zeta6 + 1, -1] + sage: chi.conductor() + 7 + sage: chi.modulus() + 21 + sage: chi.order() + 6 + sage: chi(19) + -zeta6 + 1 + sage: chi(40) + -zeta6 + 1 + +É também possível calcular a ação do grupo de Galois +:math:`\text{Gal}(\QQ(\zeta_N)/\QQ)` sobre esses caracteres, bem como +a decomposição em produto direto correspondente à fatorização do +módulo. + +.. link + +:: + + sage: chi.galois_orbit() + [Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6, + Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> -zeta6 + 1] + + sage: go = G.galois_orbits() + sage: [len(orbit) for orbit in go] + [1, 2, 2, 1, 1, 2, 2, 1] + + sage: G.decomposition() + [ + Group of Dirichlet characters of modulus 3 over Cyclotomic Field of order + 6 and degree 2, + Group of Dirichlet characters of modulus 7 over Cyclotomic Field of order + 6 and degree 2 + ] + +A seguir, construímos o grupo de caracteres de Dirichlet mod 20, mas +com valores em :math:`\QQ(i)`: + +:: + + sage: K. = NumberField(x^2+1) + sage: G = DirichletGroup(20,K) + sage: G + Group of Dirichlet characters of modulus 20 over Number Field in i with defining polynomial x^2 + 1 + +Agora calculamos diversos invariantes de ``G``: + +.. link + +:: + + sage: G.gens() + (Dirichlet character modulo 20 of conductor 4 mapping 11 |--> -1, 17 |--> 1, + Dirichlet character modulo 20 of conductor 5 mapping 11 |--> 1, 17 |--> i) + + sage: G.unit_gens() + [11, 17] + sage: G.zeta() + i + sage: G.zeta_order() + 4 + +No próximo exemplo criamos um caractere de Dirichlet com valores em um +corpo numérico. Nós especificamos explicitamente a escolha da raiz da +unidade no terceiro argumento do comando ``DirichletGroup`` abaixo. + +:: + + sage: x = polygen(QQ, 'x') + sage: K = NumberField(x^4 + 1, 'a'); a = K.0 + sage: b = K.gen(); a == b + True + sage: K + Number Field in a with defining polynomial x^4 + 1 + sage: G = DirichletGroup(5, K, a); G + Group of Dirichlet characters of modulus 5 over Number Field in a with + defining polynomial x^4 + 1 + sage: chi = G.0; chi + Dirichlet character modulo 5 of conductor 5 mapping 2 |--> a^2 + sage: [(chi^i)(2) for i in range(4)] + [1, a^2, -1, -a^2] + +Aqui ``NumberField(x^4 + 1, 'a')`` diz para o Sage usar o símbolo "a" +quando imprimir o que é ``K`` (um corpo numérico definido pelo +polinômio :math:`x^4 + 1`). O nome "a" não está declarado até então. +Uma vez que ``a = K.0`` (ou equivalentemente ``a = K.gen()``) é +calculado, o símbolo "a" representa a raiz do polinômio gerador +:math:`x^4+1`. + +Formas Modulares +---------------- + +O Sage pode fazer alguns cálculos relacionados a formas modulares, +incluindo dimensões, calcular espaços de símbolos modulares, +operadores de Hecke, e decomposições. + +Existem várias funções disponíveis para calcular dimensões de espaços +de formas modulares. Por exemplo, + +:: + + sage: dimension_cusp_forms(Gamma0(11),2) + 1 + sage: dimension_cusp_forms(Gamma0(1),12) + 1 + sage: dimension_cusp_forms(Gamma1(389),2) + 6112 + +A seguir ilustramos o cálculo dos operadores de Hecke em um espaço de +símbolos modulares de nível :math:`1` e peso :math:`12`. + +:: + + sage: M = ModularSymbols(1,12) + sage: M.basis() + ([X^8*Y^2,(0,0)], [X^9*Y,(0,0)], [X^10,(0,0)]) + sage: t2 = M.T(2) + sage: t2 + Hecke operator T_2 on Modular Symbols space of dimension 3 for Gamma_0(1) + of weight 12 with sign 0 over Rational Field + sage: t2.matrix() + [ -24 0 0] + [ 0 -24 0] + [4860 0 2049] + sage: f = t2.charpoly('x'); f + x^3 - 2001*x^2 - 97776*x - 1180224 + sage: factor(f) + (x - 2049) * (x + 24)^2 + sage: M.T(11).charpoly('x').factor() + (x - 285311670612) * (x - 534612)^2 + +Podemos também criar espaços para :math:`\Gamma_0(N)` e +:math:`\Gamma_1(N)`. + + +:: + + sage: ModularSymbols(11,2) + Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign + 0 over Rational Field + sage: ModularSymbols(Gamma1(11),2) + Modular Symbols space of dimension 11 for Gamma_1(11) of weight 2 with + sign 0 and over Rational Field + +Vamos calcular alguns polinômios característicos e expansões +:math:`q`. + +:: + + sage: M = ModularSymbols(Gamma1(11),2) + sage: M.T(2).charpoly('x') + x^11 - 8*x^10 + 20*x^9 + 10*x^8 - 145*x^7 + 229*x^6 + 58*x^5 - 360*x^4 + + 70*x^3 - 515*x^2 + 1804*x - 1452 + sage: M.T(2).charpoly('x').factor() + (x - 3) * (x + 2)^2 * (x^4 - 7*x^3 + 19*x^2 - 23*x + 11) + * (x^4 - 2*x^3 + 4*x^2 + 2*x + 11) + sage: S = M.cuspidal_submodule() + sage: S.T(2).matrix() + [-2 0] + [ 0 -2] + sage: S.q_expansion_basis(10) + [ + q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10) + ] + +Podemos até mesmo calcular espaços de símbolos modulares com carácter. + +:: + + sage: G = DirichletGroup(13) + sage: e = G.0^2 + sage: M = ModularSymbols(e,2); M + Modular Symbols space of dimension 4 and level 13, weight 2, character + [zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2 + sage: M.T(2).charpoly('x').factor() + (x - 2*zeta6 - 1) * (x - zeta6 - 2) * (x + zeta6 + 1)^2 + sage: S = M.cuspidal_submodule(); S + Modular Symbols subspace of dimension 2 of Modular Symbols space of + dimension 4 and level 13, weight 2, character [zeta6], sign 0, over + Cyclotomic Field of order 6 and degree 2 + sage: S.T(2).charpoly('x').factor() + (x + zeta6 + 1)^2 + sage: S.q_expansion_basis(10) + [ + q + (-zeta6 - 1)*q^2 + (2*zeta6 - 2)*q^3 + zeta6*q^4 + (-2*zeta6 + 1)*q^5 + + (-2*zeta6 + 4)*q^6 + (2*zeta6 - 1)*q^8 - zeta6*q^9 + O(q^10) + ] + +Aqui está um outro exemplo de como o Sage pode calcular a ação de +operadores de Hecke em um espaço de formas modulares. + +:: + + sage: T = ModularForms(Gamma0(11),2) + sage: T + Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of + weight 2 over Rational Field + sage: T.degree() + 2 + sage: T.level() + 11 + sage: T.group() + Congruence Subgroup Gamma0(11) + sage: T.dimension() + 2 + sage: T.cuspidal_subspace() + Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for + Congruence Subgroup Gamma0(11) of weight 2 over Rational Field + sage: T.eisenstein_subspace() + Eisenstein subspace of dimension 1 of Modular Forms space of dimension 2 + for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field + sage: M = ModularSymbols(11); M + Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign + 0 over Rational Field + sage: M.weight() + 2 + sage: M.basis() + ((1,0), (1,8), (1,9)) + sage: M.sign() + 0 + +Denote por :math:`T_p` os operadores de Hecke usuais (:math:`p` +primo). Como os operadores de Hecke :math:`T_2`, :math:`T_3`, +e :math:`T_5` agem sobre o espaço de símbolos modulares? + + +.. link + +:: + + sage: M.T(2).matrix() + [ 3 0 -1] + [ 0 -2 0] + [ 0 0 -2] + sage: M.T(3).matrix() + [ 4 0 -1] + [ 0 -1 0] + [ 0 0 -1] + sage: M.T(5).matrix() + [ 6 0 -1] + [ 0 1 0] + [ 0 0 1] diff --git a/doc/pt/tutorial/tour_algebra.rst b/doc/pt/tutorial/tour_algebra.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_algebra.rst @@ -0,0 +1,414 @@ +Álgebra Elementar e Cálculo +=========================== + +O Sage pode realizar diversos cálculos em álgebra elementar e cálculo +diferencial e integral: por exemplo, encontrar soluções de equações, +diferenciar, integrar, e calcular a transformada de Laplace. Veja a +documentação em `Sage Constructions +`_ para mais exemplos. + +Resolvendo equações +------------------- + +Resolvendo equações exatamente +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A função ``solve`` resolve equações. Para usá-la, primeiro especifique +algumas variáveis; então os argumentos de ``solve`` são uma equação +(ou um sistema de equações), juntamente com as variáveis para as +quais resolver: + +:: + + sage: x = var('x') + sage: solve(x^2 + 3*x + 2, x) + [x == -2, x == -1] + +Você pode resolver equações para uma variável em termos das outras: + +:: + + sage: x, b, c = var('x b c') + sage: solve([x^2 + b*x + c == 0],x) + [x == -1/2*b - 1/2*sqrt(b^2 - 4*c), x == -1/2*b + 1/2*sqrt(b^2 - 4*c)] + +Você pode resolver para diversas variáveis: + +:: + + sage: x, y = var('x, y') + sage: solve([x+y==6, x-y==4], x, y) + [[x == 5, y == 1]] + +O seguinte exemplo, que mostra como usar o Sage para resolver um +sistema de equações não-lineares, foi sugerido por Jason Grout: +primeiro, resolvemos o sistemas simbolicamente: + +:: + + sage: var('x y p q') + (x, y, p, q) + sage: eq1 = p+q==9 + sage: eq2 = q*y+p*x==-6 + sage: eq3 = q*y^2+p*x^2==24 + sage: solve([eq1,eq2,eq3,p==1],p,q,x,y) + [[p == 1, q == 8, x == -4/3*sqrt(10) - 2/3, y == 1/6*sqrt(2)*sqrt(5) - 2/3], + [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]] + +Para obter soluções numéricas aproximadas, podemos usar: + +.. link + +:: + + sage: solns = solve([eq1,eq2,eq3,p==1],p,q,x,y, solution_dict=True) + sage: [[s[p].n(30), s[q].n(30), s[x].n(30), s[y].n(30)] for s in solns] + [[1.0000000, 8.0000000, -4.8830369, -0.13962039], + [1.0000000, 8.0000000, 3.5497035, -1.1937129]] + +(A função ``n`` imprime uma aproximação numérica, e o argumento é o +número de bits de precisão.) + +Resolvendo Equações Numericamente +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Frequentemente, ``solve`` não será capaz de encontrar uma solução +exata para uma equação ou sistema de equações. Nesse caso, você pode +usar ``find_root`` para encontrar uma solução numérica. Por exemplo, +``solve`` não encontra uma solução para a equação abaixo:: + + sage: theta = var('theta') + sage: solve(cos(theta)==sin(theta), theta) + [sin(theta) == cos(theta)] + +Por outro lado, podemos usar ``find_root`` para encontrar uma solução +para a equação acima no intervalo :math:`0 < \phi < \pi/2`:: + + sage: phi = var('phi') + sage: find_root(cos(phi)==sin(phi),0,pi/2) + 0.785398163397448... + +Diferenciação, Integração, etc. +------------------------------- + +O Sage é capaz de diferenciar e integrar diversas funções. Por +exemplo, para diferenciar :math:`\sin(u)` com respeito a :math:`u`, +faça o seguinte: + +:: + + sage: u = var('u') + sage: diff(sin(u), u) + cos(u) + +Para calcular a quarta derivada de :math:`\sin(x^2)`: + +:: + + sage: diff(sin(x^2), x, 4) + 16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2) + +Para calcular as derivadas parciais de :math:`x^2+17y^2` com respeito +a *x* e *y*, respectivamente: + +:: + + sage: x, y = var('x,y') + sage: f = x^2 + 17*y^2 + sage: f.diff(x) + 2*x + sage: f.diff(y) + 34*y + +Passamos agora para integrais, tanto indefinidas como definidas. Para +calcular :math:`\int x\sin(x^2)\, dx` e :math:`\int_0^1 +\frac{x}{x^2+1}\, dx`: + +:: + + sage: integral(x*sin(x^2), x) + -1/2*cos(x^2) + sage: integral(x/(x^2+1), x, 0, 1) + 1/2*log(2) + +Para calcular a decomposição em frações parciais de +:math:`\frac{1}{x^2-1}`: + +:: + + sage: f = 1/((1+x)*(x-1)) + sage: f.partial_fraction(x) + 1/2/(x - 1) - 1/2/(x + 1) + +.. _section-systems: + +Resolvendo Equações Diferenciais +-------------------------------- + +Você pode usar o Sage para investigar equações diferenciais +ordinárias. Para resolver a equação :math:`x'+x-1=0`: + +:: + + sage: t = var('t') # define a variable t + sage: x = function('x',t) # define x to be a function of that variable + sage: DE = diff(x, t) + x - 1 + sage: desolve(DE, [x,t]) + (c + e^t)*e^(-t) + +Esse método usa a interface do Sage para o Maxima [Max]_. Logo, o +formato dos resultados é um pouco diferente de outros cálculos +realizados no Sage. Nesse caso, o resultado diz que a solução geral da +equação diferencial é :math:`x(t) = e^{-t}(e^{t}+c)`. + +Você pode calcular a transformada de Laplace também; a transformada de +Laplace de :math:`t^2e^t -\sin(t)` é calculada da seguinte forma: + +:: + + sage: s = var("s") + sage: t = var("t") + sage: f = t^2*exp(t) - sin(t) + sage: f.laplace(t,s) + 2/(s - 1)^3 - 1/(s^2 + 1) + +A seguir, um exemplo mais complicado. O deslocamento, com respeito à +posição de equilíbrio, de duas massas presas a uma parede através de +molas, conforme a figura abaixo, + +:: + + |------\/\/\/\/\---|massa1|----\/\/\/\/\/----|massa2| + mola1 mola2 + +é modelado pelo sistema de equações diferenciais de segunda ordem + +.. math:: + + m_1 x_1'' + (k_1+k_2) x_1 - k_2 x_2 = 0 + + m_2 x_2''+ k_2 (x_2-x_1) = 0, + + + +onde, para :math:`i=1,2`, :math:`m_{i}` é a massa do objeto *i*, +:math:`x_{i}` é o deslocamento com respeito à posição de equilíbrio da +massa *i*, e :math:`k_{i}` é a constante de mola para a mola *i*. + +**Exemplo:** Use o Sage para resolver o problema acima com +:math:`m_{1}=2`, :math:`m_{2}=1`, :math:`k_{1}=4`, +:math:`k_{2}=2`, :math:`x_{1}(0)=3`, :math:`x_{1}'(0)=0`, +:math:`x_{2}(0)=3`, :math:`x_{2}'(0)=0`. + +Solução: Primeiramente, calcule a transformada de Laplace da primeira +equação (usando a notação :math:`x=x_{1}`, :math:`y=x_{2}`): + +:: + + sage: de1 = maxima("2*diff(x(t),t, 2) + 6*x(t) - 2*y(t)") + sage: lde1 = de1.laplace("t","s"); lde1 + 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) + +O resultado é um pouco difícil de ler, mas diz que + +.. math:: -2x'(0) + 2s^2*X(s) - 2sx(0) - 2Y(s) + 6X(s) = 0 + + +(onde a transformada de Laplace de uma função em letra minúscula +:math:`x(t)` é a função em letra maiúscula :math:`X(s)`). Agora, +calcule a transformada de Laplace da segunda equação: + +:: + + sage: de2 = maxima("diff(y(t),t, 2) + 2*y(t) - 2*x(t)") + sage: lde2 = de2.laplace("t","s"); lde2 + -?%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 + +O resultado significa que + +.. math:: -Y'(0) + s^2Y(s) + 2Y(s) - 2X(s) - sy(0) = 0. + + +Em seguida, substitua a condição inicial para :math:`x(0)`, +:math:`x'(0)`, :math:`y(0)`, e :math:`y'(0)`, e resolva as equações +resultantes: + +:: + + sage: var('s X Y') + (s, X, Y) + sage: eqns = [(2*s^2+6)*X-2*Y == 6*s, -2*X +(s^2+2)*Y == 3*s] + sage: solve(eqns, X,Y) + [[X == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4), + Y == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]] + +Agora calcule a transformada de Laplace inversa para obter a resposta: + +:: + + sage: var('s t') + (s, t) + sage: inverse_laplace((3*s^3 + 9*s)/(s^4 + 5*s^2 + 4),s,t) + cos(2*t) + 2*cos(t) + sage: inverse_laplace((3*s^3 + 15*s)/(s^4 + 5*s^2 + 4),s,t) + -cos(2*t) + 4*cos(t) + +Portanto, a solução é + +.. math:: x_1(t) = \cos(2t) + 2\cos(t), \quad x_2(t) = 4\cos(t) - \cos(2t). + + +Ela pode ser representada em um gráfico parametricamente usando os +comandos + +:: + + sage: t = var('t') + sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\ + ... (t, 0, 2*pi), rgbcolor=hue(0.9)) + sage: show(P) + +As componentes individuais podem ser representadas em gráfico usando + +:: + + sage: t = var('t') + sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3)) + sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6)) + sage: show(p1 + p2) + +Leia mais sobre gráficos em :ref:`section-plot`. Veja a seção 5.5 de +[NagleEtAl2004]_ (em inglês) para mais informações sobre equações +diferenciais. + + +Método de Euler para Sistemas de Equações Diferenciais +------------------------------------------------------ + +No próximo exemplo, vamos ilustrar o método de Euler para EDOs de +primeira e segunda ordem. Primeiro, relembramos a ideia básica para +equações de primeira ordem. Dado um problema de valor inicial da forma + +.. math:: + + y'=f(x,y), \quad y(a)=c, + +queremos encontrar o valor aproximado da solução em :math:`x=b` com +:math:`b>a`. + +Da definição de derivada segue que + +.. math:: y'(x) \approx \frac{y(x+h)-y(x)}{h}, + + +onde :math:`h>0` é um número pequeno. Isso, juntamente com a equação +diferencial, implica que :math:`f(x,y(x))\approx +\frac{y(x+h)-y(x)}{h}`. Agora resolvemos para :math:`y(x+h)`: + +.. math:: y(x+h) \approx y(x) + h*f(x,y(x)). + + +Se chamarmos :math:`h f(x,y(x))` de "termo de correção", :math:`y(x)` +de "valor antigo de *y*", e :math:`y(x+h)` de "novo valor de *y*", +então essa aproximação pode ser reescrita como + +.. math:: y_{novo} \approx y_{antigo} + h*f(x,y_{antigo}). + + +Se dividirmos o intervalo de *a* até *b* em *n* partes, de modo que +:math:`h=\frac{b-a}{n}`, então podemos construir a seguinte tabela. + +============== ================== ================ +:math:`x` :math:`y` :math:`hf(x,y)` +============== ================== ================ +:math:`a` :math:`c` :math:`hf(a,c)` +:math:`a+h` :math:`c+hf(a,c)` ... +:math:`a+2h` ... +... +:math:`b=a+nh` ??? ... +============== ================== ================ + + +O objetivo é completar os espaços em branco na tabela, em uma linha +por vez, até atingirmos ???, que é a aproximação para :math:`y(b)` +usando o método de Euler. + +A ideia para sistemas de EDOs é semelhante. + +**Exemplo:** Aproxime numericamente :math:`z(t)` em :math:`t=1` usando +4 passos do método de Euler, onde :math:`z''+tz'+z=0`, :math:`z(0)=1`, +:math:`z'(0)=0`. + +Devemos reduzir a EDO de segunda ordem a um sistema de duas EDOs de +primeira ordem (usando :math:`x=z`, :math:`y=z'`) e aplicar o método +de Euler: + +:: + + sage: t,x,y = PolynomialRing(RealField(10),3,"txy").gens() + sage: f = y; g = -x - y * t + sage: eulers_method_2x2(f,g, 0, 1, 0, 1/4, 1) + t x h*f(t,x,y) y h*g(t,x,y) + 0 1 0.00 0 -0.25 + 1/4 1.0 -0.062 -0.25 -0.23 + 1/2 0.94 -0.12 -0.48 -0.17 + 3/4 0.82 -0.16 -0.66 -0.081 + 1 0.65 -0.18 -0.74 0.022 + +Portanto, :math:`z(1)\approx 0.65`. + +Podemos também representar em um gráfico os pontos :math:`(x,y)` para +obter uma figura da solução aproximada. A função +``eulers_method_2x2_plot`` fará isso; para usá-la, precisamos definir +funções *f* e *g* que recebam um argumento com três coordenadas (*t*, +*x*, *y*). + +:: + + sage: f = lambda z: z[2] # f(t,x,y) = y + sage: g = lambda z: -sin(z[1]) # g(t,x,y) = -sin(x) + sage: P = eulers_method_2x2_plot(f,g, 0.0, 0.75, 0.0, 0.1, 1.0) + +A esta altura, ``P`` armazena dois gráficos: ``P[0]``, o gráfico de +*x* versus *t*, e ``P[1]``, o gráfico de *y* versus *t*. Podemos +visualizar os dois gráficos da seguinte forma: + +.. link + +:: + + sage: show(P[0] + P[1]) + +(Para mais sobre gráficos, veja :ref:`section-plot`.) + +Funções Especiais +----------------- + +Diversos polinômios ortogonais e funções especiais estão +implementadas, usando tanto o PARI [GP]_ como o Maxima [Max]_. Isso +está documentado nas seções apropriadas ("Orthogonal polynomials" and +"Special functions", respectivamente) do manual de referência do Sage +(em inglês). + +:: + + sage: x = polygen(QQ, 'x') + sage: chebyshev_U(2,x) + 4*x^2 - 1 + sage: bessel_I(1,1,"pari",250) + 0.56515910399248502720769602760986330732889962162109200948029448947925564096 + sage: bessel_I(1,1) + 0.565159103992485 + sage: bessel_I(2,1.1,"maxima") # last few digits are random + 0.16708949925104899 + +No momento, essas funções estão disponíveis na interface do Sage +apenas para uso numérico. Para uso simbólico, use a interface do +Maxima diretamente, como no seguinte exemplo: + +:: + + sage: maxima.eval("f:bessel_y(v, w)") + 'bessel_y(v,w)' + sage: maxima.eval("diff(f,w)") + '(bessel_y(v-1,w)-bessel_y(v+1,w))/2' diff --git a/doc/pt/tutorial/tour_assignment.rst b/doc/pt/tutorial/tour_assignment.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_assignment.rst @@ -0,0 +1,119 @@ +Atribuição, Igualdade, e Aritmética +=================================== + +Com pequenas exceções, o Sage utiliza a linguagem de programação +Python, logo a maioria dos livros de introdução ao Python vão ajudá-lo +a aprender Sage. + +O Sage usa ``=`` para atribuição, e usa ``==``, ``<=``, ``>=``, ``<`` +e ``>`` para comparação: + +:: + + sage: a = 5 + sage: a + 5 + sage: 2 == 2 + True + sage: 2 == 3 + False + sage: 2 < 3 + True + sage: a == 5 + True + +O Sage fornece todas as operações matemáticas básicas: + +:: + + sage: 2**3 # ** means exponent + 8 + sage: 2^3 # ^ is a synonym for ** (unlike in Python) + 8 + sage: 10 % 3 # for integer arguments, % means mod, i.e., remainder + 1 + sage: 10/4 + 5/2 + sage: 10//4 # for integer arguments, // returns the integer quotient + 2 + sage: 4 * (10 // 4) + 10 % 4 == 10 + True + sage: 3^2*4 + 2%5 + 38 + +O cálculo de uma expressão como ``3^2*4 + 2%5`` depende da ordem em +que as operações são aplicadas; isso é especificado na "tabela de +precedência" em :ref:`section-precedence`. + +O Sage também fornece várias funções matemáticas básicas; aqui estão +apenas alguns exemplos: + +:: + + sage: sqrt(3.4) + 1.84390889145858 + sage: sin(5.135) + -0.912021158525540 + sage: sin(pi/3) + 1/2*sqrt(3) + +Como o último exemplo mostra, algumas expressões matemáticas retornam +valores 'exatos' em vez de aproximações numéricas. Para obter uma +aproximação numérica, use a função ``n`` ou o método ``n`` (ambos +possuem um nome longo, ``numerical_approx``, e a função ``N`` é o +mesma que ``n``). Essas funções aceitam o argumento opcional +``prec``, que é o número de bits de precisão requisitado, e +``digits``, que é o número de dígitos decimais de precisão +requisitado; o padrão é 53 bits de precisão. + +:: + + sage: exp(2) + e^2 + sage: n(exp(2)) + 7.38905609893065 + sage: sqrt(pi).numerical_approx() + 1.77245385090552 + sage: sin(10).n(digits=5) + -0.54402 + sage: N(sin(10),digits=10) + -0.5440211109 + sage: numerical_approx(pi, prec=200) + 3.1415926535897932384626433832795028841971693993751058209749 + +O Python é uma linguagem "dinâmicamente digitada" (dynamically typed), +portanto o valor referido por cada variável possui um tipo associado a +ele, mas uma variável pode possuir valores de qualquer tipo em +determinado escopo: + +:: + + sage: a = 5 # a is an integer + sage: type(a) + + sage: a = 5/3 # now a is a rational number + sage: type(a) + + sage: a = 'hello' # now a is a string + sage: type(a) + + +A linguagem de programação C, que é "estaticamente digitada" +(statically typed), é muito diferente; uma variável que foi declarada +como int pode apenas armazenar um int em seu escopo. + +Uma potencial fonte de confusão em Python é que um inteiro literal que +começa com zero é tratado como um número octal, isto é, um número na +base 8. + +:: + + sage: 011 + 9 + sage: 8 + 1 + 9 + sage: n = 011 + sage: n.str(8) # string representation of n in base 8 + '11' + +Isso é consistente com a linguagem de programação C. diff --git a/doc/pt/tutorial/tour_coercion.rst b/doc/pt/tutorial/tour_coercion.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_coercion.rst @@ -0,0 +1,405 @@ +.. -*- coding: utf-8 -*- + +.. _section-coercion: + +============================ +Parentes, Conversão e Coação +============================ + +Esta seção pode parecer mais técnica do que as anteriores, mas +acreditamos que é importante entender o significado de parentes e +coação de modo a usar anéis e outras estruturas algébricas no Sage de +forma efetiva e eficiente. + +Note que vamos explicar algumas noções, mas não vamos mostrar aqui +como implementá-las. Um tutorial voltado à implementação está +disponível (em inglês) como um +`arquivo Sage `_. + +Elementos +--------- + +Caso se queira implementar um anel em Python, uma primeira aproximação +seria criar uma classe para os elementos ``X`` do anel e adicionar os +requeridos métodos (com underscores duplos) ``__add__``, ``__sub``, +``__mul__``, obviamente garantindo que os axiomas de anel são +verificados. + +Como o Python é uma linguagem "strongly typed" (ainda que "dynamically +typed"), poderia-se, pelo menos a princípio, esperar-se que fosse +implementado em Python uma classe para cada anel. No final das contas, +o Python contém um tipo ```` para os inteiros, um tipo +```` para os reais, e assim por diante. Mas essa estratégia +logo encontra uma limitação: Existe um número infinito de anéis, e não +se pode implementar um número infinito de classes. + +Em vez disso, poderia-se criar uma hierarquia de classes projetada +para implementar elementos de estruturas algébricas ubíquas, tais como +grupos, anéis, anéis comutativos, corpos, álgebras, e assim por +diante. + +Mas isso significa que elementos de anéis bastante diferentes podem +ter o mesmo tipo. + +:: + + sage: P. = GF(3)[] + sage: Q. = GF(4,'z')[] + sage: type(x)==type(a) + True + +Por outro lado, poderia-se ter também classes diferentes em Python +fornecendo implementações diferentes da mesma estrutura matemática +(por exemplo, matrizes densas versus matrizes esparsas). + +:: + + sage: P. = PolynomialRing(ZZ) + sage: Q. = PolynomialRing(ZZ, sparse=True) + sage: R. = PolynomialRing(ZZ, implementation='NTL') + sage: type(a); type(b); type(c) + + + + +Isso apresenta dois problemas: Por um lado, se tivéssemos elementos +que são duas instancias da mesma classe, então poderia-se esperar que +o método ``__add__`` dessas classes permitisse somá-los; mas não +se deseja isso, se os elementos pertencem a anéis bastante diferentes. +Por outro lado, se possui-se elementos que pertencem a implementações +diferentes do mesmo anel, então gostaria-se de somá-los, mas isso não +pode ser feito diretamente se eles pertencem a classes diferentes em +Python. + +A solução para esses problemas é chamada coação e será explicada a +seguir. + +Todavia, é essencial que cada elemento saiba a qual pertence. Isso +está disponível através método ``parent()``: + +.. link + +:: + + sage: a.parent(); b.parent(); c.parent() + Univariate Polynomial Ring in a over Integer Ring + Sparse Univariate Polynomial Ring in b over Integer Ring + Univariate Polynomial Ring in c over Integer Ring (using NTL) + + +Parentes e Categorias +--------------------- + +De forma similar à hierarquia de classes em Python voltada para +elementos de estruturas algébricas, o Sage também fornece classes para +as estruturas algébricas que contém esses elementos. Estruturas +contendo elementos são chamadas "estruturas parente" no Sage, e existe +uma classe básica para elas. Paralelamente à hierarquia de noções +matemáticas, tem-se uma hierarquia de classes, a saber, para +conjuntos, anéis, corpos e assim por diante: + +:: + + sage: isinstance(QQ,Field) + True + sage: isinstance(QQ, Ring) + True + sage: isinstance(ZZ,Field) + False + sage: isinstance(ZZ, Ring) + True + +Em álgebra, objetos que compartilham o mesmo tipo de estruturas +algébricas são agrupados nas assim chamadas "categorias". Logo, existe +uma analogia aproximada entre a hierarquia de classes em Sage e a +hierarquia de categorias. Todavia, essa analogia de classes em Python +e categorias não deve ser enfatizada demais. No final das contas, +categorias matemáticas também são implementadas no Sage: + +:: + + sage: Rings() + Category of rings + sage: ZZ.category() + Category of euclidean domains + sage: ZZ.category().is_subcategory(Rings()) + True + sage: ZZ in Rings() + True + sage: ZZ in Fields() + False + sage: QQ in Fields() + True + +Enquanto a hierarquia de classes no Sage é centrada nos detalhes de +implementação, a construção de categorias em Sage é mais centrada +na estrutura matemática. É possível implementar métodos e testes +gerais independentemente de uma implementação específica nas +categorias. + +Estruturas parentes em Sage são supostamente objetos únicos em Python. +Por exemplo, uma vez que um anel de polinômios sobre um certo anel +base e com uma certa lista de geradores é criada, o resultado é +arquivado: + +:: + + sage: RR['x','y'] is RR['x','y'] + True + + +Tipos versus Parentes +--------------------- + +O tipo ``RingElement`` não deve ser confundido com a noção matemática +de elemento de anel; por razões práticas, as vezes um objeto é uma +instancia de ``RingElement`` embora ele não pertence a um anel: + +:: + + sage: M = Matrix(ZZ,2,3); M + [0 0 0] + [0 0 0] + sage: isinstance(M, RingElement) + True + +Enquanto *parentes* são únicos, elementos iguais de um parente em Sage +não são necessariamente idênticos. Isso contrasta com o comportamento +do Python para alguns (embora não todos) inteiros: + +:: + + sage: int(1) is int(1) # Python int + True + sage: int(-15) is int(-15) + False + sage: 1 is 1 # Sage Integer + False + +É importante observar que elementos de anéis diferentes em geral não +podem ser distinguidos pelos seus tipos, mas sim por seus parentes: + +:: + + sage: a = GF(2)(1) + sage: b = GF(5)(1) + sage: type(a) is type(b) + True + sage: parent(a) + Finite Field of size 2 + sage: parent(b) + Finite Field of size 5 + +Logo, de um ponto de vista algébrico, **o parente de um elemento é +mais importante do que seu tipo.** + +Conversão versus Coação +----------------------- + +Em alguns casos é possível converter um elemento de uma estrutura +parente em um elemento de uma outra estrutura parente. Tal conversão +pode ser tanto explícita como implícita (essa é chamada *coação*). + +O leitor pode conhecer as noções de *conversão de tipo* e *coação de +tipo* como na linguagem C, por exemplo. Existem noções de *conversão* +e *coação* em Sage também. Mas as noções em Sage são centradas em +*parentes*, não em tipos. Então, por favor não confunda conversão de +tipo em C com conversão em Sage! + +Aqui se encontra uma breve apresentação. Para uma descrição detalhada +e informações sobre a implementação, referimos à seção sobre coação no +manual de referência e para o `arquivo tutorial +`_. + +Existem duas possibilidades extremas com respeito à possibilidade de +fazer aritmética com elementos de *anéis diferentes*: + +* Anéis diferentes são mundos diferentes, e não faz nenhum sentido + somar ou multiplicar elementos de anéis diferentes; mesmo ``1 + + 1/2`` não faz sentido, pois o primeiro somando é um inteiro e o + segundo um racional. + +Ou + +* Se um elemento ``r1`` de uma aner ``R1`` pode de alguma forma ser + interpretado em um outro anel ``R2``, então todas as operações + aritméticas envolvendo ``r1`` e qualquer elemento de ``R2`` são + permitidas. O elemento neutro da multiplicação existe em todos os + corpos e em vários anéis, e eles devem ser todos iguais. + +O Sage faz uma concessão. Se ``P1`` e ``P2`` são estruturas parentes e +``p1`` é um elemento de ``P1``, então o usuário pode explicitamente +perguntar por uma interpretação de ``p1`` em ``P2``. Isso pode não +fazer sentido em todos os casos ou não estar definido para todos os +elementos de ``P1``, e fica a cargo do usuário assegurar que isso faz +sentido. Nos referimos a isso como **conversão**: + +:: + + sage: a = GF(2)(1) + sage: b = GF(5)(1) + sage: GF(5)(a) == b + True + sage: GF(2)(b) == a + True + +Todavia, uma conversão *implícita* (ou automática) ocorrerá apenas se +puder ser feita *completamente* e *consistentemente*. Rigor matemático +é essencial nesse ponto. + +Uma tal conversão implícita é chamada **coação**. Se coação for +definida, então deve coincidir com conversão. Duas condições devem ser +satisfeitas para uma coação ser definida: + +#. Uma coação de ``P1`` para ``P2`` deve ser dada por uma estrutura + que preserva mapeamentos (por exemplo, um homomorfismo de anéis). + Não é suficiente que *alguns* elementos de ``P1`` possam ser + mapeados em ``P2``, e o mapa deve respeitar a estrutura algébrica + de ``P1``. +#. A escolha desses mapas de coação deve ser consistente: Se ``P3`` é + uma terceira estrutura parente, então a composição da coação + adotada de ``P1`` para ``P2`` com a coação de ``P2`` para ``P3`` + deve coincidir com a coação adotada de ``P1`` para ``P3``. Em + particular, se existir uma coação de ``P1`` para ``P2`` e ``P2`` + para ``P1``, a composição deve ser o mapa identidade em ``P1``. + +Logo, embora é possível converter cada elemento de ``GF(2)`` para +``GF(5)``, não há coação, pois não existe homomorfismo de anel entre +``GF(2)`` e ``GF(5)``. + +O segundo aspecto - consistência - é um pouco mais difícil de +explicar. Vamos ilustrá-lo usando anéis de polinômios em mais de uma +variável. Em aplicações, certamente faz mais sentido ter coações que +preservam nomes. Então temos: + +:: + + sage: R1. = ZZ[] + sage: R2 = ZZ['y','x'] + sage: R2.has_coerce_map_from(R1) + True + sage: R2(x) + x + sage: R2(y) + y + +Se não existir homomorfismo de anel que preserve nomes, coerção não é +definida. Todavia, conversão pode ainda ser possível, a saber, +mapeando geradores de anel de acordo com sua posição da lista de +geradores: + +.. link + +:: + + sage: R3 = ZZ['z','x'] + sage: R3.has_coerce_map_from(R1) + False + sage: R3(x) + z + sage: R3(y) + x + +Mas essas conversões que preservam a posição não se qualificam como +coação: Compondo um mapa que preserva nomes de ``ZZ['x','y']`` para +``ZZ['y','x']``, com um mapa que preserva nomes de ``ZZ['y','x']`` +para ``ZZ['a','b']``, resultaria em um mapa que não preserva nomes nem +posição, violando a consistência. + +Se houver coação, ela será usada para comparar elementos de anéis +diferentes ou fazer aritmética. Isso é frequentemente conveniente, mas +o usuário deve estar ciente que estender a relação ``==`` além das +fronteiras de parentes diferentes pode facilmente resultar em +problemas. Por exemplo, enquanto ``==`` é supostamente uma relação de +equivalência sobre os elementos de *um* anel, isso não é +necessariamente o caso se anéis *diferentes* estão envolvidos. Por +exemplo, ``1`` em ``ZZ`` e em um corpo finito são considerados iguais, +pois existe uma coação canônica dos inteiros em qualquer corpo finito. +Todavia, em geral não existe coação entre dois corpos finitos +diferentes. Portanto temos + +.. link + +:: + + sage: GF(5)(1) == 1 + True + sage: 1 == GF(2)(1) + True + sage: GF(5)(1) == GF(2)(1) + False + sage: GF(5)(1) != GF(2)(1) + True + +Similarmente, + +.. link + +:: + + sage: R3(R1.1) == R3.1 + True + sage: R1.1 == R3.1 + False + sage: R1.1 != R3.1 + True + +Uma outra consequência da condição de consistência é que coação pode +apenas ir de anéis exatos (por exemplo, os racionais ``QQ``) para +anéis não-exatos (por exemplo, os números reais com uma precisão fixa +``RR``), mas não na outra direção. A razão é que a composição da +coação de ``QQ`` em ``RR`` com a conversão de ``RR`` para ``QQ`` +deveria ser a identidade em ``QQ``. Mas isso é impossível, pois alguns +números racionais distintos podem ser tratados como iguais em ``RR``, +como no seguinte exemplo: + +:: + + sage: RR(1/10^200+1/10^100) == RR(1/10^100) + True + sage: 1/10^200+1/10^100 == 1/10^100 + False + +Quando se compara elementos de dois parentes ``P1`` e ``P2``, é +possível que não haja coação entre os dois anéis, mas existe uma +escolha canônica de um parente ``P3`` de modo que tanto ``P1`` como +``P2`` são coagidos em ``P3``. Nesse caso, coação vai ocorrer também. +Um caso de uso típico é na soma de um número racional com um polinômio +com coeficientes inteiros, resultando em um polinômio com coeficientes +racionais: + +:: + + sage: P1. = ZZ[] + sage: p = 2*x+3 + sage: q = 1/2 + sage: parent(p) + Univariate Polynomial Ring in x over Integer Ring + sage: parent(p+q) + Univariate Polynomial Ring in x over Rational Field + +Note que a princípio o resultado deveria também fazer sentido no +corpo de frações de ``ZZ['x']``. Todavia, o Sage tenta escolher um +parente *canônico* comum que parece ser o mais natural (``QQ['x']`` no +nosso exemplo). Se vários potenciais parentes comuns parecem +igualmente naturais, o Sage *não* vai escolher um deles +aleatoriamente. Os mecanismos sobre os quais essa escolha se baseia é +explicado em um `arquivo tutorial +`_ + +Nenhuma coação para um parente comum vai ocorrer no seguinte exemplo: + +:: + + sage: R. = QQ[] + sage: S. = QQ[] + sage: x+y + Traceback (most recent call last): + ... + TypeError: unsupported operand parent(s) for '+': 'Univariate Polynomial Ring in x over Rational Field' and 'Univariate Polynomial Ring in y over Rational Field' + +A razão é que o Sage não escolhe um dos potenciais candidatos +``QQ['x']['y']``, ``QQ['y']['x']``, ``QQ['x','y']`` ou +``QQ['y','x']``, porque todas essas estruturas combinadas em pares +diferentes parecem ser parentes comuns naturais, e não existe escolha +canônica aparente. diff --git a/doc/pt/tutorial/tour_functions.rst b/doc/pt/tutorial/tour_functions.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_functions.rst @@ -0,0 +1,236 @@ +.. _section-functions-issues: + +Algumas Questões Frequentes sobre Funções +========================================= + +Alguns aspectos sobre definição de funções (por exemplo, para +diferenciação, ou para criar gráficos) podem se tornar confusos. Nesta +seção, procuramos tratar algumas questões relevantes. + +Aqui estão várias formas de definir objetos que merecem ser chamamos +de "funções": + +1. Defina uma função em Python, como descrito em +:ref:`section-functions`. Essas funções podem ser usadas para criar +gráficos, mas não podem ser diferenciadas ou integradas. + +:: + + sage: def f(z): return z^2 + sage: type(f) + + sage: f(3) + 9 + sage: plot(f, 0, 2) + +Na última linha, observe a sintaxe. Se fosse usado ``plot(f(z), 0, +2)`` ocorreria um erro, porque ``z`` é uma variável muda na definição +de ``f`` e não está definida fora do contexto da função. De fato, +somente ``f(z)`` já provoca um erro. Os seguintes comandos vão +funcionar neste caso, embora em geral eles devam ser evitados pois +podem ocasionar erros (veja o item 4 abaixo). + +.. link + +:: + + sage: var('z') # define z to be a variable + z + sage: f(z) + z^2 + sage: plot(f(z), 0, 2) + +Acima, ``f(z)`` é uma expressão simbólica, o próximo item na nossa +lista. + +2. Defina um "expressão simbólica que pode ser evocada". Essas podem +ser usadas para criar gráficos, e podem ser diferenciadas ou +integradas. + +:: + + sage: g(x) = x^2 + sage: g # g sends x to x^2 + x |--> x^2 + sage: g(3) + 9 + sage: Dg = g.derivative(); Dg + x |--> 2*x + sage: Dg(3) + 6 + sage: type(g) + + sage: plot(g, 0, 2) + +Note que enquanto ``g`` é uma expressão simbólica que pode ser +evocada, ``g(x)`` é um objeto diferente, embora relacionado, que pode +ser usado para criar gráficos, ou ser diferenciado, integrado, etc., +embora com algumas ressalvas: veja o item 5 abaixo. + +.. link + +:: + + sage: g(x) + x^2 + sage: type(g(x)) + + sage: g(x).derivative() + 2*x + sage: plot(g(x), 0, 2) + +3. Use uma função pré-definida. Essas podem ser representadas em +gráfico, e com uma pequena ajuda, diferenciadas e integradas. + +:: + + sage: type(sin) + + sage: plot(sin, 0, 2) + sage: type(sin(x)) + + sage: plot(sin(x), 0, 2) + +Por si só, ``sin`` não pode ser diferenciado, pelo menos não para +produzir ``cos``. + +:: + + sage: f = sin + sage: f.derivative() + Traceback (most recent call last): + ... + AttributeError: ... + +Usando ``f = sin(x)`` no lugar de ``sin`` funciona, mas é ainda melhor +usar ``f(x) = sin(x)`` para definir uma expressão simbólica que pode +ser evocada. + +:: + + sage: S(x) = sin(x) + sage: S.derivative() + x |--> cos(x) + +Aqui estão alguns problemas comuns, com explicações: + +\4. Cálculo acidental. + +:: + + sage: def h(x): + ... if x<2: + ... return 0 + ... else: + ... return x-2 + +O problema: ``plot(h(x), 0, 4)`` cria o gráfico da reta `y=x-2`, não +da função definida por ``h``. O motivo? No comando ``plot(h(x), 0, +4)``, primeiro ``h(x)`` é calculada: isso significa substituir ``x`` +na função ``h``, o que significa que ``x<2`` é calculado. + +.. link + +:: + + sage: type(x<2) + + +Quando uma equação simbólica é calculada, como na definição de ``h``, +se ela não é obviamente verdadeira, então ela retorna False. Logo +``h(x)`` é calculada como ``x-2``, e essa é a função que será +representada no gráfico. + +A solução: não use ``plot(h(x), 0, 4)``; em vez disso, use + +.. link + +:: + + sage: plot(h, 0, 4) + +\5. Acidentalmente produzindo uma constante em vez de uma função. + +:: + + sage: f = x + sage: g = f.derivative() + sage: g + 1 + +O problema: ``g(3)``, por exemplo, retorna o erro "ValueError: the +number of arguments must be less than or equal to 0." + +.. link + +:: + + sage: type(f) + + sage: type(g) + + +``g`` não é uma função, é uma constante, logo não possui variáveis +associadas, e você não pode substituir nenhum valor em ``g``. + +Solução: existem vária opções. + +- Defina ``f`` inicialmente como uma expressão simbólica. + +:: + + sage: f(x) = x # instead of 'f = x' + sage: g = f.derivative() + sage: g + x |--> 1 + sage: g(3) + 1 + sage: type(g) + + +- Ou com ``f`` como definida originalmente, defina ``g`` como uma + expressão simbólica. + +:: + + sage: f = x + sage: g(x) = f.derivative() # instead of 'g = f.derivative()' + sage: g + x |--> 1 + sage: g(3) + 1 + sage: type(g) + + +- Ou com ``f`` e ``g`` como definidas originalmente, especifique a + variável para a qual você está substituindo. + +:: + + sage: f = x + sage: g = f.derivative() + sage: g + 1 + sage: g(x=3) # instead of 'g(3)' + 1 + +Finalmente, aqui vai mais uma forma de saber a diferença entre as +derivadas de ``f = x`` e ``f(x) = x``. + +:: + + sage: f(x) = x + sage: g = f.derivative() + sage: g.variables() # the variables present in g + () + sage: g.arguments() # the arguments which can be plugged into g + (x,) + sage: f = x + sage: h = f.derivative() + sage: h.variables() + () + sage: h.arguments() + () + +Como esse exemplo procura ilustrar, ``h`` não aceita argumentos, e é +por isso que ``h(3)`` retorna um erro. diff --git a/doc/pt/tutorial/tour_groups.rst b/doc/pt/tutorial/tour_groups.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_groups.rst @@ -0,0 +1,92 @@ +Grupos Finitos, Grupos Abelianos +================================ + +O Sage possui suporte para fazer cálculos com grupos de permutação, +grupos finitos clássicos (tais como :math:`SU(n,q)`), grupos +matriciais finitos (com os seus próprios geradores), e grupos +abelianos (até mesmo infinitos). A maior parte disso é implementada +usando a interface com o GAP. + +Por exemplo, para criar um grupo de permutação, forneça uma lista de +geradores, como no seguinte exemplo. + +:: + + sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)']) + sage: G + Permutation Group with generators [(3,4), (1,2,3)(4,5)] + sage: G.order() + 120 + sage: G.is_abelian() + False + sage: G.derived_series() # random-ish output + [Permutation Group with generators [(1,2,3)(4,5), (3,4)], + Permutation Group with generators [(1,5)(3,4), (1,5)(2,4), (1,3,5)]] + sage: G.center() + Subgroup of (Permutation Group with generators [(3,4), (1,2,3)(4,5)]) generated by [()] + sage: G.random_element() # random output + (1,5,3)(2,4) + sage: print latex(G) + \langle (3,4), (1,2,3)(4,5) \rangle + +Você pode também obter a tabela de caracteres (em formato LaTeX) no +Sage: + +:: + + sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]]) + sage: latex(G.character_table()) + \left(\begin{array}{rrrr} + 1 & 1 & 1 & 1 \\ + 1 & 1 & -\zeta_{3} - 1 & \zeta_{3} \\ + 1 & 1 & \zeta_{3} & -\zeta_{3} - 1 \\ + 3 & -1 & 0 & 0 + \end{array}\right) + +O Sage também inclui grupos clássicos matriciais sobre corpos finitos: + +:: + + sage: MS = MatrixSpace(GF(7), 2) + sage: gens = [MS([[1,0],[-1,1]]),MS([[1,1],[0,1]])] + sage: G = MatrixGroup(gens) + sage: G.conjugacy_class_representatives() + [ + [1 0] + [0 1], + [0 1] + [6 1], + ... + [6 0] + [0 6] + ] + sage: G = Sp(4,GF(7)) + sage: G._gap_init_() + 'Sp(4, 7)' + sage: G + Symplectic Group of rank 2 over Finite Field of size 7 + sage: G.random_element() # random output + [5 5 5 1] + [0 2 6 3] + [5 0 1 0] + [4 6 3 4] + sage: G.order() + 276595200 + +Você também pode fazer cálculos usando grupos abelianos (finitos ou +infinitos): + +:: + + sage: F = AbelianGroup(5, [5,5,7,8,9], names='abcde') + sage: (a, b, c, d, e) = F.gens() + sage: d * b**2 * c**3 + b^2*c^3*d + sage: F = AbelianGroup(3,[2]*3); F + Multiplicative Abelian Group isomorphic to C2 x C2 x C2 + sage: H = AbelianGroup([2,3], names="xy"); H + Multiplicative Abelian Group isomorphic to C2 x C3 + sage: AbelianGroup(5) + Multiplicative Abelian Group isomorphic to Z x Z x Z x Z x Z + sage: AbelianGroup(5).order() + +Infinity diff --git a/doc/pt/tutorial/tour_help.rst b/doc/pt/tutorial/tour_help.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_help.rst @@ -0,0 +1,363 @@ +.. _chapter-help: + +Obtendo ajuda +============= + +O Sage possui vasta documentação, acessível digitando o nome de uma +função ou constante (por exemplo), seguido pelo ponto de interrogação: + +.. skip + +:: + + sage: tan? + Type: + Definition: tan( [noargspec] ) + Docstring: + + The tangent function + + EXAMPLES: + sage: tan(pi) + 0 + sage: tan(3.1415) + -0.0000926535900581913 + sage: tan(3.1415/4) + 0.999953674278156 + sage: tan(pi/4) + 1 + sage: tan(1/2) + tan(1/2) + sage: RR(tan(1/2)) + 0.546302489843790 + sage: log2? + Type: + Definition: log2( [noargspec] ) + Docstring: + + The natural logarithm of the real number 2. + + EXAMPLES: + sage: log2 + log2 + sage: float(log2) + 0.69314718055994529 + sage: RR(log2) + 0.693147180559945 + sage: R = RealField(200); R + Real Field with 200 bits of precision + sage: R(log2) + 0.69314718055994530941723212145817656807550013436025525412068 + sage: l = (1-log2)/(1+log2); l + (1 - log(2))/(log(2) + 1) + sage: R(l) + 0.18123221829928249948761381864650311423330609774776013488056 + sage: maxima(log2) + log(2) + sage: maxima(log2).float() + .6931471805599453 + sage: gp(log2) + 0.6931471805599453094172321215 # 32-bit + 0.69314718055994530941723212145817656807 # 64-bit + sage: sudoku? + File: sage/local/lib/python2.5/site-packages/sage/games/sudoku.py + Type: + Definition: sudoku(A) + Docstring: + + Solve the 9x9 Sudoku puzzle defined by the matrix A. + + EXAMPLE: + sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0, + 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, + 0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0, 0,3,0, 0,0,2, + 0,0,0, 4,9,0, 0,5,0, 0,0,3]) + sage: A + [5 0 0 0 8 0 0 4 9] + [0 0 0 5 0 0 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] + [0 0 0 0 0 0 0 1 8] + [7 0 0 0 0 4 1 5 0] + [0 3 0 0 0 2 0 0 0] + [4 9 0 0 5 0 0 0 3] + sage: sudoku(A) + [5 1 3 6 8 7 2 4 9] + [8 4 9 5 2 1 6 3 7] + [2 6 7 3 4 9 5 8 1] + [1 5 8 4 6 3 9 7 2] + [9 7 4 2 1 8 3 6 5] + [3 2 6 7 9 5 4 1 8] + [7 8 2 9 3 4 1 5 6] + [6 3 5 1 7 2 8 9 4] + [4 9 1 8 5 6 7 2 3] + +O Sage também fornece completamento tab: digite as primeiras letras de +uma função e então pressione a tecla tab. Por exemplo, se você digitar +``ta`` seguido de ``TAB``, o Sage vai imprimir ``tachyon, tan, tanh, +taylor``. Essa é uma boa forma de encontrar nomes de funções e outras +estruturas no Sage. + + +.. _section-functions: + +Funções, Tabulação, e Contagem +=============================== + +Para definir uma nova função no Sage, use o comando ``def`` e dois +pontos após a lista de nomes das variáveis. Por exemplo: + +:: + + sage: def is_even(n): + ... return n%2 == 0 + ... + sage: is_even(2) + True + sage: is_even(3) + False + +Observação: Dependendo da versão do tutorial que você está lendo, +você pode ver três pontos ``...`` na segunda linha desse exemplo. Não +digite esses pontos; eles são apenas para enfatizar que o código está +tabulado. Se for esse o caso, pressione [Enter] uma vez após o fim do +bloco de código para inserir uma linha em branco e concluir a +definição da função. + +Você não especifica o tipo de dado de nenhum dos argumentos da função. +É possível especificar argumentos múltiplos, cada um dos quais pode +ter um valor opcional padrão. Por exemplo, a função abaixo usa o valor +padrão ``divisor=2`` se ``divisor`` não é especificado. + +:: + + sage: def is_divisible_by(number, divisor=2): + ... return number%divisor == 0 + sage: is_divisible_by(6,2) + True + sage: is_divisible_by(6) + True + sage: is_divisible_by(6, 5) + False + +Você também pode especificar explicitamente um ou mais argumentos +quando evocar uma função; se você especificar os argumentos +explicitamente, você pode fazê-lo em qualquer ordem: + +.. link + +:: + + sage: is_divisible_by(6, divisor=5) + False + sage: is_divisible_by(divisor=2, number=6) + True + +Em Python, blocos de código não são indicados por colchetes ou blocos +de início e fim, como em outras linguagens. Em vez disso, blocos de +código são indicados por tabulação, que devem estar alinhadas +exatamente. Por exemplo, o seguinte código possui um erro de sintaxe +porque o comando ``return`` não possui a mesma tabulação da linha que +inicia o seu bloco de código. + +.. skip + +:: + + sage: def even(n): + ... v = [] + ... for i in range(3,n): + ... if i % 2 == 0: + ... v.append(i) + ... return v + Syntax Error: + return v + +Se você corrigir a tabulação, a função fica correta: + +:: + + sage: def even(n): + ... v = [] + ... for i in range(3,n): + ... if i % 2 == 0: + ... v.append(i) + ... return v + sage: even(10) + [4, 6, 8] + +Não é necessário inserir ponto-e-vírgula no final da linha. Todavia, +você pode inserir múltiplos comandos em uma mesma linha separados por +ponto-e-vírgula: + +:: + + sage: a = 5; b = a + 3; c = b^2; c + 64 + +Se você quiser que uma única linha de comando seja escrita em mais de +uma linha, use a barra invertida para quebrar a linha: + +:: + + sage: 2 + \ + ... 3 + 5 + +Em Sage, a contagem é feita iterando sobre um intervalo de inteiros. +Por exemplo, a primeira linha abaixo é equivalente a ``for(i=0; i<3; +i++)`` em C++ ou Java: + +:: + + sage: for i in range(3): + ... print i + 0 + 1 + 2 + +A primeira linha abaixo é equivalente a ``for(i=2; i<5; i++)``. + +:: + + sage: for i in range(2,5): + ... print i + 2 + 3 + 4 + +O Terceiro argumento controla o passo. O comando abaixo é equivalente +a ``for(i=1; i<6; i+=2)``. + +:: + + sage: for i in range(1,6,2): + ... print i + 1 + 3 + 5 + +Frequentemente deseja-se criar uma tabela para visualizar resultados +calculados com o Sage. Uma forma fácil de fazer isso é utilizando +formatação de strings. Abaixo, criamos três colunas cada uma com +largura exatamente 6, e fazemos uma tabela com quadrados e cubos de +alguns números. + +:: + + sage: for i in range(5): + ... print '%6s %6s %6s'%(i, i^2, i^3) + 0 0 0 + 1 1 1 + 2 4 8 + 3 9 27 + 4 16 64 + +A estrutura de dados mais básica em Sage é a lista, que é -- como o +nome sugere -- simplesmente uma lista de objetos arbitrários. Por +exemplo, o comando ``range`` que usamos acima cria uma lista: + +:: + + sage: range(2,10) + [2, 3, 4, 5, 6, 7, 8, 9] + +Abaixo segue uma lista mais complicada: + +:: + + sage: v = [1, "hello", 2/3, sin(x^3)] + sage: v + [1, 'hello', 2/3, sin(x^3)] + +Listas são indexadas começando do 0, como em várias linguagens de +programação. + +.. link + +:: + + sage: v[0] + 1 + sage: v[3] + sin(x^3) + +Use ``len(v)`` para obter o comprimento de ``v``, use +``v.append(obj)`` para inserir um novo objeto no final de ``v``, e use +``del v[i]`` para remover o :math:`i`-ésimo elemento de ``v``: + +.. link + +:: + + sage: len(v) + 4 + sage: v.append(1.5) + sage: v + [1, 'hello', 2/3, sin(x^3), 1.50000000000000] + sage: del v[1] + sage: v + [1, 2/3, sin(x^3), 1.50000000000000] + +Outra importante estrutura de dados é o dicionário (ou lista +associativa). Ele funciona como uma lista, exceto que pode ser +indexado por vários tipos de objeto (os índices devem ser imutáveis): + +:: + + sage: d = {'hi':-2, 3/8:pi, e:pi} + sage: d['hi'] + -2 + sage: d[e] + pi + +Você pode também definir novos tipos de dados usando classes. +Encapsular objetos matemáticos usando classes é uma técnica poderosa +que pode ajudar a simplificar e organizar os seus programas em Sage. +Abaixo, definimos uma nova classe que representa a lista de inteiros +pares positivos até *n*; essa classe é derivada do tipo ``list``. + +:: + + sage: class Evens(list): + ... def __init__(self, n): + ... self.n = n + ... list.__init__(self, range(2, n+1, 2)) + ... def __repr__(self): + ... return "Even positive numbers up to n." + +O método ``__init__`` é evocado para inicializar o objeto quando ele é +criado; o método ``__repr__`` imprime o objeto. Nós evocamos o +construtor ``__init__`` do tipo ``list`` na segunda linha do método +``__init__``. Criamos um objeto da classe ``Evens`` da seguinte forma: + +.. link + +:: + + sage: e = Evens(10) + sage: e + Even positive numbers up to n. + +Note que ``e`` imprime usando o método ``__repr__`` que nós +definimos. Para ver a lista de números, use a função ``list``: + +.. link + +:: + + sage: list(e) + [2, 4, 6, 8, 10] + +Podemos também acessar o atributo ``n`` ou tratar ``e`` como uma +lista. + +.. link + +:: + + sage: e.n + 10 + sage: e[2] + 6 diff --git a/doc/pt/tutorial/tour_linalg.rst b/doc/pt/tutorial/tour_linalg.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_linalg.rst @@ -0,0 +1,233 @@ +.. _section-linalg: + +Álgebra Linear +============== + +O Sage fornece os objetos usuais em álgebra linear, por exemplo, o +polinômio característico, matriz escalonada, traço, decomposição, +etc., de uma matriz. + +Criar e multiplicar matrizes é fácil e natural: + +:: + + sage: A = Matrix([[1,2,3],[3,2,1],[1,1,1]]) + sage: w = vector([1,1,-4]) + sage: w*A + (0, 0, 0) + sage: A*w + (-9, 1, -2) + sage: kernel(A) + Free module of degree 3 and rank 1 over Integer Ring + Echelon basis matrix: + [ 1 1 -4] + +Note que no Sage, o núcleo de uma matriz :math:`A` é o núcleo à +esquerda, i.e., o conjunto de vetores :math:`w` tal que :math:`wA=0`. + +Resolver equações matriciais é fácil usando o método ``solve_right``. +Calculando ``A.solve_right(Y)`` obtém-se uma matrix (ou vetor) +:math:`X` tal que :math:`AX=Y`: + +.. link + +:: + + sage: Y = vector([0, -4, -1]) + sage: X = A.solve_right(Y) + sage: X + (-2, 1, 0) + sage: A * X # checking our answer... + (0, -4, -1) + +Uma barra invertida ``\`` pode ser usada no lugar de ``solve_right``; +use ``A \ Y`` no lugar de ``A.solve_right(Y)``. + +.. link + +:: + + sage: A \ Y + (-2, 1, 0) + +Se não existir solução, o Sage retorna um erro: + +.. skip + +:: + + sage: A.solve_right(w) + Traceback (most recent call last): + ... + ValueError: matrix equation has no solutions + +Similarmente, use ``A.solve_left(Y)`` para resolver para :math:`X` em +:math:`XA=Y`. + +O Sage também pode calcular autovalores e autovetores:: + + sage: A = matrix([[0, 4], [-1, 0]]) + sage: A.eigenvalues () + [-2*I, 2*I] + sage: B = matrix([[1, 3], [3, 1]]) + sage: B.eigenvectors_left() + [(4, [ + (1, 1) + ], 1), (-2, [ + (1, -1) + ], 1)] + +(A sintaxe para a resposta de ``eigenvectors_left`` é uma lista com +três componentes: (autovalor, autovetor, multiplicidade).) Autovalores +e autovetores sobre ``QQ`` ou ``RR`` também podem ser calculados +usando o Maxima (veja :ref:`section-maxima`). + +Como observado em :ref:`section-rings`, o anel sobre o qual a matriz +esta definida afeta alguma de suas propriedades. A seguir, o primeiro +argumento do comando ``matrix`` diz para o Sage considerar a matriz +como uma matriz de inteiros (o caso ``ZZ``), uma matriz de números +racionais (``QQ``), ou uma matriz de números reais (``RR``):: + + sage: AZ = matrix(ZZ, [[2,0], [0,1]]) + sage: AQ = matrix(QQ, [[2,0], [0,1]]) + sage: AR = matrix(RR, [[2,0], [0,1]]) + sage: AZ.echelon_form() + [2 0] + [0 1] + sage: AQ.echelon_form() + [1 0] + [0 1] + sage: AR.echelon_form() + [ 1.00000000000000 0.000000000000000] + [0.000000000000000 1.00000000000000] + +Espaços de Matrizes +------------------- + +Agora criamos o espaço :math:`\text{Mat}_{3\times 3}(\QQ)` de matrizes +`3 \times 3` com entradas racionais:: + + sage: M = MatrixSpace(QQ,3) + sage: M + Full MatrixSpace of 3 by 3 dense matrices over Rational Field + +(Para especificar o espaço de matrizes 3 por 4, você usaria +``MatrixSpace(QQ,3,4)``. Se o número de colunas é omitido, ele é +considerado como igual ao número de linhas, portanto, +``MatrixSpace(QQ,3)`` é sinônimo de ``MatrixSpace(QQ,3,3)``.) O espaço +de matrizes possui uma base que o Sage armazena como uma lista: + +.. link + +:: + + sage: B = M.basis() + sage: len(B) + 9 + sage: B[1] + [0 1 0] + [0 0 0] + [0 0 0] + +Vamos criar uma matriz como um elemento de ``M``. + +.. link + +:: + + sage: A = M(range(9)); A + [0 1 2] + [3 4 5] + [6 7 8] + +A seguir calculamos a sua forma escalonada e o núcleo. + +.. link + +:: + + sage: A.echelon_form() + [ 1 0 -1] + [ 0 1 2] + [ 0 0 0] + sage: A.kernel() + Vector space of degree 3 and dimension 1 over Rational Field + Basis matrix: + [ 1 -2 1] + +Agora ilustramos o cálculo com matrizes definidas sobre um corpo +finito: + +:: + + sage: M = MatrixSpace(GF(2),4,8) + sage: A = M([1,1,0,0, 1,1,1,1, 0,1,0,0, 1,0,1,1, + ... 0,0,1,0, 1,1,0,1, 0,0,1,1, 1,1,1,0]) + sage: A + [1 1 0 0 1 1 1 1] + [0 1 0 0 1 0 1 1] + [0 0 1 0 1 1 0 1] + [0 0 1 1 1 1 1 0] + sage: rows = A.rows() + sage: A.columns() + [(1, 0, 0, 0), (1, 1, 0, 0), (0, 0, 1, 1), (0, 0, 0, 1), + (1, 1, 1, 1), (1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 0)] + sage: rows + [(1, 1, 0, 0, 1, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1), + (0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 1, 1, 1, 1, 1, 0)] + +Criamos o subespaço sobre `\GF{2}` gerado pelas linhas acima. + +.. link + +:: + + sage: V = VectorSpace(GF(2),8) + sage: S = V.subspace(rows) + sage: S + Vector space of degree 8 and dimension 4 over Finite Field of size 2 + Basis matrix: + [1 0 0 0 0 1 0 0] + [0 1 0 0 1 0 1 1] + [0 0 1 0 1 1 0 1] + [0 0 0 1 0 0 1 1] + sage: A.echelon_form() + [1 0 0 0 0 1 0 0] + [0 1 0 0 1 0 1 1] + [0 0 1 0 1 1 0 1] + [0 0 0 1 0 0 1 1] + +A base de `S` usada pelo Sage é obtida a partir das linhas não-nulas +da forma escalonada da matriz de geradores de `S`. + +Álgebra Linear Esparsa +---------------------- + +O Sage fornece suporte para álgebra linear esparsa. + +:: + + sage: M = MatrixSpace(QQ, 100, sparse=True) + sage: A = M.random_element(density = 0.05) + sage: E = A.echelon_form() + +O algoritmo multi-modular no Sage é bom para matrizes quadradas (mas +não muito bom para matrizes que não são quadradas): + +:: + + sage: M = MatrixSpace(QQ, 50, 100, sparse=True) + sage: A = M.random_element(density = 0.05) + sage: E = A.echelon_form() + sage: M = MatrixSpace(GF(2), 20, 40, sparse=True) + sage: A = M.random_element() + sage: E = A.echelon_form() + +Note que o Python é sensível a maiúsculas e minúsculas: + +:: + + sage: M = MatrixSpace(QQ, 10,10, Sparse=True) + Traceback (most recent call last): + ... + TypeError: MatrixSpace() got an unexpected keyword argument 'Sparse' diff --git a/doc/pt/tutorial/tour_numtheory.rst b/doc/pt/tutorial/tour_numtheory.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_numtheory.rst @@ -0,0 +1,168 @@ +Teoria de Números +================= + +O Sage possui extensa funcionalidade para teoria de números. Por +exemplo, podemos fazer aritmética em :math:`\ZZ/N\ZZ` da seguinte +forma: + +:: + + sage: R = IntegerModRing(97) + sage: a = R(2) / R(3) + sage: a + 33 + sage: a.rational_reconstruction() + 2/3 + sage: b = R(47) + sage: b^20052005 + 50 + sage: b.modulus() + 97 + sage: b.is_square() + True + +O Sage contém funções comuns em teoria de números. Por exemplo, + +:: + + sage: gcd(515,2005) + 5 + sage: factor(2005) + 5 * 401 + sage: c = factorial(25); c + 15511210043330985984000000 + sage: [valuation(c,p) for p in prime_range(2,23)] + [22, 10, 6, 3, 2, 1, 1, 1] + sage: next_prime(2005) + 2011 + sage: previous_prime(2005) + 2003 + sage: divisors(28); sum(divisors(28)); 2*28 + [1, 2, 4, 7, 14, 28] + 56 + 56 + +Perfeito! + +A função ``sigma(n,k)`` do Sage soma as :math:`k`-ésimas potências dos +divisores de ``n``: + +:: + + sage: sigma(28,0); sigma(28,1); sigma(28,2) + 6 + 56 + 1050 + +A seguir ilustramos o algoritmo de Euclides estendido, a função +:math:`\phi` de Euler, e o teorema do resto Chinês: + +:: + + sage: d,u,v = xgcd(12,15) + sage: d == u*12 + v*15 + True + sage: n = 2005 + sage: inverse_mod(3,n) + 1337 + sage: 3 * 1337 + 4011 + sage: prime_divisors(n) + [5, 401] + sage: phi = n*prod([1 - 1/p for p in prime_divisors(n)]); phi + 1600 + sage: euler_phi(n) + 1600 + sage: prime_to_m_part(n, 5) + 401 + +Agora verificamos algo sobre o problema :math:`3n+1`. + +:: + + sage: n = 2005 + sage: for i in range(1000): + ... n = 3*odd_part(n) + 1 + ... if odd_part(n)==1: + ... print i + ... break + 38 + +Por fim, ilustramos o teorema do resto Chinês. + +:: + + sage: x = crt(2, 1, 3, 5); x + 11 + sage: x % 3 # x mod 3 = 2 + 2 + sage: x % 5 # x mod 5 = 1 + 1 + sage: [binomial(13,m) for m in range(14)] + [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1] + sage: [binomial(13,m)%2 for m in range(14)] + [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1] + sage: [kronecker(m,13) for m in range(1,13)] + [1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1] + sage: n = 10000; sum([moebius(m) for m in range(1,n)]) + -23 + sage: list(partitions(4)) + [(1, 1, 1, 1), (1, 1, 2), (2, 2), (1, 3), (4,)] + +Números :math:`p`-ádicos +------------------------ + +O corpo dos números :math:`p`-ádicos está implementado em Sage. Note +que uma vez que um corpo :math:`p`-ádico é criado, você não pode +alterar a sua precisão. + +:: + + sage: K = Qp(11); K + 11-adic Field with capped relative precision 20 + sage: a = K(211/17); a + 4 + 4*11 + 11^2 + 7*11^3 + 9*11^5 + 5*11^6 + 4*11^7 + 8*11^8 + 7*11^9 + + 9*11^10 + 3*11^11 + 10*11^12 + 11^13 + 5*11^14 + 6*11^15 + 2*11^16 + + 3*11^17 + 11^18 + 7*11^19 + O(11^20) + sage: b = K(3211/11^2); b + 10*11^-2 + 5*11^-1 + 4 + 2*11 + O(11^18) + +Muito trabalho foi feito implementando anéis de inteiros em corpos +:math:`p`-ádicos ou corpos numéricos além de `Z`. O leitor +interessado é convidado a perguntar mais detalhes aos especialistas na +lista ``sage-support`` no Google Groups. + +Diversos métodos relacionados já estão implementados na classe +NumberField. + +:: + + sage: R. = PolynomialRing(QQ) + sage: K = NumberField(x^3 + x^2 - 2*x + 8, 'a') + sage: K.integral_basis() + [1, 1/2*a^2 + 1/2*a, a^2] + +.. link + +:: + + sage: K.galois_group(type="pari") + Galois group PARI group [6, -1, 2, "S3"] of degree 3 of the Number Field + in a with defining polynomial x^3 + x^2 - 2*x + 8 + +.. link + +:: + + sage: K.polynomial_quotient_ring() + Univariate Quotient Polynomial Ring in a over Rational Field with modulus + x^3 + x^2 - 2*x + 8 + sage: K.units() + [3*a^2 + 13*a + 13] + sage: K.discriminant() + -503 + sage: K.class_group() + Class group of order 1 of Number Field in a with + defining polynomial x^3 + x^2 - 2*x + 8 + sage: K.class_number() + 1 diff --git a/doc/pt/tutorial/tour_plotting.rst b/doc/pt/tutorial/tour_plotting.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_plotting.rst @@ -0,0 +1,231 @@ +.. _section-plot: + +Gráficos +======== + +O Sage pode produzir gráficos bidimensionais e tridimensionais. + +Gráficos Bidimensionais +----------------------- + +Em duas dimensões, o Sage pode desenhar círculos, linhas, e polígonos; +gráficos de funções em coordenadas retangulares, e também coordenadas +polares; gráficos de contorno e gráficos de campos vetoriais. +Apresentamos alguns exemplos desses gráficos aqui. Para mais exemplos +de gráficos com o Sage, veja :ref:`section-systems` e +:ref:`section-maxima`, e também a documentação `Sage Constructions +`_. + +Este comando produz um círculo amarelo de raio 1, centrado na origem. + +:: + + sage: circle((0,0), 1, rgbcolor=(1,1,0)) + +Você pode também produzir um círculo preenchido: + +:: + + sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True) + +Outra possibilidade é criar um círculo atribuindo-o a uma variável; +isso não cria um gráfico: + +:: + + sage: c = circle((0,0), 1, rgbcolor=(1,1,0)) + +Para criar o gráfico, use ``c.show()`` ou ``show(c)``, da seguinte +forma: + +.. link + +:: + + sage: c.show() + +Alternativamente, o comando ``c.save('filename.png')`` salva o gráfico +no arquivo citado. + +Agora, esses 'círculos' parecem mais elipses porque os eixos estão em +escalas diferentes. Você pode alterar isso: + +.. link + +:: + + sage: c.show(aspect_ratio=1) + +O comando ``show(c, aspect_ratio=1)`` produz o mesmo resultado, ou +você pode salvar a figura usando ``c.save('filename.png', +aspect_ratio=1)``. + +É fácil criar o gráfico de funções simples: + +:: + + sage: plot(cos, (-5,5)) + +Após especificar uma variável, você também pode criar gráficos +paramétricos: + +:: + + sage: x = var('x') + sage: parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6)) + +É importante notar que os eixos dos gráficos vão se intersectar apenas +se a origem estiver no escopo do gráfico, e que valores grandes podem +ser representados usando notação científica. + +:: + + sage: plot(x^2,(x,300,500)) + +Você pode combinar vários gráficos somando-os: + +:: + + sage: x = var('x') + sage: p1 = parametric_plot((cos(x),sin(x)),(x,0,2*pi),rgbcolor=hue(0.2)) + sage: p2 = parametric_plot((cos(x),sin(x)^2),(x,0,2*pi),rgbcolor=hue(0.4)) + sage: p3 = parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6)) + sage: show(p1+p2+p3, axes=false) + +Uma boa forma de produzir figuras preenchidas é criar uma lista de +pontos (``L`` no exemplo abaixo) e então usar o comando ``polygon`` +para fazer o gráfico do polígono formado por esses pontos. Por +exemplo, aqui está um "deltoid" verde: + +:: + + sage: L = [[-1+cos(pi*i/100)*(1+cos(pi*i/100)),\ + ... 2*sin(pi*i/100)*(1-cos(pi*i/100))] for i in range(200)] + sage: p = polygon(L, rgbcolor=(1/8,3/4,1/2)) + sage: p + +Digite ``show(p, axes=false)`` para visualizar isso sem os eixos. + +Você pode adicionar texto ao gráfico: + +:: + + sage: L = [[6*cos(pi*i/100)+5*cos((6/2)*pi*i/100),\ + ... 6*sin(pi*i/100)-5*sin((6/2)*pi*i/100)] for i in range(200)] + sage: p = polygon(L, rgbcolor=(1/8,1/4,1/2)) + sage: t = text("hypotrochoid", (5,4), rgbcolor=(1,0,0)) + sage: show(p+t) + +Professores de cálculo frequentemente desenham o seguinte gráfico na +lousa: não apenas um ramo do arco-seno, mas vários deles: isto é, o +gráfico de :math:`y=\sin(x)` para :math:`x` entre :math:`-2\pi` e +:math:`2\pi`, refletido com respeito a reta :math:`x=y`. Os seguintes +comandos fazem isso: + +:: + + sage: v = [(sin(x),x) for x in srange(-2*float(pi),2*float(pi),0.1)] + sage: line(v) + +Como a função tangente possui imagem maior do que o seno, se você usar +o mesmo método para fazer o gráfico da função inversa da função +tangente, você deve alterar as coordenadas mínima e máxima para o eixo +*x*: + +:: + + sage: v = [(tan(x),x) for x in srange(-2*float(pi),2*float(pi),0.01)] + sage: show(line(v), xmin=-20, xmax=20) + +O Sage também cria gráficos usando coordenadas polares, gráficos de +contorno e gráficos de campos vetoriais (para tipos especiais de +funções). Aqui está um exemplo de gráfico de contorno: + +:: + + sage: f = lambda x,y: cos(x*y) + sage: contour_plot(f, (-4, 4), (-4, 4)) + +Gráficos Tridimensionais +------------------------ + +O Sage pode ser usado para criar gráficos tridimensionais. Tanto no +Sage Notebook, como no console (linha de comando), esses gráficos serão +exibidos usando o software de código aberto [Jmol]_, que permite girar +e ampliar a figura usando o mouse. + +Use ``plot3d`` para criar o gráfico de uma função da forma `f(x, y) = +z`: + +:: + + sage: x, y = var('x,y') + sage: plot3d(x^2 + y^2, (x,-2,2), (y,-2,2)) + +Alternativamente, você pode usar ``parametric_plot3d`` para criar o +gráfico de uma superfície onde cada coordenada `x, y, z` é determinada +por uma função de uma ou duas variáveis (os parâmetros, tipicamente +`u` e `v`). O gráfico anterior pode ser representado parametricamente +na forma: + +:: + + sage: u, v = var('u, v') + sage: f_x(u, v) = u + sage: f_y(u, v) = v + sage: f_z(u, v) = u^2 + v^2 + sage: parametric_plot3d([f_x, f_y, f_z], (u, -2, 2), (v, -2, 2)) + +A terceira forma de fazer um gráfico de uma superfície no Sage é +usando o comando ``implicit_plot3d``, que cria um gráfico de uma +superfície definida por uma equação `f(x, y, z) = 0` (isso define um +conjunto de pontos). Vamos fazer o gráfico de uma esfera usando a +expressão usual: + +:: + + sage: x, y, z = var('x, y, z') + sage: implicit_plot3d(x^2 + y^2 + z^2 - 4, (x,-2, 2), (y,-2, 2), (z,-2, 2)) + +Aqui estão mais alguns exemplos: + +`Yellow Whitney's umbrella `__: + +:: + + sage: u, v = var('u,v') + sage: fx = u*v + sage: fy = u + sage: fz = v^2 + sage: parametric_plot3d([fx, fy, fz], (u, -1, 1), (v, -1, 1), + ... frame=False, color="yellow") + +`Cross cap `__: + +:: + + sage: u, v = var('u,v') + sage: fx = (1+cos(v))*cos(u) + sage: fy = (1+cos(v))*sin(u) + sage: fz = -tanh((2/3)*(u-pi))*sin(v) + sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi), + ... frame=False, color="red") + +Toro retorcido: + +:: + + sage: u, v = var('u,v') + sage: fx = (3+sin(v)+cos(u))*cos(2*v) + sage: fy = (3+sin(v)+cos(u))*sin(2*v) + sage: fz = sin(u)+2*cos(v) + sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi), + ... frame=False, color="red") + +Lemniscata: + +:: + + sage: x, y, z = var('x,y,z') + sage: f(x, y, z) = 4*x^2 * (x^2 + y^2 + z^2 + z) + y^2 * (y^2 + z^2 - 1) + sage: implicit_plot3d(f, (x, -0.5, 0.5), (y, -1, 1), (z, -1, 1)) diff --git a/doc/pt/tutorial/tour_polynomial.rst b/doc/pt/tutorial/tour_polynomial.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_polynomial.rst @@ -0,0 +1,332 @@ +.. _section-poly: + +Polinômios +========== + +Nesta seção vamos ilustrar como criar e usar polinômios no Sage. + + +.. _section-univariate: + +Polinômios em Uma Variável +-------------------------- + +Existem três formas de criar anéis de polinômios. + +:: + + sage: R = PolynomialRing(QQ, 't') + sage: R + Univariate Polynomial Ring in t over Rational Field + +Esse comando cria um anel de polinômios e diz para o Sage usar a letra +'t' para representar a variável indeterminada quando imprimir na tela. +Todavia, isso não define o símbolo ``t`` para uso no Sage, logo você +não pode usá-lo para definir um polinômio (como :math:`t^2+1`) +pertencente a ``R``. + +Uma forma alternativa é + +.. link + +:: + + sage: S = QQ['t'] + sage: S == R + True + +As mesmas observações com respeito a ``t`` valem também nesse caso. + +Uma terceira e conveniente forma de definir polinômios é + +:: + + sage: R. = PolynomialRing(QQ) + +ou + +:: + + sage: R. = QQ['t'] + +ou ainda + +:: + + sage: R. = QQ[] + +Isso tem o efeito colateral de definir a variável ``t`` como a +variável indeterminada do anel de polinômios, logo você pode +facilmente construir elementos de ``R`` da seguinte forma. (Note que +essa terceira alternativa é muito semelhante à notação usada em Magma, +e da mesma forma que no Magma ela pode ser usada para diversos tipos +de objetos.) + +.. link + +:: + + sage: poly = (t+1) * (t+2); poly + t^2 + 3*t + 2 + sage: poly in R + True + +Qualquer que seja o método usado para definir um anel de polinômios, +você pode recuperar a variável indeterminada como o :math:`0`-ésimo +gerador: + +:: + + sage: R = PolynomialRing(QQ, 't') + sage: t = R.0 + sage: t in R + True + +Note que uma construção similar funciona com os números complexos: os +números complexos podem ser vistos como sendo gerados pelo símbolo +``i`` sobre os números reais; logo temos o seguinte: + +:: + + sage: CC + Complex Field with 53 bits of precision + sage: CC.0 # 0th generator of CC + 1.00000000000000*I + +Para anel de polinômios, você pode obter tanto o anel como o seu +gerador, ou somente o gerador, no momento em que o anel for criado, da +seguinte forma: + +:: + + sage: R, t = QQ['t'].objgen() + sage: t = QQ['t'].gen() + sage: R, t = objgen(QQ['t']) + sage: t = gen(QQ['t']) + +Finalmente apresentamos um pouco de aritmética em :math:`\QQ[t]`. + +:: + + sage: R, t = QQ['t'].objgen() + sage: f = 2*t^7 + 3*t^2 - 15/19 + sage: f^2 + 4*t^14 + 12*t^9 - 60/19*t^7 + 9*t^4 - 90/19*t^2 + 225/361 + sage: cyclo = R.cyclotomic_polynomial(7); cyclo + t^6 + t^5 + t^4 + t^3 + t^2 + t + 1 + sage: g = 7 * cyclo * t^5 * (t^5 + 10*t + 2) + sage: g + 7*t^16 + 7*t^15 + 7*t^14 + 7*t^13 + 77*t^12 + 91*t^11 + 91*t^10 + 84*t^9 + + 84*t^8 + 84*t^7 + 84*t^6 + 14*t^5 + sage: F = factor(g); F + (7) * t^5 * (t^5 + 10*t + 2) * (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1) + sage: F.unit() + 7 + sage: list(F) + [(t, 5), (t^5 + 10*t + 2, 1), (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1, 1)] + +Note que a fatorização corretamente leva em conta e armazena a parte +unitária. + +Se você fosse usar, por exemplo, a função ``R.cyclotomic_polynomial`` +intensamente para algum projeto de pesquisa, além de citar o Sage, +você deveria tentar descobrir qual componente do Sage é de fato usado +para calcular esses polinômios, e citá-lo também. Nesse caso, se você +digitar ``R.cyclotomic_polynomial??`` para ver o código fonte, você +irá facilmente ver uma linha ``f = pari.polcyclo(n)`` o que significa +que o PARI é usado para o cálculo dos polinômios ciclotrômicos. Cite o +PARI também no seu trabalho. + +Dividindo dois polinômios cria-se um elemento do corpo de frações (o +qual o Sage cria automaticamente). + +:: + + sage: x = QQ['x'].0 + sage: f = x^3 + 1; g = x^2 - 17 + sage: h = f/g; h + (x^3 + 1)/(x^2 - 17) + sage: h.parent() + Fraction Field of Univariate Polynomial Ring in x over Rational Field + +Usando-se a série de Laurent, pode-se calcular a expansão em série no +corpo de frações de ``QQ[x]``: + +:: + + sage: R. = LaurentSeriesRing(QQ); R + Laurent Series Ring in x over Rational Field + sage: 1/(1-x) + O(x^10) + 1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10) + +Se nomearmos a variável de outra forma, obtemos um anel de polinômios +em uma variável diferente. + +:: + + sage: R. = PolynomialRing(QQ) + sage: S. = PolynomialRing(QQ) + sage: x == y + False + sage: R == S + False + sage: R(y) + x + sage: R(y^2 - 17) + x^2 - 17 + +O anel é determinado pela variável. Note que criar um outro anel com +variável indeterminada ``x`` não retorna um anel diferente. + +:: + + sage: R = PolynomialRing(QQ, "x") + sage: T = PolynomialRing(QQ, "x") + sage: R == T + True + sage: R is T + True + sage: R.0 == T.0 + True + +O Sage também possui suporte para séries de potências e séries de +Laurent sobre um anel arbitrário. No seguinte exemplo, nós criamos um +elemento de :math:`\GF{7}[[T]]` e dividimos para criar um elemento de +:math:`\GF{7}((T))`. + +:: + + sage: R. = PowerSeriesRing(GF(7)); R + Power Series Ring in T over Finite Field of size 7 + sage: f = T + 3*T^2 + T^3 + O(T^4) + sage: f^3 + T^3 + 2*T^4 + 2*T^5 + O(T^6) + sage: 1/f + T^-1 + 4 + T + O(T^2) + sage: parent(1/f) + Laurent Series Ring in T over Finite Field of size 7 + +Você também pode criar anéis de polinômios usando a notação de +colchetes duplos: + +:: + + sage: GF(7)[['T']] + Power Series Ring in T over Finite Field of size 7 + +Polinômios em Mais De Uma Variável +---------------------------------- + +Para trabalhar com polinômios em várias variáveis, nós primeiro +declaramos o anel de polinômios e as variáveis. + +:: + + sage: R = PolynomialRing(GF(5),3,"z") # here, 3 = number of variables + sage: R + Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 + +Da mesma forma como ocorre com polinômios em uma variável, existem +três maneiras de fazer isso: + +:: + + sage: GF(5)['z0, z1, z2'] + Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 + sage: R. = GF(5)[]; R + Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 + +Se você quiser usar os nomes das variáveis com apenas uma letra, então +você pode usar os seguinte comando: + +:: + + sage: PolynomialRing(GF(5), 3, 'xyz') + Multivariate Polynomial Ring in x, y, z over Finite Field of size 5 + +A seguir fazemos um pouco de aritmética. + +:: + + sage: z = GF(5)['z0, z1, z2'].gens() + sage: z + (z0, z1, z2) + sage: (z[0]+z[1]+z[2])^2 + z0^2 + 2*z0*z1 + z1^2 + 2*z0*z2 + 2*z1*z2 + z2^2 + +Você também pode usar uma notação mais matemática para criar um anel +de polinômios. + +:: + + sage: R = GF(5)['x,y,z'] + sage: x,y,z = R.gens() + sage: QQ['x'] + Univariate Polynomial Ring in x over Rational Field + sage: QQ['x,y'].gens() + (x, y) + sage: QQ['x'].objgens() + (Univariate Polynomial Ring in x over Rational Field, (x,)) + +Polinômios em mais de uma variável são implementados no Sage usando +dicionários em Python e a "representação distribuída" de um polinômio. +O Sage usa o Singular [Si]_, por exemplo, para o cálculo do maior +divisor comum e bases de Gröbner para ideais algébricos. + +:: + + sage: R, (x, y) = PolynomialRing(RationalField(), 2, 'xy').objgens() + sage: f = (x^3 + 2*y^2*x)^2 + sage: g = x^2*y^2 + sage: f.gcd(g) + x^2 + +A seguir criamos o ideal :math:`(f,g)` gerado por :math:`f` e +:math:`g`, simplesmente multiplicando ``(f,g)`` por ``R`` (nós +poderíamos também escrever ``ideal([f,g])`` ou ``ideal(f,g)``). + +.. link + +:: + + sage: I = (f, g)*R; I + Ideal (x^6 + 4*x^4*y^2 + 4*x^2*y^4, x^2*y^2) of Multivariate Polynomial + Ring in x, y over Rational Field + sage: B = I.groebner_basis(); B + [x^6, x^2*y^2] + sage: x^2 in I + False + +A base de Gröbner acima não é uma lista mas sim uma sequência +imutável. Isso implica que ela possui universo (universe) e parente +(parent), e não pode ser modificada (o que é bom pois ocasionaria +erros em outras rotinas que usam bases de Gröbner). + +.. link + +:: + + sage: B.parent() + Category of sequences in Multivariate Polynomial Ring in x, y over Rational + Field + sage: B.universe() + Multivariate Polynomial Ring in x, y over Rational Field + sage: B[1] = x + Traceback (most recent call last): + ... + ValueError: object is immutable; please change a copy instead. + +Um pouco (não tanto quanto gostaríamos) de álgebra comutativa está +disponível no Sage, implementado via Singular. Por exemplo, podemos +calcular a decomposição primaria e primos associados de :math:`I`: + +.. link + +:: + + sage: I.primary_decomposition() + [Ideal (x^2) of Multivariate Polynomial Ring in x, y over Rational Field, + Ideal (y^2, x^6) of Multivariate Polynomial Ring in x, y over Rational Field] + sage: I.associated_primes() + [Ideal (x) of Multivariate Polynomial Ring in x, y over Rational Field, + Ideal (y, x) of Multivariate Polynomial Ring in x, y over Rational Field] diff --git a/doc/pt/tutorial/tour_rings.rst b/doc/pt/tutorial/tour_rings.rst new file mode 100644 --- /dev/null +++ b/doc/pt/tutorial/tour_rings.rst @@ -0,0 +1,148 @@ +.. _section-rings: + +Anéis Básicos +============= + +Quando se define matrizes, vetores, ou polinômios, é as vezes útil, e +as vezes necessário, especificar o "anel" sobre o qual o objeto será +definido. Um *anel* é uma estrutura matemática na qual se tem noções +de adição e multiplicação bem definidas; se você nunca ouviu falar +sobre anéis, você provavelmente só precisa saber a respeito dos +seguintes exemplos: + +* os inteiros `\{..., -1, 0, 1, 2,... \}`, que são chamados ``ZZ`` no + Sage. +* os números racionais -- i. e., frações, ou razões, de inteiros -- + que são chamados ``QQ`` no Sage. +* os números reais, chamados de ``RR`` no Sage. +* os números complexos, chamados de ``CC`` no Sage. + +Você pode precisar saber sobre essas distinções porque o mesmo +polinômio, por exemplo, pode ser tratado diferentemente dependendo do +anel sobre o qual está definido. A propósito, o polinômio `x^2-2` +possui duas raízes, `\pm \sqrt{2}`. Essas raízes não são racionais, +logo, se você esta lidando com polinômios com coeficientes racionais, +os polinômios não serão fatorados. Com coeficientes reais, eles serão. +Portanto você pode querer especificar o anel para garantir que você +vai obter a informação que deseja. Os dois comandos a seguir definem +os conjuntos de polinômios com coeficientes racionais e coeficientes +reais, respectivamente. Os conjuntos são chamados "ratpoly" e +"realpoly", mas esses nomes não são importantes aqui; todavia, note +que as strings "." e "." especificam o nome das variáveis +usadas em cada caso. + +:: + + sage: ratpoly. = PolynomialRing(QQ) + sage: realpoly. = PolynomialRing(RR) + +Agora ilustramos a nossa discussão sobre fatorar `x^2-2`: + +.. link + +:: + + sage: factor(t^2-2) + t^2 - 2 + sage: factor(z^2-2) + (z - 1.41421356237310) * (z + 1.41421356237310) + +Comentários similares também se aplicam a matrizes: a forma reduzida +de uma matriz pode depender do anel sobre o qual ela esta definida, +como também pode os seus autovalores e autovetores. Para mais sobre +polinômios, veja :ref:`section-poly`, para mais sobre matrizes, veja +:ref:`section-linalg`. + +O símbolo ``I`` representa a raiz quadrada de :math:`-1`; ``i`` é um +sinônimo de ``I``. Obviamente, isso não é um número racional:: + + sage: i # square root of -1 + I + sage: i in QQ + False + +Nota: O código acima pode não funcionar como esperado se a variável +``i`` estiver atribuída a um outro valor, por exemplo, se ela for +usada como a variável de um laço (loop). Nesse caso, digite:: + + sage: reset('i') + +para restabelecer o valor original de ``i``. + +Há uma sutileza ao definir números complexos: como mencionado acima, +o símbolo ``i`` representa a raiz quadrada de `-1`, mas é uma raiz +quadrada de `-1` *formal* ou *simbólica*. Evocando ``CC(i)`` ou +``CC.0`` obtém-se a raiz de `-1` complexa. Aritmética envolvendo tipos +diferentes de números é possível graças ao que se chama de coação, +veja :ref:`section-coercion`. + +:: + + sage: i = CC(i) # floating point complex number + sage: i == CC.0 + True + sage: a, b = 4/3, 2/3 + sage: z = a + b*i + sage: z + 1.33333333333333 + 0.666666666666667*I + sage: z.imag() # imaginary part + 0.666666666666667 + sage: z.real() == a # automatic coercion before comparison + True + sage: a + b + 2 + sage: 2*b == a + True + sage: parent(2/3) + Rational Field + sage: parent(4/2) + Rational Field + sage: 2/3 + 0.1 # automatic coercion before addition + 0.766666666666667 + sage: 0.1 + 2/3 # coercion rules are symmetric in SAGE + 0.766666666666667 + +Aqui estão mais exemplos de anéis básicos em Sage. Como observado +acima, o anel dos números racionais pode ser referido usando ``QQ``, +ou também ``RationalField()`` (um *corpo*, ou *field* em inglês, é um +anel no qual a operação de multiplicação é comutativa, e todo elemento +não-nulo possui um elemento inverso com respeito à operação de +multiplicação. Logo, os racionais formam um corpo, mas os inteiros +não):: + + sage: RationalField() + Rational Field + sage: QQ + Rational Field + sage: 1/2 in QQ + True + +O número decimal ``1.2`` é considerado como um elemento de ``QQ``: +número decimais que são também racionais podem ser coagidos ao conjunto de +números racionais (veja :ref:`section-coercion`). Os números `\pi` e +`\sqrt{2}` não são racionais, todavia:: + + sage: 1.2 in QQ + True + sage: pi in QQ + False + sage: pi in RR + True + sage: sqrt(2) in QQ + False + sage: sqrt(2) in CC + True + +Para uso em matemática mais avançada, o Sage também pode especificar +outros anéis, como corpos finitos, inteiros `p`-ádicos, o anel dos +números algébricos, anéis de polinômios, e anéis de matrizes. Aqui +está a construção de alguns deles:: + + sage: GF(3) + Finite Field of size 3 + sage: GF(27, 'a') # need to name the generator if not a prime field + Finite Field in a of size 3^3 + sage: Zp(5) + 5-adic Ring with capped relative precision 20 + sage: sqrt(3) in QQbar # algebraic closure of QQ + True