<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Интерактивная оболочка — Sage Tutorial in Russian v5.9</title>
<link rel="stylesheet" href="_static/sage.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '',
VERSION: '5.9',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/translations.js"></script>
<link rel="shortcut icon" href="_static/favicon.ico"/>
<link rel="top" title="Sage Tutorial in Russian v5.9" href="index.html" />
<link rel="next" title="Интерфейсы" href="interfaces.html" />
<link rel="prev" title="Немного высшей математики" href="tour_advanced.html" />
<link rel="icon" href="_static/sageicon.png" type="image/x-icon" />
</head>
<body>
<div class="related">
<h3>Просмотр</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Словарь-указатель"
accesskey="I">словарь</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>модули</a> |</li>
<li class="right" >
<a href="interfaces.html" title="Интерфейсы"
accesskey="N">следующий</a> |</li>
<li class="right" >
<a href="tour_advanced.html" title="Немного высшей математики"
accesskey="P">предыдущий</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Sage Tutorial in Russian v5.9</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="chapter-interactive-shell">
<span id="id1"></span><h1>Интерактивная оболочка<a class="headerlink" href="#chapter-interactive-shell" title="Ссылка на этот заголовок">¶</a></h1>
<p>Почти всегда в этом руководстве мы предполагаем, что интерпретатор
Sage был запущен командой <tt class="docutils literal"><span class="pre">sage</span></tt>. Она запустит специальную версию
консоли IPython и импортирует множество функций и классов, так что
они готовы для использования в командной строке. Более тонкая настройка
производится редактированием файла <tt class="docutils literal"><span class="pre">$SAGE_ROOT/ipythonrc</span></tt>. При запуске
Sage вы увидите вывод, похожий на следующий:</p>
<div class="highlight-python"><pre>----------------------------------------------------------------------
| SAGE Version 3.1.1, Release Date: 2008-05-24 |
| Type notebook() for the GUI, and license() for information. |
----------------------------------------------------------------------
sage:</pre>
</div>
<p>Чтобы выйти из Sage, нажмите Ctrl-D или введите <tt class="docutils literal"><span class="pre">quit</span></tt> или <tt class="docutils literal"><span class="pre">exit</span></tt>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: quit</span>
<span class="go">Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s)</span>
</pre></div>
</div>
<p>Wall time — это прошедшее время. Это значение верно, потому как в “CPU time”
не входит время, использованное субпроцессами вроде GAP или Singular.</p>
<p>(Постарайтесь не убивать процесс Sage командой <tt class="docutils literal"><span class="pre">kill</span> <span class="pre">-9</span></tt> из терминала,
потому что Sage может не убить дочерние процессы, такие как Maple, или может
не очистить временные файлы из директории <tt class="docutils literal"><span class="pre">$HOME/.sage/tmp</span></tt>.)</p>
<div class="section" id="sage">
<h2>Ваша сессия Sage<a class="headerlink" href="#sage" title="Ссылка на этот заголовок">¶</a></h2>
<p>Сессия — это последовательность вводов и выводов начиная с запуска программы
и заканчивая выходом из нее. Sage заносит всю историю вводов в log-файл,
используя IPython. Если вы используете интерактивную оболочку (не веб-интерфейс
Notebook), то вы можете ввести <tt class="docutils literal"><span class="pre">%hist</span></tt>, чтобы вывести список всех введенных
команд. Вы можете ввести <tt class="docutils literal"><span class="pre">?</span></tt> в командной строке Sage, чтобы получить больше
информации о IPython, например,
“IPython предоставляет пронумерованные командные строки... с кешированием ввода и вывода. Все введенные данные сохраняются и могут быть использованы как переменные (помимо обычного вызова с помощью стрелок). Следующие глобальные переменные присутствуют всегда (не перезаписывайте их!)”:</p>
<div class="highlight-python"><pre>_: previous input (interactive shell and notebook)
__: next previous input (interactive shell only)
_oh : list of all inputs (interactive shell only)</pre>
</div>
<p>Пример:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: factor(100)</span>
<span class="go"> _1 = 2^2 * 5^2</span>
<span class="go">sage: kronecker_symbol(3,5)</span>
<span class="go"> _2 = -1</span>
<span class="go">sage: %hist # Работает только в интерактивной оболочке, но не в Sage notebook.</span>
<span class="go">1: factor(100)</span>
<span class="go">2: kronecker_symbol(3,5)</span>
<span class="go">3: %hist</span>
<span class="go">sage: _oh</span>
<span class="go"> _4 = {1: 2^2 * 5^2, 2: -1}</span>
<span class="go">sage: _i1</span>
<span class="go"> _5 = 'factor(ZZ(100))\n'</span>
<span class="go">sage: eval(_i1)</span>
<span class="go"> _6 = 2^2 * 5^2</span>
<span class="go">sage: %hist</span>
<span class="go">1: factor(100)</span>
<span class="go">2: kronecker_symbol(3,5)</span>
<span class="go">3: %hist</span>
<span class="go">4: _oh</span>
<span class="go">5: _i1</span>
<span class="go">6: eval(_i1)</span>
<span class="go">7: %hist</span>
</pre></div>
</div>
<p>Мы не включаем номера строк в этом учебном пособии и в другой документации Sage.</p>
<p>Вы также можете хранить список введенных команд сессии в виде макроса для сессии.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: E = EllipticCurve([1,2,3,4,5])</span>
<span class="go">sage: M = ModularSymbols(37)</span>
<span class="go">sage: %hist</span>
<span class="go">1: E = EllipticCurve([1,2,3,4,5])</span>
<span class="go">2: M = ModularSymbols(37)</span>
<span class="go">3: %hist</span>
<span class="go">sage: %macro em 1-2</span>
<span class="go">Macro `em` created. To execute, type its name (without quotes).</span>
</pre></div>
</div>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: E</span>
<span class="go">Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over</span>
<span class="go">Rational Field</span>
<span class="go">sage: E = 5</span>
<span class="go">sage: M = None</span>
<span class="go">sage: em</span>
<span class="go">Executing Macro...</span>
<span class="go">sage: E</span>
<span class="go">Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over</span>
<span class="go">Rational Field</span>
</pre></div>
</div>
<p>При использовании интерактивной оболочки Sage, любая UNIX-команда может быть
запущена с помощью префикса <tt class="docutils literal"><span class="pre">!</span></tt>. Например</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: !ls</span>
<span class="go">auto example.sage glossary.tex t tmp tut.log tut.tex</span>
</pre></div>
</div>
<p>возвращает содержание текущей директории.</p>
<p>Переменная <tt class="docutils literal"><span class="pre">PATH</span></tt> сожержит директорию bin (бинарные файлы) в самом начале,
так что если вы запускаете <tt class="docutils literal"><span class="pre">gp</span></tt>, <tt class="docutils literal"><span class="pre">gap</span></tt>, <tt class="docutils literal"><span class="pre">singular</span></tt>, <tt class="docutils literal"><span class="pre">maxima</span></tt>, и т.д.
вы получаете версии, включенные в Sage.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: !gp</span>
<span class="go">Reading GPRC: /etc/gprc ...Done.</span>
<span class="go"> GP/PARI CALCULATOR Version 2.2.11 (alpha)</span>
<span class="go"> i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version</span>
<span class="gp">...</span>
<span class="go">sage: !singular</span>
<span class="go"> SINGULAR / Development</span>
<span class="go"> A Computer Algebra System for Polynomial Computations / version 3-0-1</span>
<span class="go"> 0<</span>
<span class="go"> by: G.-M. Greuel, G. Pfister, H. Schoenemann \ October 2005</span>
<span class="go">FB Mathematik der Universitaet, D-67653 Kaiserslautern \</span>
</pre></div>
</div>
</div>
<div class="section" id="id2">
<h2>Журналирование ввода и вывода<a class="headerlink" href="#id2" title="Ссылка на этот заголовок">¶</a></h2>
<p>Журналирование сессии Sage это не то же самое, что сохрнанение
сессии (см. <a class="reference internal" href="#section-save"><em>Сохранение и загрузка полных сессий</em></a> для этого). Для журналирования ввода (и, опционально,
вывода), используйте команду <tt class="docutils literal"><span class="pre">logstart</span></tt>. Введите <tt class="docutils literal"><span class="pre">logstart?</span></tt> для подробностей.
Вы можете использовать эту команду для журналирования всего, что вы вводите, всего
вывода, и даже можете воспроизвести введенные данные в будущей сессии (просто
загрузив log-файл).</p>
<div class="highlight-python"><pre>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 <setup> one line at a time...
Finished replaying log file <setup>
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)]</pre>
</div>
<p>Если вы используете Sage в <tt class="docutils literal"><span class="pre">konsole</span></tt> — терминале среды KDE в GNU/Linux —
тогда вы можете сохранить сессию следующим образом: после запуска Sage в
<tt class="docutils literal"><span class="pre">konsole</span></tt>, выберите “settings”, потом “history...”, потом “set unlimited”.
Когда вы готовы сохранить сессию, выберите “edit” и “save history as...” и
введите имя файла для сохранения. После этого вы можете воспользоваться
любым текстовым редактором, например xemacs, для чтения файла.</p>
</div>
<div class="section" id="id3">
<h2>Вставка игнорирует приглашение<a class="headerlink" href="#id3" title="Ссылка на этот заголовок">¶</a></h2>
<p>Допустим, вы читаете сессию Sage или вычисления Python, и хотите скопировать
их в Sage. Но есть одна проблема: знаки <tt class="docutils literal"><span class="pre">>>></span></tt> или <tt class="docutils literal"><span class="pre">sage:</span></tt>. На самом деле
вы можете копировать и вставлять примеры, которые включают эти знаки. Дргуими
словами, Sage игнорирует символы <tt class="docutils literal"><span class="pre">>>></span></tt> или <tt class="docutils literal"><span class="pre">sage:</span></tt> перед отправкой команд
в Python. Например,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 2^10</span>
<span class="go">1024</span>
<span class="go">sage: sage: sage: 2^10</span>
<span class="go">1024</span>
<span class="go">sage: >>> 2^10</span>
<span class="go">1024</span>
</pre></div>
</div>
</div>
<div class="section" id="id4">
<h2>Команды измерения времени<a class="headerlink" href="#id4" title="Ссылка на этот заголовок">¶</a></h2>
<p>Если вы введете команду <tt class="docutils literal"><span class="pre">%time</span></tt> в начале строки ввода, то время,
затраченное на выполнение операции, будет выведено на экран. Например, вы
можете измерить время выполнения операции возведения в степень несколькими
путями. Показания ниже будут отличаться от ваших; они могут отличаться даже
в разных версиях Sage. Чистый Python:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %time a = int(1938)^int(99484)</span>
<span class="go">CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s</span>
<span class="go">Wall time: 0.66</span>
</pre></div>
</div>
<p>Это означает что 0.66 секунд было затрачено в сумме, а “Wall time”,
(прошедшее время), тоже 0.66 секунд. Если ваш компьютер сильно загружен
другими процессами, то “Wall time” может сильно отличаться от процессорного
времени.</p>
<p>Далее мы посчитаем время возведения в степень с использованием встроенного в
Sage целочисленного типа данных, реализованного (в Cython) с использованием
библиотеки GMP:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %time a = 1938^99484</span>
<span class="go">CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s</span>
<span class="go">Wall time: 0.04</span>
</pre></div>
</div>
<p>Используя интерфейс PARI из библиотеки C:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %time a = pari(1938)^pari(99484)</span>
<span class="go">CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s</span>
<span class="go">Wall time: 0.05</span>
</pre></div>
</div>
<p>GMP ведет себя лучше, но только немного (как и ожидалось, ведь версия PARI,
встроенная в Sage, использует GMP для работы с целыми числами).</p>
<p>Вы также можете замерить время выполнения блока команд с помощью <tt class="docutils literal"><span class="pre">cputime</span></tt>,
как показано ниже:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: t = cputime()</span>
<span class="go">sage: a = int(1938)^int(99484)</span>
<span class="go">sage: b = 1938^99484</span>
<span class="go">sage: c = pari(1938)^pari(99484)</span>
<span class="go">sage: cputime(t) # random output</span>
<span class="go">0.64</span>
</pre></div>
</div>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: cputime?</span>
<span class="gp">...</span>
<span class="go"> Return the time in CPU second since SAGE started, or with optional</span>
<span class="go"> argument t, return the time since time t.</span>
<span class="go"> INPUT:</span>
<span class="go"> t -- (optional) float, time in CPU seconds</span>
<span class="go"> OUTPUT:</span>
<span class="go"> float -- time in CPU seconds</span>
</pre></div>
</div>
<p>Команда <tt class="docutils literal"><span class="pre">walltime</span></tt> ведет себя так же, как <tt class="docutils literal"><span class="pre">cputime</span></tt>, но она измеряет
настоящее время.</p>
<p>Мы также можем возвести число в степень, используя системы компьютерной
алгебры, включённые в Sage. В каждом случае мы запускаем простую команду
в системе чтобы запустить сервер для этой программы. Самое точное - время это
Wall time. Однако, если существует существенная разница между этим значением
и процессорным временем (CPU time), то, возможно, есть смысл проверить систему
на наличие проблем производительности.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: time 1938^99484;</span>
<span class="go">CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s</span>
<span class="go">Wall time: 0.01</span>
<span class="go">sage: gp(0)</span>
<span class="go">0</span>
<span class="go">sage: time g = gp('1938^99484')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 0.04</span>
<span class="go">sage: maxima(0)</span>
<span class="go">0</span>
<span class="go">sage: time g = maxima('1938^99484')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 0.30</span>
<span class="go">sage: kash(0)</span>
<span class="go">0</span>
<span class="go">sage: time g = kash('1938^99484')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 0.04</span>
<span class="go">sage: mathematica(0)</span>
<span class="go"> 0</span>
<span class="go">sage: time g = mathematica('1938^99484')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 0.03</span>
<span class="go">sage: maple(0)</span>
<span class="go">0</span>
<span class="go">sage: time g = maple('1938^99484')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 0.11</span>
<span class="go">sage: gap(0)</span>
<span class="go">0</span>
<span class="go">sage: time g = gap.eval('1938^99484;;')</span>
<span class="go">CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s</span>
<span class="go">Wall time: 1.02</span>
</pre></div>
</div>
<p>Заметьте, что GAP и Maxima являются самыми медленными в этом тесте (тест
был проведен на машине <tt class="docutils literal"><span class="pre">sage.math.washington.edu</span></tt>). Так как они работают
с другим интерфейсом, надстроенным над ними, судить об абсолютной
производительности этих систем не стоит.</p>
</div>
<div class="section" id="id5">
<h2>Ошибки и исключения<a class="headerlink" href="#id5" title="Ссылка на этот заголовок">¶</a></h2>
<p>Когда что-то идет не так, обычно можно увидеть исключение Python (Python
“exception”). Python даже попытается предположить, что вызвало ошибку. Часто
вы можете видеть имя исключения, например, <tt class="docutils literal"><span class="pre">NameError</span></tt> или <tt class="docutils literal"><span class="pre">ValueError</span></tt>
(см. Python Reference Manual <a class="reference internal" href="bibliography.html#py">[Py]</a> для полного списка исключений). Например,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: 3_2</span>
<span class="go">------------------------------------------------------------</span>
<span class="go"> File "<console>", line 1</span>
<span class="go"> ZZ(3)_2</span>
<span class="go"> ^</span>
<span class="go">SyntaxError: invalid syntax</span>
<span class="go">sage: EllipticCurve([0,infinity])</span>
<span class="go">------------------------------------------------------------</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="gr">TypeError</span>: <span class="n">Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational</span>
</pre></div>
</div>
<p>Интерактивный отладчик может быть полезным для понимая того, что пошло не так.
Отладчик можно включать или выключать командой <tt class="docutils literal"><span class="pre">%pdb</span></tt> (по умолчанию он
выключен). Приглашение командной строки <tt class="docutils literal"><span class="pre">ipdb></span></tt> появляется на экране,
если случилось исключение и отладчик был включен. Из отладчика вы можете
вывести на экран состояние любой локальной переменной и двигаться вверх и вниз
по стеку (execution stack). Например,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: %pdb</span>
<span class="go">Automatic pdb calling has been turned ON</span>
<span class="go">sage: EllipticCurve([1,infinity])</span>
<span class="go">---------------------------------------------------------------------------</span>
<span class="go"><type 'exceptions.TypeError'> Traceback (most recent call last)</span>
<span class="gp">...</span>
<span class="go">ipdb></span>
</pre></div>
</div>
<p>Для получения списка команд отладчика введите <tt class="docutils literal"><span class="pre">?</span></tt> в командной строке <tt class="docutils literal"><span class="pre">ipdb></span></tt>:</p>
<div class="highlight-python"><pre>ipdb> ?
Documented commands (type help <topic>):
========================================
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</pre>
</div>
<p>Нажмите Ctrl-D или введите <tt class="docutils literal"><span class="pre">quit</span></tt> чтобы вернуться в Sage.</p>
</div>
<div class="section" id="section-tabcompletion">
<span id="id7"></span><h2>Обратный поиск и автодополнение<a class="headerlink" href="#section-tabcompletion" title="Ссылка на этот заголовок">¶</a></h2>
<p>Сначала создадим трехмерное векторное пространство <img class="math" src="_images/math/ea0ae4a2520f18a9a18589c9f5a39e4da25913d8.png" alt="V=\QQ^3"/> следующим
образом:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = VectorSpace(QQ,3)</span>
<span class="go">sage: V</span>
<span class="go">Vector space of dimension 3 over Rational Field</span>
</pre></div>
</div>
<p>Можно использовать сокращенное обозначение:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3</span>
</pre></div>
</div>
<p>Введите начало команды, потом нажмите <tt class="docutils literal"><span class="pre">Ctrl-p</span></tt> (или просто нажмите
стрелку вверх на клавиатуре) чтобы вернуться к любой из строк, которые
вы вводили, начинающейся с таких же символов. Это работает даже если вы
полность вышли из Sage и перезапустили его позже. Можно использовать и
обратный поиск по истории команд с помощью <tt class="docutils literal"><span class="pre">Ctrl-r</span></tt>. Все эти возможности
используют пакет <tt class="docutils literal"><span class="pre">readline</span></tt> который доступен почти на всех разновидностях
GNU/Linux.</p>
<p>Можно с легкостью вывести список всех функций для <img class="math" src="_images/math/12d58aa29201da09d8e620f8698e3a37547f6b4a.png" alt="V"/>, используя
автодополнение. Просто введите <tt class="docutils literal"><span class="pre">V.</span></tt>, потом нажмите <tt class="docutils literal"><span class="pre">[TAB]</span></tt> на своей
клавиатуре:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V.[tab key]</span>
<span class="go">V._VectorSpace_generic__base_field</span>
<span class="gp">...</span>
<span class="go">V.ambient_space</span>
<span class="go">V.base_field</span>
<span class="go">V.base_ring</span>
<span class="go">V.basis</span>
<span class="go">V.coordinates</span>
<span class="gp">...</span>
<span class="go">V.zero_vector</span>
</pre></div>
</div>
<p>Если вы введете первые несколько символов команды, а потом нажмёте <tt class="docutils literal"><span class="pre">[TAB]</span></tt>,
вы получите функции, которые начинаются с этих символов.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V.i[tab key]</span>
<span class="go">V.is_ambient V.is_dense V.is_full V.is_sparse</span>
</pre></div>
</div>
<p>Если вам интересно, что делает какая-нибудь функция, например coordinates,
введите <tt class="docutils literal"><span class="pre">V.coordinates?</span></tt> для получения справки или <tt class="docutils literal"><span class="pre">V.coordinates??</span></tt> для
получения исходного кода (объясняется в следующем разделе).</p>
</div>
<div class="section" id="id8">
<h2>Встроенная справочная система<a class="headerlink" href="#id8" title="Ссылка на этот заголовок">¶</a></h2>
<p>Sage обладает встроенной справочной системой. Введите название функции со
знаком ? для доступа к документации по этой функции.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3</span>
<span class="go">sage: V.coordinates?</span>
<span class="go">Type: instancemethod</span>
<span class="go">Base Class: <type 'instancemethod'></span>
<span class="go">String Form: <bound method FreeModule_ambient_field.coordinates of Vector</span>
<span class="go">space of dimension 3 over Rational Field></span>
<span class="go">Namespace: Interactive</span>
<span class="go">File: /home/was/s/local/lib/python2.4/site-packages/sage/modules/f</span>
<span class="go">ree_module.py</span>
<span class="go">Definition: V.coordinates(self, v)</span>
<span class="go">Docstring:</span>
<span class="go"> Write v in terms of the basis for self.</span>
<span class="go"> Returns a list c such that if B is the basis for self, then</span>
<span class="go"> sum c_i B_i = v.</span>
<span class="go"> If v is not in self, raises an ArithmeticError exception.</span>
<span class="go"> EXAMPLES:</span>
<span class="go"> sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens()</span>
<span class="go"> sage: W = M.submodule([M0 + M1, M0 - 2*M1])</span>
<span class="go"> sage: W.coordinates(2*M0-M1)</span>
<span class="go"> [2, -1]</span>
</pre></div>
</div>
<p>Как показано выше, вывод показывает тип объекта, файл, в котором он
определен и полезное описание функции с примерами, которые можно вставить
в вашу текущую сессию. Почти все примеры подвергаются регулярной
автоматической проверке на предмет работоспособности и наличия требуемого
поведения.</p>
<p>Другая возможность хорошо отражает дух открытого программного обеспечения:
если <tt class="docutils literal"><span class="pre">f</span></tt> это функция Python’а, то <tt class="docutils literal"><span class="pre">f??</span></tt> выведет исходный код, который
определяет <tt class="docutils literal"><span class="pre">f</span></tt>. Например,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3</span>
<span class="go">sage: V.coordinates??</span>
<span class="go">Type: instancemethod</span>
<span class="gp">...</span>
<span class="go">Source:</span>
<span class="go">def coordinates(self, v):</span>
<span class="go"> """</span>
<span class="go"> Write $v$ in terms of the basis for self.</span>
<span class="go"> ...</span>
<span class="go"> """</span>
<span class="go"> return self.coordinate_vector(v).list()</span>
</pre></div>
</div>
<p>Отсюда мы знаем, что все, что делает функция <tt class="docutils literal"><span class="pre">coordinates</span></tt>, это вызов функции
<tt class="docutils literal"><span class="pre">coordinate_vector</span></tt> и превращает результат в список. Что делает функция
<tt class="docutils literal"><span class="pre">coordinate_vector?</span></tt></p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3</span>
<span class="go">sage: V.coordinate_vector??</span>
<span class="gp">...</span>
<span class="go">def coordinate_vector(self, v):</span>
<span class="go"> ...</span>
<span class="go"> return self.ambient_vector_space()(v)</span>
</pre></div>
</div>
<p>Функция <tt class="docutils literal"><span class="pre">coordinate_vector</span></tt> удерживает введенные значения во внешнем
пространстве, что позволяет добиться такого же эффекта, как при вычислении
вектора коэффициентов переменной <img class="math" src="_images/math/a9f23bf124b6b2b2a993eb313c72e678664ac74a.png" alt="v"/> с точки зрения <img class="math" src="_images/math/12d58aa29201da09d8e620f8698e3a37547f6b4a.png" alt="V"/>.
Пространство <img class="math" src="_images/math/12d58aa29201da09d8e620f8698e3a37547f6b4a.png" alt="V"/> уже внешнее, так как оно является <img class="math" src="_images/math/1219c02f3a57aca09c165eb787dbc502d8479099.png" alt="\QQ^3"/>.
Существует также функция <tt class="docutils literal"><span class="pre">coordinate_vector</span></tt> для подпространств, и она
ведет себя по-иному. Мы создим подпространство и посмотрим:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: V = QQ^3; W = V.span_of_basis([V.0, V.1])</span>
<span class="go">sage: W.coordinate_vector??</span>
<span class="gp">...</span>
<span class="go">def coordinate_vector(self, v):</span>
<span class="go"> """</span>
<span class="go"> ...</span>
<span class="go"> """</span>
<span class="go"> # First find the coordinates of v wrt echelon basis.</span>
<span class="go"> w = self.echelon_coordinate_vector(v)</span>
<span class="go"> # Next use transformation matrix from echelon basis to</span>
<span class="go"> # user basis.</span>
<span class="go"> T = self.echelon_to_user_matrix()</span>
<span class="go"> return T.linear_combination_of_rows(w)</span>
</pre></div>
</div>
<p>(Если вы считаете, что существующая реализация неэффективна, пожалуйста,
зарегистрируйтесь и помогите оптимизировать линейную алгебру.)</p>
<p>Вы также можете ввести <tt class="docutils literal"><span class="pre">help(имя_команды)</span></tt> или <tt class="docutils literal"><span class="pre">help(класс)</span></tt> для
получения справки о классах или функциях в стиле man-страниц.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: help(VectorSpace)</span>
<span class="go">Help on class VectorSpace ...</span>
<span class="go">class VectorSpace(__builtin__.object)</span>
<span class="go"> | Create a Vector Space.</span>
<span class="go"> |</span>
<span class="go"> | To create an ambient space over a field with given dimension</span>
<span class="go"> | using the calling syntax ...</span>
<span class="go"> :</span>
<span class="go"> :</span>
</pre></div>
</div>
<p>Когда вы вводите <tt class="docutils literal"><span class="pre">q</span></tt> для выхода из справочной системы, ваша сессия
находится в том же состоянии, что и до этого. Справка не захламляет ваш
экран, в отличие от формы <tt class="docutils literal"><span class="pre">function_name?</span></tt>, которая иногда может
оставлять информацию в вашей сессии. Особенно полезно использовать
<tt class="docutils literal"><span class="pre">help(module_name)</span></tt>. Например, векторные пространства описаны в
<tt class="docutils literal"><span class="pre">sage.modules.free_module</span></tt>, поэтому введите <tt class="docutils literal"><span class="pre">help(sage.modules.free_module)</span></tt>
для документации обо всем модуле. Когда вы просматриваете документацию в
справочной системе, вы можете осуществлять поиск с помощью <tt class="docutils literal"><span class="pre">/</span></tt> и в обратном
порядке с помощью <tt class="docutils literal"><span class="pre">?</span></tt>.</p>
</div>
<div class="section" id="id9">
<h2>Сохранение и загрузка отдельных объектов<a class="headerlink" href="#id9" title="Ссылка на этот заголовок">¶</a></h2>
<p>Допустим вы вычислили матрицу или хуже: сложное пространство модулярных
символов, и хотите сохранить его для работы в будущем. Как это сделать? Есть
несколько способов, которыми компьютерные алгебры пользуются для сохранения
объектов.</p>
<ol class="arabic simple">
<li><strong>Сохранить игру:</strong> Поддерживается сохранение и загрузка только полных сессий
(например, GAP, Magma).</li>
<li><strong>Унифицированный ввод/вывод:</strong> Вывод объектов на экран в таком виде, в
котором они могут быть считаны позже. (GP/PARI).</li>
<li><strong>Eval</strong>: Легкий способ запуска любого кода в интерпретаторе (например,
Singular, PARI).</li>
</ol>
<p>Так как Sage построен на Python’е, он использует иной подход: каждый объект
может быть превращен в строку, из которой в последствии можно восстановить объект.
Способ схож со способом унификации ввода и вывода, как в PARI, но в случае с
Sage нет необходимости выводить объект на экран в самой неудобной форме.
Также, поддержка сохранения и загрузки (в большинстве случаев) полностью
автоматична, не требует дополнительного программирования; это просто возможность
Python’а, которая была включена в язык с самого начала.</p>
<p>Почти любой объект x может быть сохранен в сжатой форме на диск при помощи
команды ‘’save(x, filename)’’ (или во многих случаях ‘’x.save(filename)’‘).
Для загрузки объекта введите ‘’load(filename)’‘.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: A = MatrixSpace(QQ,3)(range(9))^2</span>
<span class="go">sage: A</span>
<span class="go">[ 15 18 21]</span>
<span class="go">[ 42 54 66]</span>
<span class="go">[ 69 90 111]</span>
<span class="go">sage: save(A, 'A')</span>
</pre></div>
</div>
<p>Теперь выйдите из Sage и перезапустите. Теперь вы можете получить ‘’A’’ обратно:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: A = load('A')</span>
<span class="go">sage: A</span>
<span class="go">[ 15 18 21]</span>
<span class="go">[ 42 54 66]</span>
<span class="go">[ 69 90 111]</span>
</pre></div>
</div>
<p>То же самое можно делать и с более сложными объектами, например эллиптическими
кривыми. Вся информация об объекте (которая находится в кеше) сохраняется вместе
с объектом. Например,</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: E = EllipticCurve('11a')</span>
<span class="go">sage: v = E.anlist(100000) # требует некоторого времени...</span>
<span class="go">sage: save(E, 'E')</span>
<span class="go">sage: quit</span>
</pre></div>
</div>
<p>Сохраненная версия <tt class="docutils literal"><span class="pre">E</span></tt> занимает 153 килобита, так как в нем содержатся первые
100000 <img class="math" src="_images/math/6f1a2b6b7c193f9ba2b2134a59f1da5addcfbc98.png" alt="a_n"/>.</p>
<div class="highlight-python"><pre>~/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) # моментально!</pre>
</div>
<p>(В Python, сохранение и загрузка осуществляется модулем <tt class="docutils literal"><span class="pre">cPickle</span></tt>. Объект
Sage <tt class="docutils literal"><span class="pre">x</span></tt> может быть сохранен с помощью <tt class="docutils literal"><span class="pre">cPickle.dumps(x,</span> <span class="pre">2)</span></tt>. Обратите
внимание на <tt class="docutils literal"><span class="pre">2</span></tt>!)</p>
<p>Sage не может сохранять и загружать объекты, созданные в других системах
компьютерной алгебры, таких как GAP, Singular, Maxima и пр. Они загружаются
в состоянии, которое помечено как “invalid”. Хотя, в GAP многие объекты выводятся
в форме, из которой их потом можно восстановить, но многие не выводятся в
такой форме, поэтому их восстановление из такого вида нарочно запрещено.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: a = gap(2)</span>
<span class="go">sage: a.save('a')</span>
<span class="go">sage: load('a')</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="gr">ValueError</span>: <span class="n">The session in which this object was defined is no longer</span>
<span class="go">running.</span>
</pre></div>
</div>
<p>Объекты GP/PARI могут быть сохранены и загружены, так как их вид при выводе
на экран достаточен для восстановления объекта.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: a = gp(2)</span>
<span class="go">sage: a.save('a')</span>
<span class="go">sage: load('a')</span>
<span class="go">2</span>
</pre></div>
</div>
<p>Сохраненные объекты могут быть загружены позже на компьютерах с другой
архитектурой или операционной системой, например, вы можете сохранить
огромную матрицу в 32-битной OS X и загрузить ее в 64-битную GNU/Linux,
привести к ступенчатой форме и переместить обратно. Также во многих случаях
вы можете загружать объекты в версии Sage, отличные от версии, на которой
они были сохранены. Все атрибуты объекта сохраняются вместе с классом (но не
включая исходный код), который описывает объект. Если класс более не существует
в новой версии Sage, тогда объект не может быть загружен в эту новую версию.
Но если вы загрузите ее на версию ниже, получите словарь объектов (с помощью
<tt class="docutils literal"><span class="pre">x.__dict__</span></tt>) и сохраните словарь, то сможете загрузить его в новую версию.</p>
<div class="section" id="id10">
<h3>Сохранение в виде текста<a class="headerlink" href="#id10" title="Ссылка на этот заголовок">¶</a></h3>
<p>Вы также можете сохранять объекты в виде набора ASCII символов в простой
текстовый файл простым открытием файла и сохранением строки, которая выражает
(описывает) объект (вы можете записывать несколько объектов). Не забудьте
закрыть файл после добавления данных.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: R.<x,y> = PolynomialRing(QQ,2)</span>
<span class="go">sage: f = (x+y)^7</span>
<span class="go">sage: o = open('file.txt','w')</span>
<span class="go">sage: o.write(str(f))</span>
<span class="go">sage: o.close()</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="section-save">
<span id="id11"></span><h2>Сохранение и загрузка полных сессий<a class="headerlink" href="#section-save" title="Ссылка на этот заголовок">¶</a></h2>
<p>Sage обладает очень гибкими возможностями сохранения и загрузки полных сессий.</p>
<p>Команда <tt class="docutils literal"><span class="pre">save_session(sessionname)</span></tt> сохраняет все переменные, которые
вы задали в текущей сессии в виде словаря в заданном <tt class="docutils literal"><span class="pre">sessionname</span></tt>. (В редком
случае, когда объект не поддерживает сохранения, он просто не будет включен
в словарь.) В результате будет создан файл с расширением <tt class="docutils literal"><span class="pre">.sobj</span></tt> и может быть
загружен как любой другой объект. Когда вы загружаете сохраненные объекты в
сессию, вы получаете словарь, ключами которого являются имена переменных, а
значениями — объекты.</p>
<p>Вы можете использовать команду <tt class="docutils literal"><span class="pre">load_session(sessionname)</span></tt>, чтобы загрузить
переменные, описанные в <tt class="docutils literal"><span class="pre">sessionname</span></tt>, в текущую сессию. Заметьте, что это
не удаляет переменные, заданные в этой сессии. Вместо этого, две сессии
объединяются.</p>
<p>Для начала запустим Sage и зададим несколько переменных.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: E = EllipticCurve('11a')</span>
<span class="go">sage: M = ModularSymbols(37)</span>
<span class="go">sage: a = 389</span>
<span class="go">sage: t = M.T(2003).matrix(); t.charpoly().factor()</span>
<span class="go"> _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2</span>
</pre></div>
</div>
<p>Далее, сохраним нашу сессию, что включит в себя сохранение всех заданных
выше переменных в файл. Потом мы проверим информацию о файле. Его размер —
3 килобайта.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: save_session('misc')</span>
<span class="go">Saving a</span>
<span class="go">Saving M</span>
<span class="go">Saving t</span>
<span class="go">Saving E</span>
<span class="go">sage: quit</span>
<span class="go">was@form:~/tmp$ ls -l misc.sobj</span>
<span class="go">-rw-r--r-- 1 was was 2979 2006-01-28 19:47 misc.sobj</span>
</pre></div>
</div>
<p>Наконец, мы перезапустим Sage, зададим дополнительную переменную и загрузим
сохраненную сессию.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: b = 19</span>
<span class="go">sage: load_session('misc')</span>
<span class="go">Loading a</span>
<span class="go">Loading M</span>
<span class="go">Loading E</span>
<span class="go">Loading t</span>
</pre></div>
</div>
<p>Каждая сохраненная переменная снова является переменной. Кроме того, переменная
<tt class="docutils literal"><span class="pre">b</span></tt> не была перезаписана.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: M</span>
<span class="go">Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0</span>
<span class="go">and dimension 5 over Rational Field</span>
<span class="go">sage: E</span>
<span class="go">Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational</span>
<span class="go">Field</span>
<span class="go">sage: b</span>
<span class="go">19</span>
<span class="go">sage: a</span>
<span class="go">389</span>
</pre></div>
</div>
</div>
<div class="section" id="notebook">
<span id="section-notebook"></span><h2>Интерфейс Notebook<a class="headerlink" href="#notebook" title="Ссылка на этот заголовок">¶</a></h2>
<p>Sage notebook запускается с помощью следующей команды</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: notebook()</span>
</pre></div>
</div>
<p>введенной в командной строке. Она запустит Sage notebook и откроет его в
браузере по умолчанию. Файлы состояния сервера хранятся в
<tt class="docutils literal"><span class="pre">$HOME/.sage/sage\_notebook</span></tt>.</p>
<p>Другие параметры включают в себя:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="go">sage: notebook("directory")</span>
</pre></div>
</div>
<p>Этот параметр позволяет запустить сервер Notebook, используя файлы в заданной
директории, вместо использования директории по умолчанию
<tt class="docutils literal"><span class="pre">$HOME/.sage/sage_notebook</span></tt>. Это может оказаться полезным, если вы хотите
иметь коллекцию рабочих листов, связанных с конкретным проектом, или если вы
хотите запускать несколько отдельных серверов Notebook в одно время.</p>
<p>Когда вы запускаете Notebook, вначале он создает следующие файлы в директории
<tt class="docutils literal"><span class="pre">$HOME/.sage/sage_notebook</span></tt>:</p>
<div class="highlight-python"><pre>nb.sobj (the notebook SAGE object file)
objects/ (a directory containing SAGE objects)
worksheets/ (a directory containing SAGE worksheets).</pre>
</div>
<p>После создания этих файлов, Notebook запускает веб-сервер.</p>
<p>Notebook — это коллекция учетных записей пользователей (аккаунтов), каждый
из которых может иметь любое количество рабочих листов. Когда вы создаете
новый рабочий лист, информация, которая описывает его, сохраняется в директории
<tt class="docutils literal"><span class="pre">worksheets/username/number</span></tt>. В каждой такой директории находится простой
текстовый файл <tt class="docutils literal"><span class="pre">worksheet.txt</span></tt>; если что-то случится с вашими рабочими листами,
или с Sage, или что-нибудь еще пойдет не так, то текcтовый файл, который легко
читается, поможет восстановить ваш лист полностью.</p>
<p>В Sage введите <tt class="docutils literal"><span class="pre">notebook?</span></tt> для получения подробной информации о том, как
запустить сервер Notebook.</p>
<p>Следующая диаграмма иллюстрирует архитектуру Sage Notebook:</p>
<div class="highlight-python"><pre>----------------------
| |
| |
| firefox/safari |
| |
| javascript |
| program |
| |
| |
----------------------
| ^
| AJAX |
V |
----------------------
| |
| sage | SAGE process 1
| web | ------------> SAGE process 2 (Python processes)
| server | pexpect SAGE process 3
| | .
| | .
---------------------- .</pre>
</div>
<p>Для получения справки о команде Sage, <tt class="docutils literal"><span class="pre">cmd</span></tt>, в notebook введите, <tt class="docutils literal"><span class="pre">cmd?</span></tt> и
нажмите <tt class="docutils literal"><span class="pre"><esc></span></tt> (не <tt class="docutils literal"><span class="pre"><shift-enter></span></tt>).</p>
<p>Для получения справки о горячих клавишах интерфейса notebook нажмите ссылку
<tt class="docutils literal"><span class="pre">Help</span></tt>.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Содержание</a></h3>
<ul>
<li><a class="reference internal" href="#">Интерактивная оболочка</a><ul>
<li><a class="reference internal" href="#sage">Ваша сессия Sage</a></li>
<li><a class="reference internal" href="#id2">Журналирование ввода и вывода</a></li>
<li><a class="reference internal" href="#id3">Вставка игнорирует приглашение</a></li>
<li><a class="reference internal" href="#id4">Команды измерения времени</a></li>
<li><a class="reference internal" href="#id5">Ошибки и исключения</a></li>
<li><a class="reference internal" href="#section-tabcompletion">Обратный поиск и автодополнение</a></li>
<li><a class="reference internal" href="#id8">Встроенная справочная система</a></li>
<li><a class="reference internal" href="#id9">Сохранение и загрузка отдельных объектов</a><ul>
<li><a class="reference internal" href="#id10">Сохранение в виде текста</a></li>
</ul>
</li>
<li><a class="reference internal" href="#section-save">Сохранение и загрузка полных сессий</a></li>
<li><a class="reference internal" href="#notebook">Интерфейс Notebook</a></li>
</ul>
</li>
</ul>
<h4>Предыдущий раздел</h4>
<p class="topless"><a href="tour_advanced.html"
title="предыдущая глава">Немного высшей математики</a></p>
<h4>Следующий раздел</h4>
<p class="topless"><a href="interfaces.html"
title="следующая глава">Интерфейсы</a></p>
<h3>На этой странице</h3>
<ul class="this-page-menu">
<li><a href="_sources/interactive_shell.txt"
rel="nofollow">Показать исходный текст</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Быстрый поиск</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18" />
<!-- The shading of the "Go" button should be consistent -->
<!-- with the colour of the header and footer. See the file -->
<!-- doc/common/themes/sage/theme.conf for colours used by -->
<!-- the Sage theme. -->
<input type="submit" style="background-color: #B8B9F6" value="Искать" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Введите слова для поиска или имя модуля, класса или функции.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Просмотр</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="Словарь-указатель"
>словарь</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>модули</a> |</li>
<li class="right" >
<a href="interfaces.html" title="Интерфейсы"
>следующий</a> |</li>
<li class="right" >
<a href="tour_advanced.html" title="Немного высшей математики"
>предыдущий</a> |</li>
<a href="../index.html"><img src="_static/sagelogo.png" style="vertical-align: middle" title="Sage Logo"></a>
<li><a href="index.html">Sage Tutorial in Russian v5.9</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2005--2011, The Sage Development Team.
При создании использован <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<script type="text/javascript">
/*global jQuery, window */
/* Sphinx sidebar toggle. Putting this code at the end of the body
* enables the toggle for the live, static, and offline docs. Note:
* sage.misc.html.math_parse() eats jQuery's dollar-sign shortcut. */
var jq = jQuery;
jq(document).ready(function () {
var bar, bod, bg, fg, key, tog, wid_old, wid_new, resize, get_state, set_state;
bod = jq('div.bodywrapper');
bar = jq('div.sphinxsidebar');
tog = jq('<div class="sphinxsidebartoggle"></div>');
/* Delayed resize helper. Not perfect but good enough. */
resize = function () {
setTimeout(function () {
tog.height(bod.height());
}, 100);
};
jq(window).resize(function () {
resize();
});
/* Setup and add the toggle. See Sphinx v0.5.1 default.css. */
fg = jq('div.sphinxsidebar p a').css('color') || 'rgb(152, 219, 204)';
bg = jq('div.document').css('background-color') || 'rgb(28, 78, 99)';
wid_old = '230px';
wid_new = '5px';
tog.css('background-color', bg)
.css('border-width', '0px')
.css('border-right', wid_new + ' ridge ' + bg)
.css('cursor', 'pointer')
.css('position', 'absolute')
.css('left', '-' + wid_new)
.css('top', '0px')
.css('width', wid_new);
bod.css('position', 'relative');
bod.prepend(tog);
resize();
/* Cookie helpers. */
key = 'sphinxsidebar=';
set_state = function (s) {
var date = new Date();
/* Expiry in 7 days. */
date.setTime(date.getTime() + (7 * 24 * 3600 * 1000));
document.cookie = key + encodeURIComponent(s) + '; expires=' +
date.toUTCString() + '; path=/';
};
get_state = function () {
var i, c, crumbs = document.cookie.split(';');
for (i = 0; i < crumbs.length; i += 1) {
c = crumbs[i].replace(/^\s+/, '');
if (c.indexOf(key) === 0) {
return decodeURIComponent(c.substring(key.length, c.length));
}
}
return null;
};
/* Event handlers. */
tog.mouseover(function (ev) {
tog.css('border-right-color', fg);
}).mouseout(function (ev) {
tog.css('border-right-color', bg);
}).click(function (ev) {
if (bod.hasClass('wide')) {
bod.removeClass('wide');
bod.css('margin-left', wid_old);
bar.css('width', wid_old);
bar.show();
set_state('visible');
} else {
set_state('hidden');
bar.hide();
bar.css('width', '0px');
bod.css('margin-left', wid_new);
bod.addClass('wide');
}
resize();
});
/* Hide the normally visible sidebar? */
if (get_state() === 'hidden') {
tog.trigger('click');
} else {
set_state('visible');
}
});
</script>
</body>
</html>
