.. _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 processamento extra (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 ambiente :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 (Fevereiro 2015), o Sage usa a versão 2.3.0 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 salvo 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 salvos 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 salvos 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 salvo. Quando você abre os objetos que foram salvos 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 ======================= Esta seção refere-se ao notebook Sage legado, ou "sagenb". Consulte a `documentação da sagenb `_ para obter maiores detalhes. SageMath está em transição para uso do `Jupyter `_ como padrão, que tem uma estrutura diferente. A diferença mais importante para os usuários é que as planilhas individuais no Jupyter são salvas no seu sistema local (como qualquer outro arquivo é salvo), enquanto que no tipo de notebook anterior Sage (ou sagenb) o principal ponto de acesso está nos arquivos descritos abaixo através do servidor. Notebook Sage legado -------------------- O Sage Notebook é iniciado digitando .. skip :: sage: notebook() na linha de comando do Sage. Isso inicia o Notebook e abre o seu navegador padrão para visualizá-lo. Os arquivos de estado do servidor são armazenados em ``$HOME/.sage/sage\_notebook.sagenb``. Outras opções incluem: .. skip :: sage: notebook("directory") a qual inicia um novo servidor para o Notebook usando arquivos em um dado diretório ``directory.sagenb``, em vez do diretório padrão ``$HOME/.sage/sage_notebook.sagenb``. 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.sagenb``: :: conf.pickle openid.pickle twistedconf.tac sagenb.pid users.pickle home/admin/ home/guest/ home/pub/ 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 ``home/username/number``. Em cada diretório desse há um arquivo texto ``worksheet.html`` - 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``.