PREP Intro Tutorial
system:sage


<h1>Introductory Sage Tutorial - Welcome!</h1>
<p>This&nbsp;<a href="http://www.sagemath.org" target="_blank">Sage</a>&nbsp;worksheet is the first in a series of tutorials developed for the MAA PREP Workshop "Sage: Using Open-Source Mathematics Software with Undergraduates" (funding provided by NSF DUE 0817071). &nbsp;The first part of the tutorial was to load this worksheet, of course!</p>
<p>This tutorial has the following sections:</p>
<ul>
<li><a href="#SageCommands">Evaluating Sage Commands</a></li>
<li><a href="#SageFunctions">Functions in Sage</a></li>
<li><a href="#SageHelp">Help inside Sage</a></li>
<li><a href="#SageAnnotation">Annotating with Sage</a></li>
</ul>
<p>As the workshop progresses, more tutorials on topics such as calculus, advanced plotting, and specific mathematical topics will become available.</p>
<h1 id="SageCommands">Evaluating Sage Commands</h1>
<h3>(i.e., How do I get Sage to do some math?)</h3>
<p id="Evaluate">The little boxes below are called&nbsp;<em>input cells</em><span style="font-style: italic;">&nbsp;or <em>code cells</em>.</span>&nbsp;To evaluate the content of an input cell, first click inside the cell so that the cell is active (i.e., has a bright blue border). &nbsp;Then, just below the cell on the left, an "evaluate" link appears; clicking this link evaluates the cell. &nbsp;Try evaluating the following cell.</p>

{{{id=2|
2+2
///
4
}}}

