Ticket #12822: trac_12822_pt_translation_of_tutorial_rev1.patch

File trac_12822_pt_translation_of_tutorial_rev1.patch, 21.9 KB (added by goliveira, 8 years ago)
  • doc/pt/tutorial/interactive_shell.rst

    # HG changeset patch
    # User Gustavo de Oliveira <goliveira5d@gmail.com>
    # Date 1336320704 -7200
    # Node ID f35ca5dd36d8ccfeba96947e9e10402f6e6ed79b
    # Parent  ad8e41651a3187a45f087335cb048418bf545506
    Trac 12822: Portuguese translation of "Tutorial" (revision 1).
    
    diff --git a/doc/pt/tutorial/interactive_shell.rst b/doc/pt/tutorial/interactive_shell.rst
    a b  
    361361
    362362Note que o GAP e o Maxima são os mais lentos neste teste (isso foi
    363363executado no computador ``sage.math.washington.edu``). Devido ao
    364 "overhead" da interface pexpect, talvez não seja apropriado comparar
    365 esses resultados com o Sage, que é o mais rápido.
     364processamento extra (overhead) da interface pexpect, talvez não seja
     365apropriado comparar esses resultados com o Sage, que é o mais rápido.
    366366
    367367Outras Dicas para o IPython
    368368===========================
     
    402402
    403403- Você pode usar ``%edit`` (ou ``%ed`` ou ``ed``) para abrir um
    404404  editor, se você desejar digitar algum código mais complexo. Antes de
    405   iniciar o Sage, certifique-se de que a variável de environment
     405  iniciar o Sage, certifique-se de que a variável de ambiente
    406406  :envvar:`EDITOR` está definida com o seu editor favorito (colocando
    407407  ``export EDITOR=/usr/bin/emacs`` ou ``export EDITOR=/usr/bin/vim``
    408408  or algo similar no lugar apropriado, como um arquivo ``.profile``).
     
    789789    sage: v = E.anlist(100000)              # instant!
    790790
    791791(Em Python, salvar e restaurar é feito usando o módulo ``cPickle``. Em
    792 particular, um objeto ``x`` do Sage pode ser salvado usando
     792particular, um objeto ``x`` do Sage pode ser salvo usando
    793793``cPickle.dumps(x, 2)``. Note o ``2``!)
    794794
    795795O sage não pode salvar e carregar objetos criados em algum outro
     
    811811    ValueError: The session in which this object was defined is no longer
    812812    running.
    813813
    814 Objetos do GP/PARI também podem ser salvados e carregados pois suas
     814Objetos do GP/PARI também podem ser salvos e carregados pois suas
    815815representações em forma impressa são suficientes para reconstruí-los.
    816816
    817817.. skip
     
    823823    sage: load('a')
    824824    2
    825825
    826 Objetos que foram salvados podem ser abertos posteriormente em
     826Objetos que foram salvos podem ser abertos posteriormente em
    827827computadores com arquiteturas e sistemas operacionais diferentes, por
    828828exemplo, você poderia salvar uma matriz muito grande em um OS X de
    82982932-bits e abri-lo em um Linux de 64-bits, encontrar a forma reduzida,
     
    868868``sessionname``. (No caso raro de uma variável não poder ser salva,
    869869ela simplesmente não aparece no dicionário.) O resultado é um arquivo
    870870``.sobj`` que pode ser aberto como qualquer outro objeto que foi
    871 salvado. Quando você abre os objetos que foram salvados em uma sessão,
     871salvo. Quando você abre os objetos que foram salvos em uma sessão,
    872872você obtém um dicionário cujas chaves (keys) são os nomes das
    873873variáveis e os valores são os objetos.
    874874
     
    954954    sage: notebook()
    955955
    956956na linha de comando do Sage. Isso inicia o Notebook e abre o seu
    957 browser padrão para visualizá-lo. Os arquivos de estado do servidor
     957navegador padrão para visualizá-lo. Os arquivos de estado do servidor
    958958são armazenados em ``$HOME/.sage/sage\_notebook``.
    959959
    960960Outras opções incluem:
  • doc/pt/tutorial/interfaces.rst

    diff --git a/doc/pt/tutorial/interfaces.rst b/doc/pt/tutorial/interfaces.rst
    a b  
    4848    Mod(5, 10007)
    4949
    5050No primeiro caso, uma cópia separada do interpretador GP é iniciada
    51 como um servidor, e a string ``´znprimroot(10007)'`` é enviada,
     51como um servidor, e a string ``znprimroot(10007)`` é enviada,
    5252calculada pelo GP, e o resultado é armazenado em uma variável no GP
    5353(que ocupa espaço na memória dos processos do GP que não serão
    5454liberados). Então o valor dessa variável é exibido. No segundo caso,
    55 nenhum programa separado é iniciado, e a string
    56 ``´znprimroot(10007)'`` é calculada por uma certa função da biblioteca
    57 C do PARI. O resultado é armazenado na memória em uso pelo Python, que
    58 é liberada quando a variável não for mais referenciada. Os objetos
    59 possuem tipos diferentes:
     55nenhum programa separado é iniciado, e a string ``znprimroot(10007)``
     56é calculada por uma certa função da biblioteca C do PARI. O resultado
     57é armazenado na memória em uso pelo Python, que é liberada quando a
     58variável não for mais referenciada. Os objetos possuem tipos
     59diferentes:
    6060
    6161::
    6262
     
    187187========
    188188
    189189O Singular fornece uma biblioteca massiva e madura para bases de
    190 Gröbner, máximo divisor comum para poliômios em várias variaveis,
     190Gröbner, máximo divisor comum para polinômios em várias variáveis,
    191191bases de espaços de Riemann-Roch de uma curva plana, e fatorização,
    192192entre outras coisas. Vamos ilustrar a fatorização de polinômios em
    193193várias variáveis usando a interface do Sage para o Singular (não
  • doc/pt/tutorial/introduction.rst

    diff --git a/doc/pt/tutorial/introduction.rst b/doc/pt/tutorial/introduction.rst
    a b  
    6868principal do Sage [SA]_ para instruções de como instalar o Sage no seu
    6969computador. Aqui faremos apenas alguns comentários.
    7070
    71 #. O arquivo para download do Sage vem com "baterias incluídas". Em
     71#. O arquivo para instalação do Sage vem com "baterias incluídas". Em
    7272   outras palavras, embora o Sage use o Python, IPython, PARI, GAP,
    7373   Singular, Maxima, NTL, GMP, e uma série de outros programas, você
    7474   não precisa instalá-los separadamente pois eles estão incluídos no
  • doc/pt/tutorial/latex.rst

    diff --git a/doc/pt/tutorial/latex.rst b/doc/pt/tutorial/latex.rst
    a b  
    3131
    3232#. A interface Notebook é configurada para usar o `jsMath
    3333   <http://www.math.union.edu/~dpvc/jsMath/>`_ para representar
    34    fórmulas matemáticas de forma clara em um web browser. O jsMath é
     34   fórmulas matemáticas de forma clara em um web navegador. O jsMath é
    3535   uma coleção de rotinas em JavaScript e fontes associadas.
    3636   Tipicamente esses fontes ficam armazenadas em um servidor e são
    37    enviadas para o browser juntamente com a página onde elas estão
     37   enviadas para o navegador juntamente com a página onde elas estão
    3838   sendo usadas. No caso do Sage, o Notebook está sempre conectado a
    3939   um servidor usado para executar os comando do Sage, e esse servidor
    4040   também fornece as fontes do jsMath necessárias. Logo não é
    4141   necessário configurar nada mais para ter formulas matemáticas
    42    representadas no seu browser quando você usa o Notebook do Sage.
     42   representadas no seu navegador quando você usa o Notebook do Sage.
    4343
    4444   O jsMath é implementado para representar um subconjunto grande,
    4545   mas não completo, do TeX. Ele não suporta objetos como, por
     
    154154Um segundo recurso disponível no Notebook é possibilidade de inserir
    155155código TeX para fazer anotações na folha de trabalho. Quando o cursos
    156156esta posicionado entre células de modo que uma barra azul fica
    157 visível, então shift-click irá abrir um mini processador de texto,
     157visível, então shift+clique irá abrir um mini processador de texto,
    158158TinyMCE. Isso permite digitar texto, usando um editor WSISYG para
    159159criar HTML e CSS. Logo é possível inserir texto formatado para
    160160complementar a folha de trabalho. Todavia, texto entre símbolos $, ou
     
    176176usado para alterar a notação de matrizes -- parênteses grandes,
    177177colchetes, barras verticais. Nenhuma noção de estilo é enfatizada,
    178178você pode configurar como desejado. Observe como as barras invertidas
    179 usadas em LaTeX requerem uma barra adicional de modo que elas possam
    180 ser interpretadas (escaped) corretamente em uma string do Python. ::
     179usadas em LaTeX requerem uma barra adicional para que elas não sejam
     180interpretadas pelo Python como um comando (ou seja, sejam implementadas
     181simplesmente como parte de uma string. ::
    181182
    182183    sage: A = matrix(ZZ, 2, 2, range(4))
    183184    sage: latex(A)
     
    217218    <html><div class="math">\newcommand{\Bold}[1]{\mathbb{#1}}\Bold{Q}</div></html>
    218219    sage: latex.blackboard_bold(False)
    219220
    220 É possível aproveitar os recursos do TeX adicionando novas macros e
    221 novos pacotes. Primeiro, macros individuais podem ser adicionadas para
    222 serem usadas quando o jsMath interpreta pequenos trechos de códigos
    223 TeX no Notebook. ::
     221É possível aproveitar os recursos do TeX adicionando novas funções
     222(macros em inglês) e novos pacotes. Primeiro, funções individuais podem
     223ser adicionadas para serem usadas quando o jsMath interpreta pequenos
     224trechos de códigos TeX no Notebook. ::
    224225
    225226    sage: latex.extra_macros()
    226227    ''
     
    436437Para uma experiência semelhante no Notebook, é necessário desabilitar
    437438o processador jsMath para o código LaTeX do grafo usando a "lista de
    438439comandos a serem evitados pelo jsMath". Grafos são criados usando o
    439 environment ``tikzpicture``, logo essa uma boa escolha para uma string
     440ambiente ``tikzpicture``, logo essa uma boa escolha para uma string
    440441a ser incluída na lista que acabamos de mencionar. Agora,
    441442``view(graphs.CompleteGraph(4))`` em uma folha de trabalho deve
    442443executar o pdflatex para criar um PDF e então o programa ``convert``
     
    486487
    487488Existem três programas disponíveis para integrar ainda mais o TeX e o
    488489Sage. O primeiro é o sagetex. Uma descrição concisa do sagetex é que
    489 ele é uma coleção de macros do TeX que permitem incluir em um
     490ele é uma coleção de funções do TeX que permitem incluir em um
    490491documento LaTeX instruções para usar o Sage para calcular vários
    491492objetos, e/ou formatar objetos usando o comando ``latex()`` existente
    492493no Sage. Logo, como um passo intermediário para compilar um documento
     
    496497sagetex para fazer cálculos com o Sage. Veja :ref:`sec-sagetex` para
    497498mais informações.
    498499
    499 O tex2sws começa com um documento LaTeX, mas define environments
     500O tex2sws começa com um documento LaTeX, mas define ambientes
    500501adicionais para inserir código em Sage. Quando processado com as
    501502ferramentas adequadas, o resultado é uma folha de trabalho do Sage,
    502503com conteúdo apropriadamente formatado para o jsMath e com código em
  • doc/pt/tutorial/programming.rst

    diff --git a/doc/pt/tutorial/programming.rst b/doc/pt/tutorial/programming.rst
    a b  
    6666(Em Python, ``^`` significa "ou exclusivo" e ``**`` significa
    6767"exponenciação".)
    6868
    69 Esse "preparsing" está implementado em ``sage/misc/interpreter.py``.)
     69Esse "" está implementado em ``sage/misc/interpreter.py``.)
    7070
    7171Você pode colar código tabulado com muitas linhas no Sage desde que
    7272existam linhas em branco separando blocos de código (isso não é
     
    130130em ``$HOME/.sage/temp/hostname/pid/spyx``. Esses arquivos são
    131131excluídos quando você encerra o Sage.
    132132
    133 Nenhum pré-processador (preparsing) é aplicado em arquivos spyx, por
     133Nenhum pré-processamento (preparsing) é aplicado em arquivos spyx, por
    134134exemplo, ``1/3`` vai resultar em 0 em um arquivo spyx em vez do número
    135135racional :math:`1/3`. Se ``foo`` é uma função da biblioteca Sage, para
    136136usá-la em um arquivo spyx importe ``sage.all`` e use ``sage.all.foo``.
     
    456456Dicionários
    457457===========
    458458
    459 Um dicionário (também chamado as vezes de lista associativa) é um
    460 mapeamento de objetos "hashable" em objetos arbitrários. (Exemplos de
    461 objetos "hashable" são strings e números; veja a documentação Python
    462 em http://docs.python.org/tut/node7.html e
     459Um dicionário (também chamado as vezes de lista associativa ou "hash
     460table") é um mapeamento de objetos em objetos arbitrários. (Exemplos
     461de objetos que admitem uma lista associativa são strings e números;
     462veja a documentação Python em http://docs.python.org/tut/node7.html e
    463463http://docs.python.org/lib/typesmapping.html para detalhes).
    464464
    465465::
     
    502502Conjuntos
    503503=========
    504504
    505 O Python possui um tipo set (conjuntos) nativo. O principal recurso
     505O Python possui um tipo de conjuntos (set) nativo. O principal recurso
    506506que ele oferece é a rápida verificação se um objeto está ou não em um
    507507conjunto, juntamente com as operações comuns em conjuntos.
    508508
  • doc/pt/tutorial/sagetex.rst

    diff --git a/doc/pt/tutorial/sagetex.rst b/doc/pt/tutorial/sagetex.rst
    a b  
    8888que tudo que foi calculado, incluindo os gráficos, foi incluído em seu
    8989documento.
    9090
    91 As macros utilizadas acima devem ser fáceis de entender. Um
    92 environment ``sageblock`` insere código "verbatim" (exatamente como é
    93 digitado) e também executa o código quando você executa o Sage. Quando
    94 você insere ``\sage{foo}``, é incluído em seu documento o resultado
    95 que você obteria executando ``latex(foo)`` no Sage. Comandos para
    96 fazer gráficos são um pouco mais complicados, mas em sua forma mais
    97 simples, ``\sageplot{foo}`` insere a imagem que você obtêm usando
    98 ``foo.save('filename.eps')``.
     91As funções (macros em inglês) utilizadas acima devem ser fáceis de
     92entender. Um ambiente ``sageblock`` insere código "verbatim"
     93(exatamente como é digitado) e também executa o código quando você
     94executa o Sage. Quando você insere ``\sage{foo}``, é incluído em seu
     95documento o resultado que você obteria executando ``latex(foo)`` no
     96Sage. Comandos para fazer gráficos são um pouco mais complicados, mas
     97em sua forma mais simples, ``\sageplot{foo}`` insere a imagem que você
     98obtêm usando ``foo.save('filename.eps')``.
    9999
    100100Em geral, a rotina é a seguinte:
    101101
  • doc/pt/tutorial/tour_advanced.rst

    diff --git a/doc/pt/tutorial/tour_advanced.rst b/doc/pt/tutorial/tour_advanced.rst
    a b  
    8484funcionalidade para curvas elípticas do PARI, acesso aos dados da base
    8585de dados Cremona (isso requer um pacote adicional), os recursos do
    8686mwrank, isto é, "2-descends" com cálculos do grupo de Mordell-Weil
    87 completo, o algoritmo SEA (singla em inglês), cálculo de todas as
     87completo, o algoritmo SEA (sigla em inglês), cálculo de todas as
    8888isogenias, bastante código novo para curvas sobre :math:`\QQ`, e parte
    8989do software "algebraic descent" de Denis Simons.
    9090
     
    9898   .. math::  y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6,
    9999
    100100
    101    onde os :math:`a_i`'s são coagidos para os parentes de :math:`a_1`.
     101   onde os :math:`a_i`'s são coagidos para a família de :math:`a_1`.
    102102   Se todos os :math:`a_i` possuem parente :math:`\ZZ`, então eles são
    103103   coagidos para :math:`\QQ`.
    104104
  • doc/pt/tutorial/tour_assignment.rst

    diff --git a/doc/pt/tutorial/tour_assignment.rst b/doc/pt/tutorial/tour_assignment.rst
    a b  
    8181    sage: numerical_approx(pi, prec=200)
    8282    3.1415926535897932384626433832795028841971693993751058209749
    8383
    84 O Python é uma linguagem "dinâmicamente digitada" (dynamically typed),
    85 portanto o valor referido por cada variável possui um tipo associado a
    86 ele, mas uma variável pode possuir valores de qualquer tipo em
    87 determinado escopo:
     84O Python é uma linguagem de tipagem dinâmica, portanto o valor
     85referido por cada variável possui um tipo associado a ele, mas uma
     86variável pode possuir valores de qualquer tipo em determinado escopo:
    8887
    8988::
    9089
     
    9897    sage: type(a)
    9998    <type 'str'>
    10099
    101 A linguagem de programação C, que é "estaticamente digitada"
    102 (statically typed), é muito diferente; uma variável que foi declarada
    103 como int pode apenas armazenar um int em seu escopo.
     100A linguagem de programação C, que é de tipagem estática , é muito
     101diferente; uma variável que foi declarada como int pode apenas
     102armazenar um int em seu escopo.
    104103
    105104Uma potencial fonte de confusão em Python é que um inteiro literal que
    106105começa com zero é tratado como um número octal, isto é, um número na
  • doc/pt/tutorial/tour_coercion.rst

    diff --git a/doc/pt/tutorial/tour_coercion.rst b/doc/pt/tutorial/tour_coercion.rst
    a b  
    33.. _section-coercion:
    44
    55============================
    6 Parentes, Conversão e Coação
     6Famílias, Conversão e Coação
    77============================
    88
    99Esta seção pode parecer mais técnica do que as anteriores, mas
    10 acreditamos que é importante entender o significado de parentes e
     10acreditamos que é importante entender o significado de famílias e
    1111coação de modo a usar anéis e outras estruturas algébricas no Sage de
    1212forma efetiva e eficiente.
    1313
     
    2525``__mul__``, obviamente garantindo que os axiomas de anel são
    2626verificados.
    2727
    28 Como o Python é uma linguagem "strongly typed" (ainda que "dynamically
    29 typed"), poderia-se, pelo menos a princípio, esperar-se que fosse
     28Como o Python é uma linguagem de tipagem forte (ainda que de tipagem
     29dinâmica), poderia-se, pelo menos a princípio, esperar-se que fosse
    3030implementado em Python uma classe para cada anel. No final das contas,
    3131o Python contém um tipo ``<int>`` para os inteiros, um tipo
    3232``<float>`` para os reais, e assim por diante. Mas essa estratégia
     
    8787    Univariate Polynomial Ring in c over Integer Ring (using NTL)
    8888
    8989
    90 Parentes e Categorias
     90Famílias e Categorias
    9191---------------------
    9292
    9393De forma similar à hierarquia de classes em Python voltada para
     
    137137gerais independentemente de uma implementação específica nas
    138138categorias.
    139139
    140 Estruturas parentes em Sage são supostamente objetos únicos em Python.
    141 Por exemplo, uma vez que um anel de polinômios sobre um certo anel
    142 base e com uma certa lista de geradores é criada, o resultado é
    143 arquivado:
     140Estruturas da mesma família em Sage são supostamente objetos únicos em
     141Python. Por exemplo, uma vez que um anel de polinômios sobre um certo anel
     142base e com uma certa lista de geradores é criada, o resultado é arquivado:
    144143
    145144::
    146145
     
    163162    sage: isinstance(M, RingElement)
    164163    True
    165164
    166 Enquanto *parentes* são únicos, elementos iguais de um parente em Sage
     165Enquanto *famílias* são únicas, elementos iguais de uma família em Sage
    167166não são necessariamente idênticos. Isso contrasta com o comportamento
    168167do Python para alguns (embora não todos) inteiros:
    169168
     
    177176    False
    178177
    179178É importante observar que elementos de anéis diferentes em geral não
    180 podem ser distinguidos pelos seus tipos, mas sim por seus parentes:
     179podem ser distinguidos pelos seus tipos, mas sim por sua família:
    181180
    182181::
    183182
     
    203202O leitor pode conhecer as noções de *conversão de tipo* e *coação de
    204203tipo* como na linguagem C, por exemplo. Existem noções de *conversão*
    205204e *coação* em Sage também. Mas as noções em Sage são centradas em
    206 *parentes*, não em tipos. Então, por favor não confunda conversão de
     205*família*, não em tipos. Então, por favor não confunda conversão de
    207206tipo em C com conversão em Sage!
    208207
    209208Aqui se encontra uma breve apresentação. Para uma descrição detalhada
     
    227226  permitidas. O elemento neutro da multiplicação existe em todos os
    228227  corpos e em vários anéis, e eles devem ser todos iguais.
    229228
    230 O Sage faz uma concessão. Se ``P1`` e ``P2`` são estruturas parentes e
    231 ``p1`` é um elemento de ``P1``, então o usuário pode explicitamente
    232 perguntar por uma interpretação de ``p1`` em ``P2``. Isso pode não
    233 fazer sentido em todos os casos ou não estar definido para todos os
    234 elementos de ``P1``, e fica a cargo do usuário assegurar que isso faz
    235 sentido. Nos referimos a isso como **conversão**:
     229O Sage faz uma concessão. Se ``P1`` e ``P2`` são estruturas da mesma família
     230e ``p1`` é um elemento de ``P1``, então o usuário pode explicitamente
     231perguntar por uma interpretação de ``p1`` em ``P2``. Isso pode não fazer
     232sentido em todos os casos ou não estar definido para todos os elementos de
     233``P1``, e fica a cargo do usuário assegurar que isso faz sentido. Nos
     234referimos a isso como **conversão**:
    236235
    237236::
    238237
     
    283282    sage: R2(y)
    284283    y
    285284
    286 Se não existir homomorfismo de anel que preserve nomes, coerção não é
     285Se não existir homomorfismo de anel que preserve nomes, coação não é
    287286definida. Todavia, conversão pode ainda ser possível, a saber,
    288287mapeando geradores de anel de acordo com sua posição da lista de
    289288geradores:
     
    309308Se houver coação, ela será usada para comparar elementos de anéis
    310309diferentes ou fazer aritmética. Isso é frequentemente conveniente, mas
    311310o usuário deve estar ciente que estender a relação ``==`` além das
    312 fronteiras de parentes diferentes pode facilmente resultar em
     311fronteiras de famílias diferentes pode facilmente resultar em
    313312problemas. Por exemplo, enquanto ``==`` é supostamente uma relação de
    314313equivalência sobre os elementos de *um* anel, isso não é
    315314necessariamente o caso se anéis *diferentes* estão envolvidos. Por
     
    360359    sage: 1/10^200+1/10^100 == 1/10^100
    361360    False
    362361
    363 Quando se compara elementos de dois parentes ``P1`` e ``P2``, é
     362Quando se compara elementos de duas famílias ``P1`` e ``P2``, é
    364363possível que não haja coação entre os dois anéis, mas existe uma
    365364escolha canônica de um parente ``P3`` de modo que tanto ``P1`` como
    366365``P2`` são coagidos em ``P3``. Nesse caso, coação vai ocorrer também.
     
    381380Note que a princípio o resultado deveria também fazer sentido no
    382381corpo de frações de ``ZZ['x']``. Todavia, o Sage tenta escolher um
    383382parente *canônico* comum que parece ser o mais natural (``QQ['x']`` no
    384 nosso exemplo). Se vários potenciais parentes comuns parecem
     383nosso exemplo). Se várias famílias potencialmente comuns parecem
    385384igualmente naturais, o Sage *não* vai escolher um deles
    386385aleatoriamente. Os mecanismos sobre os quais essa escolha se baseia é
    387386explicado em um `arquivo tutorial
     
    401400A razão é que o Sage não escolhe um dos potenciais candidatos
    402401``QQ['x']['y']``, ``QQ['y']['x']``, ``QQ['x','y']`` ou
    403402``QQ['y','x']``, porque todas essas estruturas combinadas em pares
    404 diferentes parecem ser parentes comuns naturais, e não existe escolha
     403diferentes parecem ser de famílias comuns naturais, e não existe escolha
    405404canônica aparente.