<div style="color: #000000; background-image: initial; background-repeat: initial; background-attachment: initial; -webkit-background-clip: initial; -webkit-background-origin: initial; background-color: #ffffff; background-position: initial initial; margin: 8px;">
<p>Sage prints out its response just below the cell (that's the "4" above, so Sage confirms that $2+2=4$). &nbsp; Note also that Sage has probably automatically made the next cell active after your evaluated your first cell.</p>
<p>You can also evaluate a cell using a keyboard shortcut. &nbsp;If the following cell isn't active, click in it; then try holding down the Shift key while you press the Enter key. &nbsp;(We call this "Shift-Enter".)</p>
</div>

{{{id=4|
factor(2010)
///
2 * 3 * 5 * 67
}}}

<p>You can edit a cell and evaluate it again. &nbsp;Try changing the number "2010" above to your favorite number and evaluate the cell to find its factorization.</p>
<p>To create a new input cell, move your cursor over the space above or below another cell. &nbsp;A blue horizontal line as wide as the browser appears. Click on the line to insert a new cell. &nbsp;To delete an input cell, just delete all the text inside of it, and then press backspace in the now-empty cell.</p>
<p>Try creating a few new input cells below, doing some arithmetic, and deleting one of the input cells.</p>

{{{id=6|

///
}}}

{{{id=125|

///
}}}

<h1 id="SageFunctions">Functions in Sage</h1>
<p>To start out, let's explore how to define variables and functions.</p>
<p>In the next cell, we tell Sage that "x" is a variable and we define the function $f(x)=x^2$.</p>
<ul>
<li>Whenever we want to use a variable, like "y", we need to tell Sage that "y" is a variable like we do below (i.e., "var('y')").&nbsp; (There are some times that Sage can guess that we are talking about a variable, but it's still a good practice to explicitly tell Sage what our variables are.)</li>
<li>Notice that when we create the function $f(x)$, Sage just does this and doesn't print anything out back to us.</li>
<li>Notice that we can put several commands in one cell, each on a separate line.&nbsp; The output of the last command is printed as the output of the cell (which is nothing, in the cell below).</li>
</ul>

{{{id=8|
var('x')
f(x)=x^2
///
}}}

<p>We can check the definition by asking Sage what $f(x)$ is:</p>

{{{id=111|
f(x)
///
x^2
}}}

<p>If we just ask Sage what $f$ is (as opposed to $f(x)$), Sage prints out the standard mathematical notation for a function that maps a variable $x$ to the value $x^2$ (with the "maps to" arrow $\mapsto$ as "|--&gt;").</p>

{{{id=126|
f
///
x |--> x^2
}}}

<p>We can evaluate $f$ at various values.</p>

{{{id=103|
f(3)
///
9
}}}

<p>Sage knows various common mathematical constants, like $\pi$ ("pi") and $e$.</p>

{{{id=109|
f(pi)
///
pi^2
}}}

{{{id=115|
f(e^-1)
///
e^(-2)
}}}

<p>In order to see a numeric approximation for an expression, just type the expression inside the parentheses of "N()".</p>

{{{id=118|
N(f(pi))
///
9.86960440108936
}}}

<p>Another option, often more useful in practice, is having the expression immediately followed by ".n()" (note the dot).</p>

{{{id=117|
f(e^-1).n()
///
0.135335283236613
}}}

<p>Sage also has lots of common mathematical functions built in, like $\sqrt{x}$ ("sqrt(x)") and $\ln(x)$ ("ln(x)" or "log(x)").</p>

{{{id=120|
log(3).n()
///
1.09861228866811
}}}

{{{id=121|
sqrt(2)
///
sqrt(2)
}}}

{{{id=149|
sqrt(2).n()
///
1.41421356237310
}}}

{{{id=150|
f(sqrt(2))
///
2
}}}

<p>Notice that if we want this to look nicer, we can use the "show" command. &nbsp;We'll look more at this sort of thing below.</p>

{{{id=142|
show(sqrt(2))
///
<html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\sqrt{2}</div></html>
}}}

<p>We can also plot the function easily. &nbsp;In another tutorial, we will go more in depth with plotting; here, note that the preferred syntax has the variable and endpoints for the plotting domain in parentheses, separated by commas.</p>

{{{id=122|
plot(f, (x,-3,3))
///
<html><font color='black'><img src='cell://sage0.png'></font></html>
}}}

{{{id=108|

///
}}}

<h1 id="SageHelp">Help inside Sage</h1>
<p>There are various ways to get help for doing things in Sage.&nbsp; Here are several common ways to get help as you are working in a Sage worksheet.</p>
<h2>Documentation</h2>
<p>Sage includes extensive documentation covering thousands of  functions, with many examples, tutorials, and other helps.&nbsp; To access  these, just click the "Help" link at the top right of any worksheet.&nbsp; Also, the <a href="http://wiki.sagemath.org/quickref" target="_blank">Quick Reference cards</a> are useful.</p>
<h2>Tab completion</h2>
<p>To see what you can do to an expression, usually you can just give the expression a name, type a period after it, and then press tab.&nbsp; You will see a list pop up of all the things you can do to the expression.</p>
<p>Just in case you didn't do it before, evaluate this cell to (re-)define $f(x)$.</p>
<ul>
</ul>

{{{id=135|
f(x)=x^2
///
}}}

<p>After evaluating the above cell, put your cursor after the period and press your tab key. &nbsp;(To stop viewing the list, pressing the Escape/esc key should do the trick.)</p>

{{{id=139|
f.
///
}}}

<p>One of the things in that list above was "integrate".&nbsp; Let's try it.</p>

{{{id=137|
f.integrate(x)
///
x |--> 1/3*x^3
}}}

<p>This works with completing commands as well.  Try tabbing after this to see all the commands that start with the letters "plot".  Clicking on one of the options will use it for this cell.</p>

{{{id=132|
plot
///
}}}

<p>Remember, if you decide not to use any of the options, pressing Escape should make the list disappear.</p>

<h2>Finding documentation (the question marks)</h2>
<p>Use a question mark after a function name to pull up the documentation for the function.&nbsp; Almost all documentation in Sage has extensive examples that can illustrate how to use the function.&nbsp; To see this help, you can move your cursor after the question mark and press tab. &nbsp;</p>
<p>For instance, do this for the integration example above to see examples illustrating that the syntax requires "f.integrate(x)" and not just "f.integrate()" (which could be ambiguous if several variables had already been defined).</p>
<ul>
</ul>

{{{id=151|
f.integrate?
///
}}}

<p>To stop viewing the documentation after pressing tab, you can press the Escape key, just like with the completion of options.</p>
<p>Instead of using tab, you can evaluate a cell (like below) to access the documentation.</p>

{{{id=14|
binomial?
///
<html><!--notruncate-->
<div class="docstring">
    
  <p><strong>File:</strong> /usr/local/sage-prep/local/lib/python2.6/site-packages/sage/rings/arith.py</p>
<p><strong>Type:</strong> &lt;type &#8216;function&#8217;&gt;</p>
<p><strong>Definition:</strong> binomial(x, m)</p>
<p><strong>Docstring:</strong></p>
<blockquote>
<p>Return the binomial coefficient</p>
<div class="math">
\binom{x}{m} = x (x-1) \cdots (x-m+1) / m!</div>
<p>which is defined for <span class="math">m \in \ZZ</span> and any
<span class="math">x</span>. We extend this definition to include cases when
<span class="math">x-m</span> is an integer but <span class="math">m</span> is not by</p>
<div class="math">
\binom{x}{m}= \binom{x}{x-m}</div>
<p>If <span class="math">m &lt; 0</span>, return <span class="math">0</span>.</p>
<p>INPUT:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">x</span></tt>, <tt class="docutils literal"><span class="pre">m</span></tt> - numbers or symbolic expressions. Either <tt class="docutils literal"><span class="pre">m</span></tt>
or <tt class="docutils literal"><span class="pre">x-m</span></tt> must be an integer.</li>
</ul>
<p>OUTPUT: number or symbolic expression (if input is symbolic)</p>
<p>EXAMPLES:</p>
<div class="highlight-python"><div class="highlight"><pre class="literal-block"><span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">5</span><span class="p">,</span><span class="mf">2</span><span class="p">)</span>
<span class="go">10</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">2</span><span class="p">,</span><span class="mf">0</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">1</span><span class="o">/</span><span class="mf">2</span><span class="p">,</span> <span class="mf">0</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">3</span><span class="p">,</span><span class="o">-</span><span class="mf">1</span><span class="p">)</span>
<span class="go">0</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">20</span><span class="p">,</span><span class="mf">10</span><span class="p">)</span>
<span class="go">184756</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="o">-</span><span class="mf">2</span><span class="p">,</span> <span class="mf">5</span><span class="p">)</span>
<span class="go">-6</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="n">RealField</span><span class="p">()(</span><span class="s">&#39;2.5&#39;</span><span class="p">),</span> <span class="mf">2</span><span class="p">)</span>
<span class="go">1.87500000000000</span>
<span class="gp">sage: </span><span class="n">n</span><span class="o">=</span><span class="n">var</span><span class="p">(</span><span class="s">&#39;n&#39;</span><span class="p">);</span> <span class="n">binomial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="mf">2</span><span class="p">)</span>
<span class="go">1/2*(n - 1)*n</span>
<span class="gp">sage: </span><span class="n">n</span><span class="o">=</span><span class="n">var</span><span class="p">(</span><span class="s">&#39;n&#39;</span><span class="p">);</span> <span class="n">binomial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">n</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">sage: </span><span class="n">n</span><span class="o">=</span><span class="n">var</span><span class="p">(</span><span class="s">&#39;n&#39;</span><span class="p">);</span> <span class="n">binomial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">n</span><span class="o">-</span><span class="mf">1</span><span class="p">)</span>
<span class="go">n</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">2</span><span class="o">^</span><span class="mf">100</span><span class="p">,</span> <span class="mf">2</span><span class="o">^</span><span class="mf">100</span><span class="p">)</span>
<span class="go">1</span>

<span class="gp">sage: </span><span class="n">k</span><span class="p">,</span> <span class="n">i</span> <span class="o">=</span> <span class="n">var</span><span class="p">(</span><span class="s">&#39;k,i&#39;</span><span class="p">)</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="n">k</span><span class="p">,</span><span class="n">i</span><span class="p">)</span>
<span class="go">binomial(k, i)</span>
</pre></div>
</div>
<p>TESTS:</p>
<p>We test that certain binomials are very fast (this should be
instant) &#8211; see trac 3309:</p>
<div class="highlight-python"><div class="highlight"><pre class="literal-block"><span class="gp">sage: </span><span class="n">a</span> <span class="o">=</span> <span class="n">binomial</span><span class="p">(</span><span class="n">RR</span><span class="p">(</span><span class="mf">1140000.78</span><span class="p">),</span> <span class="mf">42000000</span><span class="p">)</span>
</pre></div>
</div>
<p>We test conversion of arguments to Integers &#8211; see trac 6870:</p>
<div class="highlight-python"><div class="highlight"><pre class="literal-block"><span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">1</span><span class="o">/</span><span class="mf">2</span><span class="p">,</span><span class="mf">1</span><span class="o">/</span><span class="mf">1</span><span class="p">)</span>
<span class="go">1/2</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">10</span><span class="o">^</span><span class="mf">20</span><span class="o">+</span><span class="mf">1</span><span class="o">/</span><span class="mf">1</span><span class="p">,</span><span class="mf">10</span><span class="o">^</span><span class="mf">20</span><span class="p">)</span>
<span class="go">100000000000000000001</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="n">SR</span><span class="p">(</span><span class="mf">10</span><span class="o">**</span><span class="mf">7</span><span class="p">),</span><span class="mf">10</span><span class="o">**</span><span class="mf">7</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">3</span><span class="o">/</span><span class="mf">2</span><span class="p">,</span><span class="n">SR</span><span class="p">(</span><span class="mf">1</span><span class="o">/</span><span class="mf">1</span><span class="p">))</span>
<span class="go">3/2</span>
</pre></div>
</div>
<p>Some floating point cases &#8211; see trac 7562:</p>
<div class="highlight-python"><div class="highlight"><pre class="literal-block"><span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span><span class="mf">3</span><span class="p">)</span>
<span class="go">0.000000000000000</span>
<span class="gp">sage: </span><span class="n">binomial</span><span class="p">(</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span><span class="mf">3</span><span class="p">)</span>
<span class="go">-4.00000000000000</span>
</pre></div>
</div>
</blockquote>


</div>
</html>
}}}

<p>Try this with another function!</p>

{{{id=133|

///
}}}

<p><span id="cell_outer_21"> </span></p>
<ul>
</ul>
<p><span id="cell_outer_21">&nbsp;</span></p>
<p>&nbsp;</p>
<h2>Finding the source</h2>
<p>Finally, one can use <em>two</em> question marks after a function name to pull up the documentation and the source code for the function.&nbsp; Again, to see this help, you can either evaluate a cell like below, or just move your cursor after the question mark and press tab.</p>
<p>The ability to see the code is one of Sage's great strengths.&nbsp; You can see <em>all</em> the code to <em>everything</em>.&nbsp; This means you can see what Sage is doing, your curious students can see what is going on, and if you find a better way to do something, then you can change it!</p>
<p><span id="cell_outer_21"> </span></p>
<ul>
</ul>
<p>&nbsp;</p>

{{{id=129|
binomial??
///
<html><!--notruncate-->
<div class="docstring">
    
  <p><strong>File:</strong> /usr/local/sage-prep/local/lib/python2.6/site-packages/sage/rings/arith.py</p>
<p><strong>Source Code</strong> (starting at line 2784):</p>
<div class="highlight-python"><div class="highlight"><pre class="literal-block"><span class="k">def</span> <span class="nf">binomial</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">m</span><span class="p">):</span>
    <span class="s">r&quot;&quot;&quot;</span>
<span class="s">    Return the binomial coefficient</span>

<span class="s">    .. math::</span>

<span class="s">                \binom{x}{m} = x (x-1) \cdots (x-m+1) / m!</span>


<span class="s">    which is defined for `m \in \ZZ` and any</span>
<span class="s">    `x`. We extend this definition to include cases when</span>
<span class="s">    `x-m` is an integer but `m` is not by</span>

<span class="s">    .. math::</span>

<span class="s">        \binom{x}{m}= \binom{x}{x-m}</span>

<span class="s">    If `m &lt; 0`, return `0`.</span>

<span class="s">    INPUT:</span>

<span class="s">    -  ``x``, ``m`` - numbers or symbolic expressions. Either ``m``</span>
<span class="s">       or ``x-m`` must be an integer.</span>

<span class="s">    OUTPUT: number or symbolic expression (if input is symbolic)</span>

<span class="s">    EXAMPLES::</span>

<span class="s">        sage: binomial(5,2)</span>
<span class="s">        10</span>
<span class="s">        sage: binomial(2,0)</span>
<span class="s">        1</span>
<span class="s">        sage: binomial(1/2, 0)</span>
<span class="s">        1</span>
<span class="s">        sage: binomial(3,-1)</span>
<span class="s">        0</span>
<span class="s">        sage: binomial(20,10)</span>
<span class="s">        184756</span>
<span class="s">        sage: binomial(-2, 5)</span>
<span class="s">        -6</span>
<span class="s">        sage: binomial(RealField()(&#39;2.5&#39;), 2)</span>
<span class="s">        1.87500000000000</span>
<span class="s">        sage: n=var(&#39;n&#39;); binomial(n,2)</span>
<span class="s">        1/2*(n - 1)*n</span>
<span class="s">        sage: n=var(&#39;n&#39;); binomial(n,n)</span>
<span class="s">        1</span>
<span class="s">        sage: n=var(&#39;n&#39;); binomial(n,n-1)</span>
<span class="s">        n</span>
<span class="s">        sage: binomial(2^100, 2^100)</span>
<span class="s">        1</span>

<span class="s">        sage: k, i = var(&#39;k,i&#39;)</span>
<span class="s">        sage: binomial(k,i)</span>
<span class="s">        binomial(k, i)</span>

<span class="s">    TESTS:</span>

<span class="s">    We test that certain binomials are very fast (this should be</span>
<span class="s">    instant) -- see trac 3309::</span>

<span class="s">        sage: a = binomial(RR(1140000.78), 42000000)</span>

<span class="s">    We test conversion of arguments to Integers -- see trac 6870::</span>

<span class="s">        sage: binomial(1/2,1/1)</span>
<span class="s">        1/2</span>
<span class="s">        sage: binomial(10^20+1/1,10^20)</span>
<span class="s">        100000000000000000001</span>
<span class="s">        sage: binomial(SR(10**7),10**7)</span>
<span class="s">        1</span>
<span class="s">        sage: binomial(3/2,SR(1/1))</span>
<span class="s">        3/2</span>

<span class="s">    Some floating point cases -- see trac 7562::</span>

<span class="s">        sage: binomial(1.,3)</span>
<span class="s">        0.000000000000000</span>
<span class="s">        sage: binomial(-2.,3)</span>
<span class="s">        -4.00000000000000</span>
<span class="s">    &quot;&quot;&quot;</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">m</span><span class="p">,</span><span class="n">sage</span><span class="o">.</span><span class="n">symbolic</span><span class="o">.</span><span class="n">expression</span><span class="o">.</span><span class="n">Expression</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="c"># For performance reasons, we avoid to try to coerce</span>
            <span class="c"># to Integer in the symbolic case (see #6870)</span>
            <span class="n">m</span><span class="o">=</span><span class="n">m</span><span class="o">.</span><span class="n">pyobject</span><span class="p">()</span>
            <span class="n">m</span><span class="o">=</span><span class="n">ZZ</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
            <span class="k">pass</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">m</span><span class="o">=</span><span class="n">ZZ</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
            <span class="k">pass</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">m</span><span class="p">,</span><span class="n">integer</span><span class="o">.</span><span class="n">Integer</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">m</span> <span class="o">=</span> <span class="n">ZZ</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">m</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">x</span><span class="o">.</span><span class="n">binomial</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
            <span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
                <span class="k">pass</span>
            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">,</span> <span class="s">&#39;Either m or x-m must be an integer&#39;</span>
    <span class="c"># a (hopefully) temporary fix for #3309; eventually Pari should do</span>
    <span class="c"># this for us.</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">(</span><span class="nb">float</span><span class="p">,</span> <span class="n">sage</span><span class="o">.</span><span class="n">rings</span><span class="o">.</span><span class="n">real_mpfr</span><span class="o">.</span><span class="n">RealNumber</span><span class="p">,</span>
                      <span class="n">sage</span><span class="o">.</span><span class="n">rings</span><span class="o">.</span><span class="n">real_mpfr</span><span class="o">.</span><span class="n">RealLiteral</span><span class="p">)):</span>
        <span class="n">P</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">parent</span><span class="p">()</span>
        <span class="k">if</span> <span class="n">m</span> <span class="o">&lt;</span> <span class="mf">0</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">P</span><span class="p">(</span><span class="mf">0</span><span class="p">)</span>
        <span class="kn">from</span> <span class="nn">sage.functions.all</span> <span class="kn">import</span> <span class="n">gamma</span>
        <span class="k">if</span> <span class="n">x</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mf">1</span><span class="o">/</span><span class="mf">2</span><span class="p">:</span>
            <span class="n">a</span> <span class="o">=</span> <span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">m</span><span class="o">+</span><span class="mf">1</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">a</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="mf">1</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="n">P</span><span class="p">(</span><span class="n">m</span><span class="o">+</span><span class="mf">1</span><span class="p">))</span><span class="o">/</span><span class="n">a</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">P</span><span class="p">(</span><span class="mf">0</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="k">return</span> <span class="p">(</span><span class="o">-</span><span class="mf">1</span><span class="p">)</span><span class="o">**</span><span class="n">m</span><span class="o">*</span><span class="n">gamma</span><span class="p">(</span><span class="n">m</span><span class="o">-</span><span class="n">x</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="n">P</span><span class="p">(</span><span class="n">m</span><span class="o">+</span><span class="mf">1</span><span class="p">))</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="o">-</span><span class="n">x</span><span class="p">)</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">sage</span><span class="o">.</span><span class="n">symbolic</span><span class="o">.</span><span class="n">expression</span><span class="o">.</span><span class="n">Expression</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="o">.</span><span class="n">pyobject</span><span class="p">()</span>
            <span class="n">x</span><span class="o">=</span><span class="n">ZZ</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
            <span class="k">pass</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">x</span><span class="o">=</span><span class="n">ZZ</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
            <span class="k">pass</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">integer</span><span class="o">.</span><span class="n">Integer</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">x</span> <span class="o">&gt;=</span> <span class="mf">0</span> <span class="ow">and</span> <span class="p">(</span><span class="n">m</span> <span class="o">&lt;</span> <span class="mf">0</span> <span class="ow">or</span> <span class="n">m</span> <span class="o">&gt;</span> <span class="n">x</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">ZZ</span><span class="p">(</span><span class="mf">0</span><span class="p">)</span>

        <span class="k">if</span> <span class="n">m</span> <span class="o">&gt;</span> <span class="n">sys</span><span class="o">.</span><span class="n">maxint</span><span class="p">:</span>
            <span class="n">m</span> <span class="o">=</span> <span class="n">x</span> <span class="o">-</span> <span class="n">m</span>
            <span class="k">if</span> <span class="n">m</span> <span class="o">&gt;</span> <span class="n">sys</span><span class="o">.</span><span class="n">maxint</span><span class="p">:</span>
                <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">&quot;binomial not implemented for m &gt;= 2^32.</span><span class="se">\n</span><span class="s">This is probably OK, since the answer would have billions of digits.&quot;</span>

        <span class="k">return</span> <span class="n">ZZ</span><span class="p">(</span><span class="n">pari</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">binomial</span><span class="p">(</span><span class="n">m</span><span class="p">))</span>
    <span class="k">try</span><span class="p">:</span>
        <span class="n">P</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">parent</span><span class="p">()</span>
    <span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
        <span class="n">P</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
    <span class="k">if</span> <span class="n">m</span> <span class="o">&lt;</span> <span class="mf">0</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">P</span><span class="p">(</span><span class="mf">0</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">misc</span><span class="o">.</span><span class="n">prod</span><span class="p">([</span><span class="n">x</span><span class="o">-</span><span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">xrange</span><span class="p">(</span><span class="n">m</span><span class="p">)])</span> <span class="o">/</span> <span class="n">P</span><span class="p">(</span><span class="n">factorial</span><span class="p">(</span><span class="n">m</span><span class="p">))</span>
</pre></div>
</div>


</div>
</html>
}}}

<h1 id="SageAnnotation" style="font-size: 2em;">Annotating with Sage</h1>
<p>Whether one uses Sage in the classroom or in research, it is usually helpful to describe to the reader what is being done, such as in the description you are now reading. &nbsp;&nbsp;Thanks to&nbsp;<a title="Open external site in a new window" href="http://tinymce.moxiecode.com/" target="_blank">the mini-word processor TinyMCE</a>&nbsp;and a TeX rendering engine called&nbsp;<a title="Open external site in a new window" href="http://www.math.union.edu/~dpvc/jsMath/" target="_blank">jsmath</a>, you can type much more in Sage than just Sage commands.&nbsp; This math-aware word processor makes Sage perfect annotating computations.&nbsp;</p>
<p>To use the word processor, we create a&nbsp;<em>text cell</em>&nbsp;(as opposed to a&nbsp;<em>input cell</em>&nbsp;that contains Sage commands that Sage evaluates).&nbsp; To create a text cell, first move the cursor between two input cells. &nbsp;Then hold the Shift key and then click on the thin blue line that appears. (Notice that to create an input cell, one merely clicks, but one "Shift-Click"s to create a text cell.)</p>
<p>Now try inserting a text cell between the input cells below.</p>

{{{id=147|

///
}}}

{{{id=146|

///
}}}

<p>TinyMCE makes it easy for format text in many ways.&nbsp; Try experimenting with the usual <strong>bold</strong> button, <span style="text-decoration: underline;">underline</span> button, different text <span style="font-family: 'comic sans ms', sans-serif;">fonts</span> and <span style="background-color: #00ffff;"><span style="color: #ff0000;">colors</span></span>, ordered and unordered lists, centering, and so on. &nbsp;Some of the shortcut keys you are familiar with from other word processors may also work, depending on your system.</p>
<p>There are two other things you can do which take advantage of the worksheet being on the web. &nbsp;</p>
<ul>
<li>It is easy to link to other helpful websites for additional information. &nbsp;While in the editor, highlight a word or two, and then click on the little chain link toward the bottom right of the buttons. &nbsp;You can now type in a web address to link to. &nbsp;Be sure to prepend http:// to the address; normally, one should also select it to appear in a new window (so the Sage session isn't interrupted).</li>
<li>You may have already noticed that some of the descriptions above had typeset mathematics in them. In fact we can add nearly arbitrary LaTeX to our text cells! &nbsp;For instance, it isn't too hard to add things like $$\zeta(s)=\sum_{n=1}^{\infty}\frac{1}{n^s}=\prod_p \left(\frac{1}{1-p^{-s}}\right)$$ by just typing things like&nbsp;"\$\$\zeta(s)=\sum_{n=1}^{\infty}\frac{1}{n^s}=\prod_p \left(\frac{1}{1-p^{-s}}\right)\$\$" in the word processor. &nbsp;Whether this shows up as nicely as possible depends on what fonts you have in your browser, but it should be legible. &nbsp;More realistically, we might type "\$f(x)=x^2\$" so that we remember that $f(x)=x^2$ in this worksheet.</li>
</ul>
<p>To edit a text cell, simply double-click on the text.&nbsp; Try double-clicking on this text to edit this text cell (and you can see how we typed the mathematics above!).</p>
<ul>
</ul>

{{{id=154|
f(x)=x^2
f(9)
///
81
}}}

<p>If $f(x)=x^2$, then $f(9)=81$.</p>

{{{id=157|

///
}}}

<p>Of course, one can do much more, since Sage can execute arbitrary commands in the&nbsp;<a href="http://www.python.org" target="_blank">Python</a>&nbsp;programming language, as well as output nicely formatted HTML, and so on. &nbsp;If you have enough programming experience to do things like this, go for it!</p>

{{{id=155|
print "<html>Sage is <a style='text-decoration:line-through'>somewhat</a> <b>really</b> cool! <p style='color:red'>(It even does HTML.)</p></html>"
///
<html>Sage is <a style='text-decoration:line-through'>somewhat</a> <b>really</b> cool! <p style='color:red'>(It even does HTML.)</p></html>
}}}

<p>That's the end of the introductory tutorial. &nbsp;Feel free to create more of your own worksheets, or watch for additional tutorials coming soon!</p>

{{{id=156|

///
}}}