{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\"drawing\"\n", "

Experimental Mathematics Using SageMath — AIMS-ZA-2024-25

\n", "\n", "\n", "## Instructors: \n", "\n", "\n", "* **Evans Ocansey**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "****\n", "\n", "\n", "< [Table of contents](ems_2024_25_day_00_table_of_contents.ipynb) | [2. Review of Python programming](ems_2024_25_day_02_short_review_on_python_programming.ipynb) >\n", "\n", "\n", "****" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Day 01 — Introduction to [SageMath](http://www.sagemath.org): A Computer Algebra System for All \n", "\n", "[comment]: <> (

Day 02 — Introduction to SageMath: A Mathematics Software for All

)\n", "\n", "\n", "The outline of the this notebook is as follows:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Table of Contents: \n", "* [ ] [What is SageMath?](#what-is-sagemath)\n", " * [A Brief Overview](#a-brief-overview)\n", " * [Using Other Non-Commercial Softwares](#using-non-commerical-softwares)\n", "[comment]: <> (Help Inside SageMath)\n", "* [ ] [Help Inside SageMath](#help-inside-sagemath)\n", " * [Documentation](#documetation)\n", " * [Tab Completion](#tab-completion)\n", "[comment]: <> (Complete Access to Source Code)\n", "* [ ] [Complete Access to Source Code](#complete-access-to-source-code)\n", " * [Exercise 1](#exercise-1)\n", "[comment]: <> (Just the Basics) \n", "* [ ] [Just the Basics](#just-the-basics)\n", " * [Sage as a Calculator](#sagemath-as-a-calculator)\n", " * [Exercise 2](#exercise-2)\n", " * [Elementary Functions and Usual Constants](#elementary-functions-and-usual-constants)\n", " * [Python Variables](#python-variables)\n", " * [Symbolic Variables](#symbolic-variables)\n", " * [Exercise 3](#exercise-3)\n", " * [Linear Algebra — Some Basics](#linear-algebra-some-basics)\n", " * [Calculus — Some Basics](#calculus-some-basics)\n", " * [Plotting in Brief](#plotting-in-brief)\n", "[comment]: <> (Short Demonstration of Packages) \n", "* [ ] [Demonstration of Some SageMath Components](#demonstration-of-some-sagemath-components)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## What is SageMath? \n", "\n", "\n", "1. An open source system for advanced mathematics.\n", "2. An open source mathematics distribution (like Linux) with *Python* as the glue.\n", "3. A tool for learning and teaching mathematics.\n", "4. A tool for mathematics research.\n", "\n", "![image info](./images/sagemath-logo.png)\n", "\n", "

Mission Statement: Create a viable free open source alternative to Magma, Maple, Mathematica, and Matlab.

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A Brief Overview \n", "\n", "- Created in 2005 by William Stein.\n", "- Free and open, GPL license.\n", "- Includes about 100 open source packages.\n", "- Now has around 500,000+ lines of new code, by several hundred mathematician-programmers.\n", "\n", "Some of the 100 packages includes:\n", "\n", "- [Groups, Algorithms, Programming (GAP)](https://www.gap-system.org/) - group theory\n", "- [PARI](https://pari.math.u-bordeaux.fr/) - rings, finite fields, field extensions, number theory\n", "- [Singular](https://www.singular.uni-kl.de/) - commutative algebra\n", "- [NumPy](http://www.numpy.org/)/[SciPy](https://www.scipy.org/) - numerical linear algebra, scientific computing\n", "- [Integer Matrix Library (IML)](https://cs.uwaterloo.ca/~astorjoh/iml.html) - integer, rational matrices\n", "- [CVXOPT](https://cvxopt.org/) - linear programming, optimization\n", "- [NetworkX](https://networkx.github.io/) - graph theory\n", "- [Pynac](http://pynac.org/) - symbolic manipulation\n", "- [Maxima](http://maxima.sourceforge.net/) - calculus, differential equations\n", "- [R](https://www.r-project.org/) - for statistical computing\n", "- [Ore Algebra](http://kauers.de/software.html) - computations with Ore operators\n", "\n", "Click [**here**](https://www.sagemath.org/links-components.html) to see all software packages that constitute SageMath." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using Other Non-Commercial Softwares \n", "\n", "As mentioned earlier, [SageMath](http://www.sagemath.org/) includes about 100 open source packages and these packages can be run separately in either a [SageMath](http://www.sagemath.org/) worksheet or in a [Jupyter](https://jupyter.org/) notebook. There are several ways one can use this. I will only demonstrate a few." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Group( [ (1,2), (1,2,3,4,5,6,7,8) ] )" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "S_8 = gap('Group( (1,2), (1,2,3,4,5,6,7,8) )'); S_8" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Group([ (1,2), (1,2,3,4,5,6,7,8) ])\n" ] } ], "source": [ "%%gap\n", "\n", "S := Group( (1,2), (1,2,3,4,5,6,7,8) )" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "x^7+x^2+x" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "maxima('lsum(x^i, i, [1, 2, 7])')" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x^7+x^2+x\n" ] } ], "source": [ "%%maxima\n", "\n", "lsum (x^i, i, [1, 2, 7]);" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "%%python\n", "\n", "print(map(lambda x : x**2, [1,3,5])) # note the operation ** and not the same as ^ in Python but in Sage they are." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "// coefficients: QQ\n", "// number of vars : 3\n", "// block 1 : ordering lp\n", "// : names x y z\n", "// block 2 : ordering C\n" ] } ], "source": [ "%%singular\n", "\n", "ring R = 0,(x,y,z), lp; R;" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " MPG.city\n", "Origin 15 16 17 18 19 20 21 22 23 24 25 26 28 29 30 31 32 33 39 42 46\n", " USA 2 3 4 5 8 3 3 4 7 2 2 0 1 2 0 2 0 0 0 0 0\n", " non-USA 0 0 4 7 2 5 3 3 1 3 4 2 1 4 1 0 1 1 1 1 1\n" ] } ], "source": [ "%%r\n", "library(\"MASS\")\n", "data(Cars93)\n", "mean(Cars93$MPG.city)\n", "xtabs( ~ Origin + MPG.city, data=Cars93)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1] 1 2 3 4\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "IOStream.flush timed out\n" ] } ], "source": [ "%%r\n", "\n", "d = c(1,2,3,4)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ans =\n", "\n", " 0.633673 0.120137\n", " 0.183186 0.234952\n", " 0.771881 0.308574\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "IOStream.flush timed out\n" ] } ], "source": [ "%%octave\n", "rand (3, 2) # This is will output a 3x2 matrix whose entries are randomly generated between 0 and 1." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Section**](#help-inside-sagemath)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Help Inside [SageMath](http://www.sagemath.org/) \n", "\n", "There are various ways to get help in [SageMath](http://www.sagemath.org/). Here are several common ways to get help as you are working in the [Jupyter](https://jupyter.org/) notebook." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Documentation \n", "\n", "[SageMath](http://www.sagemath.org/) includes extensive documentation covering thousands of functions, with many examples, tutorials, and other helps.\n", "\n", "- One way to access these is to click the “Help” link at the top right of any worksheet. This page has lots of useful commands for the notebook. At the top it has a list of documents; you can click your preferred option at the top of the help page.\n", "- They are also available any time online at the [SageMath](http://www.sagemath.org/help.html) website, which has many other links, like video introductions.\n", "- The [Quick Reference Cards](http://wiki.sagemath.org/quickref) are another useful tool once you get more familiar with SageMath." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tab Completion \n", "\n", "The most useful help available in the notebook is “*__tab completion__*”. The idea is that even if you are not one hundred percent sure of the name of a command, the first few letters should still be enough to help find it. Here’s an example.\n", "\n", "- Suppose you want to do a specific type of plot - maybe a _slope field plot_ - but aren’t quite sure what will do it.\n", "- Still, it seems reasonable that the command might start with _pl_ .\n", "- Then one can type _pl_ in an input cell, and then press the Tab key to see all the commands that start with the letters _pl_ .\n", "\n", "Try tabbing after the _pl_ in the following cell to see all the commands that start with the letters _pl_. You should see that `plot_slope_field` is one of them." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x,y = var('x y')\n", "capacity = 3 # thousand\n", "growth_rate = 0.7 # population increases by 70% per unit of time\n", "plot_slope_field(growth_rate * (1-y/capacity) * y, (x,0,5), (y,0,capacity*2))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\u001b[0;31mSignature:\u001b[0m \u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfuncs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mDocstring:\u001b[0m \n", " Use plot by writing\n", "\n", " \"plot(X, ...)\"\n", "\n", " where X is a Sage object (or list of Sage objects) that either is\n", " callable and returns numbers that can be coerced to floats, or has\n", " a plot method that returns a \"GraphicPrimitive\" object.\n", "\n", " There are many other specialized 2D plot commands available in\n", " Sage, such as \"plot_slope_field\", as well as various graphics\n", " primitives like \"Arrow\"; type \"sage.plot.plot?\" for a current list.\n", "\n", " Type \"plot.options\" for a dictionary of the default options for\n", " plots. You can change this to change the defaults for all future\n", " plots. Use \"plot.reset()\" to reset to the default options.\n", "\n", " PLOT OPTIONS:\n", "\n", " * \"plot_points\" -- (default: 200); the minimal number of plot\n", " points.\n", "\n", " * \"adaptive_recursion\" -- (default: 5); how many levels of\n", " recursion to go before giving up when doing adaptive refinement.\n", " Setting this to 0 disables adaptive refinement.\n", "\n", " * \"adaptive_tolerance\" -- (default: 0.01); how large a difference\n", " should be before the adaptive refinement code considers it\n", " significant. See the documentation further below for more\n", " information, starting at \"the algorithm used to insert\".\n", "\n", " * \"imaginary_tolerance\" -- (default: \"1e-8\"); if an imaginary\n", " number arises (due, for example, to numerical issues), this\n", " tolerance specifies how large it has to be in magnitude before we\n", " raise an error. In other words, imaginary parts smaller than\n", " this are ignored in your plot points.\n", "\n", " * \"base\" -- (default: 10); the base of the logarithm if a\n", " logarithmic scale is set. This must be greater than 1. The base\n", " can be also given as a list or tuple \"(basex, basey)\". \"basex\"\n", " sets the base of the logarithm along the horizontal axis and\n", " \"basey\" sets the base along the vertical axis.\n", "\n", " * \"scale\" -- string (default: \"\"linear\"\"); scale of the axes.\n", " Possible values are \"\"linear\"\", \"\"loglog\"\", \"\"semilogx\"\",\n", " \"\"semilogy\"\".\n", "\n", " The scale can be also be given as single argument that is a list\n", " or tuple \"(scale, base)\" or \"(scale, basex, basey)\".\n", "\n", " The \"\"loglog\"\" scale sets both the horizontal and vertical axes\n", " to logarithmic scale. The \"\"semilogx\"\" scale sets the horizontal\n", " axis to logarithmic scale. The \"\"semilogy\"\" scale sets the\n", " vertical axis to logarithmic scale. The \"\"linear\"\" scale is the\n", " default value when \"Graphics\" is initialized.\n", "\n", " * \"xmin\" -- starting x value in the rendered figure. This parameter\n", " is passed directly to the \"show\" procedure and it could be\n", " overwritten.\n", "\n", " * \"xmax\" -- ending x value in the rendered figure. This parameter\n", " is passed directly to the \"show\" procedure and it could be\n", " overwritten.\n", "\n", " * \"ymin\" -- starting y value in the rendered figure. This parameter\n", " is passed directly to the \"show\" procedure and it could be\n", " overwritten.\n", "\n", " * \"ymax\" -- ending y value in the rendered figure. This parameter\n", " is passed directly to the \"show\" procedure and it could be\n", " overwritten.\n", "\n", " * \"detect_poles\" -- (default: \"False\") If set to \"True\" poles are\n", " detected. If set to \"show\" vertical asymptotes are drawn.\n", "\n", " * \"legend_label\" -- a (TeX) string serving as the label for X in\n", " the legend. If X is a list, then this option can be a single\n", " string, or a list or dictionary with strings as entries/values.\n", " If a dictionary, then keys are taken from \"range(len(X))\".\n", "\n", " Note:\n", "\n", " * If the \"scale\" is \"\"linear\"\", then irrespective of what \"base\"\n", " is set to, it will default to 10 and will remain unused.\n", "\n", " * If you want to limit the plot along the horizontal axis in the\n", " final rendered figure, then pass the \"xmin\" and \"xmax\" keywords\n", " to the \"show()\" method. To limit the plot along the vertical\n", " axis, \"ymin\" and \"ymax\" keywords can be provided to either this\n", " \"plot\" command or to the \"show\" command.\n", "\n", " * This function does NOT simply sample equally spaced points\n", " between xmin and xmax. Instead it computes equally spaced\n", " points and adds small perturbations to them. This reduces the\n", " possibility of, e.g., sampling \\sin only at multiples of 2\\pi,\n", " which would yield a very misleading graph.\n", "\n", " * If there is a range of consecutive points where the function\n", " has no value, then those points will be excluded from the plot.\n", " See the example below on automatic exclusion of points.\n", "\n", " * For the other keyword options that the \"plot\" function can\n", " take, refer to the method \"show()\" and the further options\n", " below.\n", "\n", " COLOR OPTIONS:\n", "\n", " * \"color\" -- (Default: 'blue') One of:\n", "\n", " * an RGB tuple (r,g,b) with each of r,g,b between 0 and 1.\n", "\n", " * a color name as a string (e.g., 'purple').\n", "\n", " * an HTML color such as '#aaff0b'.\n", "\n", " * a list or dictionary of colors (valid only if X is a list): if\n", " a dictionary, keys are taken from \"range(len(X))\"; the\n", " entries/values of the list/dictionary may be any of the options\n", " above.\n", "\n", " * 'automatic' -- maps to default ('blue') if X is a single Sage\n", " object; and maps to a fixed sequence of regularly spaced colors\n", " if X is a list.\n", "\n", " * \"legend_color\" -- the color of the text for X (or each item in X)\n", " in the legend.\n", " Default color is 'black'. Options are as in \"color\" above,\n", " except that the choice 'automatic' maps to 'black' if X is a\n", " single Sage object.\n", "\n", " * \"fillcolor\" -- The color of the fill for the plot of X (or each\n", " item in X).\n", " Default color is 'gray' if X is a single Sage object or if\n", " \"color\" is a single color. Otherwise, options are as in\n", " \"color\" above.\n", "\n", " APPEARANCE OPTIONS:\n", "\n", " The following options affect the appearance of the line through the\n", " points on the graph of X (these are the same as for the line\n", " function):\n", "\n", " INPUT:\n", "\n", " * \"alpha\" -- how transparent the line is\n", "\n", " * \"thickness\" -- how thick the line is\n", "\n", " * \"rgbcolor\" -- the color as an RGB tuple\n", "\n", " * \"hue\" -- the color given as a hue\n", "\n", " LINE OPTIONS:\n", "\n", " Any MATPLOTLIB line option may also be passed in. E.g.,\n", "\n", " * \"linestyle\" -- (default: \"-\") The style of the line, which is one\n", " of\n", "\n", " * \"\"-\"\" or \"\"solid\"\"\n", "\n", " * \"\"--\"\" or \"\"dashed\"\"\n", "\n", " * \"\"-.\"\" or \"\"dash dot\"\"\n", "\n", " * \"\":\"\" or \"\"dotted\"\"\n", "\n", " * \"\"None\"\" or \"\" \"\" or \"\"\"\" (nothing)\n", "\n", " * a list or dictionary (see below)\n", "\n", " The linestyle can also be prefixed with a drawing style (e.g.,\n", " \"\"steps--\"\")\n", "\n", " * \"\"default\"\" (connect the points with straight lines)\n", "\n", " * \"\"steps\"\" or \"\"steps-pre\"\" (step function; horizontal line is\n", " to the left of point)\n", "\n", " * \"\"steps-mid\"\" (step function; points are in the middle of\n", " horizontal lines)\n", "\n", " * \"\"steps-post\"\" (step function; horizontal line is to the right\n", " of point)\n", "\n", " If X is a list, then \"linestyle\" may be a list (with entries\n", " taken from the strings above) or a dictionary (with keys in\n", " \"range(len(X))\" and values taken from the strings above).\n", "\n", " * \"marker\" -- The style of the markers, which is one of\n", "\n", " * \"\"None\"\" or \"\" \"\" or \"\"\"\" (nothing) -- default\n", "\n", " * \"\",\"\" (pixel), \"\".\"\" (point)\n", "\n", " * \"\"_\"\" (horizontal line), \"\"|\"\" (vertical line)\n", "\n", " * \"\"o\"\" (circle), \"\"p\"\" (pentagon), \"\"s\"\" (square), \"\"x\"\" (x),\n", " \"\"+\"\" (plus), \"\"*\"\" (star)\n", "\n", " * \"\"D\"\" (diamond), \"\"d\"\" (thin diamond)\n", "\n", " * \"\"H\"\" (hexagon), \"\"h\"\" (alternative hexagon)\n", "\n", " * \"\"<\"\" (triangle left), \"\">\"\" (triangle right), \"\"^\"\" (triangle\n", " up), \"\"v\"\" (triangle down)\n", "\n", " * \"\"1\"\" (tri down), \"\"2\"\" (tri up), \"\"3\"\" (tri left), \"\"4\"\" (tri\n", " right)\n", "\n", " * \"0\" (tick left), \"1\" (tick right), \"2\" (tick up), \"3\" (tick\n", " down)\n", "\n", " * \"4\" (caret left), \"5\" (caret right), \"6\" (caret up), \"7\" (caret\n", " down), \"8\" (octagon)\n", "\n", " * \"\"$...$\"\" (math TeX string)\n", "\n", " * \"(numsides, style, angle)\" to create a custom, regular symbol\n", "\n", " * \"numsides\" -- the number of sides\n", "\n", " * \"style\" -- \"0\" (regular polygon), \"1\" (star shape), \"2\"\n", " (asterisk), \"3\" (circle)\n", "\n", " * \"angle\" -- the angular rotation in degrees\n", "\n", " * \"markersize\" -- the size of the marker in points\n", "\n", " * \"markeredgecolor\" -- the color of the marker edge\n", "\n", " * \"markerfacecolor\" -- the color of the marker face\n", "\n", " * \"markeredgewidth\" -- the size of the marker edge in points\n", "\n", " * \"exclude\" -- (Default: None) values which are excluded from the\n", " plot range. Either a list of real numbers, or an equation in one\n", " variable.\n", "\n", " FILLING OPTIONS:\n", "\n", " * \"fill\" -- (default: \"False\") One of:\n", "\n", " * \"axis\" or \"True\": Fill the area between the function and the\n", " x-axis.\n", "\n", " * \"min\": Fill the area between the function and its minimal\n", " value.\n", "\n", " * \"max\": Fill the area between the function and its maximal\n", " value.\n", "\n", " * a number c: Fill the area between the function and the\n", " horizontal line y = c.\n", "\n", " * a function g: Fill the area between the function that is\n", " plotted and g.\n", "\n", " * a dictionary \"d\" (only if a list of functions are plotted): The\n", " keys of the dictionary should be integers. The value of \"d[i]\"\n", " specifies the fill options for the i-th function in the list.\n", " If \"d[i] == [j]\": Fill the area between the i-th and the j-th\n", " function in the list. (But if \"d[i] == j\": Fill the area\n", " between the i-th function in the list and the horizontal line y\n", " = j.)\n", "\n", " * \"fillalpha\" -- (default: 0.5) How transparent the fill is. A\n", " number between 0 and 1.\n", "\n", " MATPLOTLIB STYLE SHEET OPTION:\n", "\n", " * \"stylesheet\" -- (Default: classic) Support for loading a full\n", " matplotlib style sheet. Any style sheet listed in\n", " \"matplotlib.pyplot.style.available\" is acceptable. If a non-\n", " existing style is provided the default classic is applied.\n", "\n", " EXAMPLES:\n", "\n", " We plot the \\sin function:\n", "\n", " sage: P = plot(sin, (0,10)); print(P)\n", " Graphics object consisting of 1 graphics primitive\n", " sage: len(P) # number of graphics primitives\n", " 1\n", " sage: len(P[0]) # how many points were computed (random)\n", " 225\n", " sage: P # render\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: P = plot(sin, (0,10), plot_points=10); print(P)\n", " Graphics object consisting of 1 graphics primitive\n", " sage: len(P[0]) # random output\n", " 32\n", " sage: P # render\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We plot with \"randomize=False\", which makes the initial sample\n", " points evenly spaced (hence always the same). Adaptive plotting\n", " might insert other points, however, unless \"adaptive_recursion=0\".\n", "\n", " sage: p = plot(1, (x,0,3), plot_points=4, randomize=False, adaptive_recursion=0)\n", " sage: list(p[0])\n", " [(0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (3.0, 1.0)]\n", "\n", " Some colored functions:\n", "\n", " sage: plot(sin, 0, 10, color='purple')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin, 0, 10, color='#ff00ff')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We plot several functions together by passing a list of functions\n", " as input:\n", "\n", " sage: plot([x*exp(-n*x^2)/.4 for n in [1..5]], (0, 2), aspect_ratio=.8)\n", " Graphics object consisting of 5 graphics primitives\n", "\n", " By default, color will change from one primitive to the next. This\n", " may be controlled by modifying \"color\" option:\n", "\n", " sage: g1 = plot([x*exp(-n*x^2)/.4 for n in [1..3]], (0, 2),\n", " ....: color='blue', aspect_ratio=.8); g1\n", " Graphics object consisting of 3 graphics primitives\n", " sage: g2 = plot([x*exp(-n*x^2)/.4 for n in [1..3]], (0, 2),\n", " ....: color=['red','red','green'], linestyle=['-','--','-.'],\n", " ....: aspect_ratio=.8); g2\n", " Graphics object consisting of 3 graphics primitives\n", "\n", " While plotting real functions, imaginary numbers that are \"almost\n", " real\" will inevitably arise due to numerical issues. By tweaking\n", " the \"imaginary_tolerance\", you can decide how large of an imaginary\n", " part you're willing to sweep under the rug in order to plot the\n", " corresponding point. If a particular value's imaginary part has\n", " magnitude larger than \"imaginary_tolerance\", that point will not be\n", " plotted. The default tolerance is \"1e-8\", so the imaginary part in\n", " the first example below is ignored, but the second example \"fails,\"\n", " emits a warning, and produces an empty graph:\n", "\n", " sage: f = x + I*1e-12\n", " sage: plot(f, x, -1, 1)\n", " Graphics object consisting of 1 graphics primitive\n", " sage: plot(f, x, -1, 1, imaginary_tolerance=0)\n", " ...WARNING: ...Unable to compute ...\n", " Graphics object consisting of 0 graphics primitives\n", "\n", " We can also build a plot step by step from an empty plot:\n", "\n", " sage: a = plot([]); a # passing an empty list returns an empty plot (Graphics() object)\n", " Graphics object consisting of 0 graphics primitives\n", " sage: a += plot(x**2); a # append another plot\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: a += plot(x**3); a # append yet another plot\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " The function \\sin(1/x) wiggles wildly near 0. Sage adapts to this\n", " and plots extra points near the origin.\n", "\n", " sage: plot(sin(1/x), (x, -1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " Via the matplotlib library, Sage makes it easy to tell whether a\n", " graph is on both sides of both axes, as the axes only cross if the\n", " origin is actually part of the viewing area:\n", "\n", " sage: plot(x^3, (x,0,2)) # this one has the origin\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(x^3, (x,1,2)) # this one does not\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " Another thing to be aware of with axis labeling is that when the\n", " labels have quite different orders of magnitude or are very large,\n", " scientific notation (the e notation for powers of ten) is used:\n", "\n", " sage: plot(x^2, (x,480,500)) # this one has no scientific notation\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(x^2, (x,300,500)) # this one has scientific notation on y-axis\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " You can put a legend with \"legend_label\" (the legend is only put\n", " once in the case of multiple functions):\n", "\n", " sage: plot(exp(x), 0, 2, legend_label='$e^x$')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " Sage understands TeX, so these all are slightly different, and you\n", " can choose one based on your needs:\n", "\n", " sage: plot(sin, legend_label='sin')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin, legend_label='$sin$')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin, legend_label=r'$\\sin$')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " It is possible to use a different color for the text of each label:\n", "\n", " sage: p1 = plot(sin, legend_label='sin', legend_color='red')\n", " sage: p2 = plot(cos, legend_label='cos', legend_color='green')\n", " sage: p1 + p2\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " Prior to https://github.com/sagemath/sage/issues/19485, legends by\n", " default had a shadowless gray background. This behavior can be\n", " recovered by setting the legend options on your plot object:\n", "\n", " sage: p = plot(sin(x), legend_label=r'$\\sin(x)$')\n", " sage: p.set_legend_options(back_color=(0.9,0.9,0.9), shadow=False)\n", "\n", " If X is a list of Sage objects and \"legend_label\" is 'automatic',\n", " then Sage will create labels for each function according to their\n", " internal representation:\n", "\n", " sage: plot([sin(x), tan(x), 1 - x^2], legend_label='automatic')\n", " Graphics object consisting of 3 graphics primitives\n", "\n", " If \"legend_label\" is any single string other than 'automatic', then\n", " it is repeated for all members of X:\n", "\n", " sage: plot([sin(x), tan(x)], color='blue', legend_label='trig')\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " Note that the independent variable may be omitted if there is no\n", " ambiguity:\n", "\n", " sage: plot(sin(1.0/x), (-1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " Plotting in logarithmic scale is possible for 2D plots. There are\n", " two different syntaxes supported:\n", "\n", " sage: plot(exp, (1, 10), scale='semilogy') # log axis on vertical\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot_semilogy(exp, (1, 10)) # same thing\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot_loglog(exp, (1, 10)) # both axes are log\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(exp, (1, 10), scale='loglog', base=2) # base of log is 2 # long time\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We can also change the scale of the axes in the graphics just\n", " before displaying:\n", "\n", " sage: G = plot(exp, 1, 10) # long time\n", " sage: G.show(scale=('semilogy', 2)) # long time\n", "\n", " The algorithm used to insert extra points is actually pretty\n", " simple. On the picture drawn by the lines below:\n", "\n", " sage: p = plot(x^2, (-0.5, 1.4)) + line([(0,0), (1,1)], color='green')\n", " sage: p += line([(0.5, 0.5), (0.5, 0.5^2)], color='purple')\n", " sage: p += point(((0, 0), (0.5, 0.5), (0.5, 0.5^2), (1, 1)),\n", " ....: color='red', pointsize=20)\n", " sage: p += text('A', (-0.05, 0.1), color='red')\n", " sage: p += text('B', (1.01, 1.1), color='red')\n", " sage: p += text('C', (0.48, 0.57), color='red')\n", " sage: p += text('D', (0.53, 0.18), color='red')\n", " sage: p.show(axes=False, xmin=-0.5, xmax=1.4, ymin=0, ymax=2)\n", "\n", " You have the function (in blue) and its approximation (in green)\n", " passing through the points A and B. The algorithm finds the\n", " midpoint C of AB and computes the distance between C and D. If that\n", " distance exceeds the \"adaptive_tolerance\" threshold (*relative* to\n", " the size of the initial plot subintervals), the point D is added to\n", " the curve. If D is added to the curve, then the algorithm is\n", " applied recursively to the points A and D, and D and B. It is\n", " repeated \"adaptive_recursion\" times (5, by default).\n", "\n", " The actual sample points are slightly randomized, so the above\n", " plots may look slightly different each time you draw them.\n", "\n", " We draw the graph of an elliptic curve as the union of graphs of 2\n", " functions.\n", "\n", " sage: def h1(x): return abs(sqrt(x^3 - 1))\n", " sage: def h2(x): return -abs(sqrt(x^3 - 1))\n", " sage: P = plot([h1, h2], 1,4)\n", " sage: P # show the result\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " It is important to mention that when we draw several graphs at the\n", " same time, parameters \"xmin\", \"xmax\", \"ymin\" and \"ymax\" are just\n", " passed directly to the \"show\" procedure. In fact, these parameters\n", " would be overwritten:\n", "\n", " sage: p=plot(x^3, x, xmin=-1, xmax=1,ymin=-1, ymax=1)\n", " sage: q=plot(exp(x), x, xmin=-2, xmax=2, ymin=0, ymax=4)\n", " sage: (p+q).show()\n", "\n", " As a workaround, we can perform the trick:\n", "\n", " sage: p1 = line([(a,b) for a, b in zip(p[0].xdata, p[0].ydata)\n", " ....: if b>=-1 and b<=1])\n", " sage: q1 = line([(a,b) for a, b in zip(q[0].xdata, q[0].ydata)\n", " ....: if b>=0 and b<=4])\n", " sage: (p1 + q1).show()\n", "\n", " We can also directly plot the elliptic curve:\n", "\n", " sage: E = EllipticCurve([0,-1])\n", " sage: plot(E, (1, 4), color=hue(0.6))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We can change the line style as well:\n", "\n", " sage: plot(sin(x), (x, 0, 10), linestyle='-.')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " If we have an empty linestyle and specify a marker, we can see the\n", " points that are actually being plotted:\n", "\n", " sage: plot(sin(x), (x,0,10), plot_points=20, linestyle='', marker='.')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " The marker can be a TeX symbol as well:\n", "\n", " sage: plot(sin(x), (x, 0, 10), plot_points=20, linestyle='', marker=r'$\\checkmark$')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " Sage currently ignores points that cannot be evaluated\n", "\n", " sage: from sage.misc.verbose import set_verbose\n", " sage: set_verbose(-1)\n", " sage: plot(-x*log(x), (x, 0, 1)) # this works fine since the failed endpoint is just skipped.\n", " Graphics object consisting of 1 graphics primitive\n", " sage: set_verbose(0)\n", "\n", " This prints out a warning and plots where it can (we turn off the\n", " warning by setting the verbose mode temporarily to -1.)\n", "\n", " sage: set_verbose(-1)\n", " sage: plot(x^(1/3), (x, -1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", " sage: set_verbose(0)\n", "\n", " Plotting the real cube root function for negative input requires\n", " avoiding the complex numbers one would usually get. The easiest\n", " way is to use \"real_nth_root(x, n)\"\n", "\n", " sage: plot(real_nth_root(x, 3), (x, -1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We can also get the same plot in the following way:\n", "\n", " sage: plot(sign(x)*abs(x)^(1/3), (x, -1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " A way to plot other functions without symbolic variants is to use\n", " lambda functions:\n", "\n", " sage: plot(lambda x : RR(x).nth_root(3), (x,-1, 1))\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " We can detect the poles of a function:\n", "\n", " sage: plot(gamma, (-3, 4), detect_poles=True).show(ymin=-5, ymax=5)\n", "\n", " We draw the Gamma-Function with its poles highlighted:\n", "\n", " sage: plot(gamma, (-3, 4), detect_poles='show').show(ymin=-5, ymax=5)\n", "\n", " The basic options for filling a plot:\n", "\n", " sage: p1 = plot(sin(x), -pi, pi, fill='axis')\n", " sage: p2 = plot(sin(x), -pi, pi, fill='min', fillalpha=1)\n", " sage: p3 = plot(sin(x), -pi, pi, fill='max')\n", " sage: p4 = plot(sin(x), -pi, pi, fill=(1-x)/3,\n", " ....: fillcolor='blue', fillalpha=.2)\n", " sage: graphics_array([[p1, p2], # long time\n", " ....: [p3, p4]]).show(frame=True, axes=False)\n", "\n", " The basic options for filling a list of plots:\n", "\n", " sage: (f1, f2) = x*exp(-1*x^2)/.35, x*exp(-2*x^2)/.35\n", " sage: p1 = plot([f1, f2], -pi, pi, fill={1: [0]},\n", " ....: fillcolor='blue', fillalpha=.25, color='blue')\n", " sage: p2 = plot([f1, f2], -pi, pi, fill={0: x/3, 1:[0]}, color=['blue'])\n", " sage: p3 = plot([f1, f2], -pi, pi, fill=[0, [0]],\n", " ....: fillcolor=['orange','red'], fillalpha=1, color={1: 'blue'})\n", " sage: p4 = plot([f1, f2], (x,-pi, pi), fill=[x/3, 0],\n", " ....: fillcolor=['grey'], color=['red', 'blue'])\n", " sage: graphics_array([[p1, p2], # long time\n", " ....: [p3, p4]]).show(frame=True, axes=False)\n", "\n", " A example about the growth of prime numbers:\n", "\n", " sage: plot(1.13*log(x), 1, 100,\n", " ....: fill=lambda x: nth_prime(x)/floor(x), fillcolor='red')\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " Fill the area between a function and its asymptote:\n", "\n", " sage: f = (2*x^3+2*x-1)/((x-2)*(x+1))\n", " sage: plot([f, 2*x+2], -7, 7, fill={0: [1]}, fillcolor='#ccc').show(ymin=-20, ymax=20)\n", "\n", " Fill the area between a list of functions and the x-axis:\n", "\n", " sage: def b(n): return lambda x: bessel_J(n, x)\n", " sage: plot([b(n) for n in [1..5]], 0, 20, fill='axis')\n", " Graphics object consisting of 10 graphics primitives\n", "\n", " Note that to fill between the ith and jth functions, you must use\n", " the dictionary key-value syntax \"i:[j]\"; using key-value pairs like\n", " \"i:j\" will fill between the ith function and the line y=j:\n", "\n", " sage: def b(n): return lambda x: bessel_J(n, x) + 0.5*(n-1)\n", " sage: plot([b(c) for c in [1..5]], 0, 20, fill={i: [i-1] for i in [1..4]},\n", " ....: color={i: 'blue' for i in [1..5]}, aspect_ratio=3, ymax=3)\n", " Graphics object consisting of 9 graphics primitives\n", " sage: plot([b(c) for c in [1..5]], 0, 20, fill={i: i-1 for i in [1..4]}, # long time\n", " ....: color='blue', aspect_ratio=3)\n", " Graphics object consisting of 9 graphics primitives\n", "\n", " Extra options will get passed on to \"show()\", as long as they are\n", " valid:\n", "\n", " sage: plot(sin(x^2), (x, -3, 3), # These labels will be nicely typeset\n", " ....: title=r'Plot of $\\sin(x^2)$', axes_labels=['$x$','$y$'])\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin(x^2), (x, -3, 3), # These will not\n", " ....: title='Plot of sin(x^2)', axes_labels=['x','y'])\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin(x^2), (x, -3, 3), # Large axes labels (w.r.t. the tick marks)\n", " ....: axes_labels=['x','y'], axes_labels_size=2.5)\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(sin(x^2), (x, -3, 3), figsize=[8,2])\n", " Graphics object consisting of 1 graphics primitive\n", " sage: plot(sin(x^2), (x, -3, 3)).show(figsize=[8,2]) # These are equivalent\n", "\n", " This includes options for custom ticks and formatting. See\n", " documentation for \"show()\" for more details.\n", "\n", " sage: plot(sin(pi*x), (x, -8, 8), ticks=[[-7,-3,0,3,7], [-1/2,0,1/2]])\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " sage: plot(2*x + 1, (x, 0, 5),\n", " ....: ticks=[[0, 1, e, pi, sqrt(20)],\n", " ....: [1, 3, 2*e + 1, 2*pi + 1, 2*sqrt(20) + 1]],\n", " ....: tick_formatter=\"latex\")\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " This is particularly useful when setting custom ticks in multiples\n", " of \\pi.\n", "\n", " sage: plot(sin(x), (x,0,2*pi), ticks=pi/3, tick_formatter=pi)\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " You can even have custom tick labels along with custom positioning.\n", "\n", " sage: plot(x**2, (x,0,3), ticks=[[1,2.5], [0.5,1,2]],\n", " ....: tick_formatter=[[\"$x_1$\",\"$x_2$\"],[\"$y_1$\",\"$y_2$\",\"$y_3$\"]])\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " You can force Type 1 fonts in your figures by providing the\n", " relevant option as shown below. This also requires that LaTeX,\n", " dvipng and Ghostscript be installed:\n", "\n", " sage: plot(x, typeset='type1')\n", " Graphics object consisting of 1 graphics primitive\n", "\n", " A example with excluded values:\n", "\n", " sage: plot(floor(x), (x, 1, 10), exclude=[1..10])\n", " Graphics object consisting of 11 graphics primitives\n", "\n", " We exclude all points where \"PrimePi\" makes a jump:\n", "\n", " sage: jumps = [n for n in [1..100] if prime_pi(n) != prime_pi(n-1)]\n", " sage: plot(lambda x: prime_pi(x), (x, 1, 100), exclude=jumps)\n", " Graphics object consisting of 26 graphics primitives\n", "\n", " Excluded points can also be given by an equation:\n", "\n", " sage: g(x) = x^2 - 2*x - 2\n", " sage: plot(1/g(x), (x, -3, 4), exclude=g(x)==0, ymin=-5, ymax=5) # long time\n", " Graphics object consisting of 3 graphics primitives\n", "\n", " \"exclude\" and \"detect_poles\" can be used together:\n", "\n", " sage: f(x) = (floor(x)+0.5) / (1-(x-0.5)^2)\n", " sage: plot(f, (x, -3.5, 3.5), detect_poles='show', exclude=[-3..3],\n", " ....: ymin=-5, ymax=5)\n", " Graphics object consisting of 12 graphics primitives\n", "\n", " Regions in which the plot has no values are automatically excluded.\n", " The regions thus excluded are in addition to the exclusion points\n", " present in the \"exclude\" keyword argument.:\n", "\n", " sage: set_verbose(-1)\n", " sage: plot(arcsec, (x, -2, 2)) # [-1, 1] is excluded automatically\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " sage: plot(arcsec, (x, -2, 2), exclude=[1.5]) # x=1.5 is also excluded\n", " Graphics object consisting of 3 graphics primitives\n", "\n", " sage: plot(arcsec(x/2), -2, 2) # plot should be empty; no valid points\n", " Graphics object consisting of 0 graphics primitives\n", " sage: plot(sqrt(x^2 - 1), -2, 2) # [-1, 1] is excluded automatically\n", " Graphics object consisting of 2 graphics primitives\n", "\n", " sage: plot(arccsc, -2, 2) # [-1, 1] is excluded automatically\n", " Graphics object consisting of 2 graphics primitives\n", " sage: set_verbose(0)\n", "\u001b[0;31mInit docstring:\u001b[0m Initialize self. See help(type(self)) for accurate signature.\n", "\u001b[0;31mFile:\u001b[0m ~/Downloads/sage-10.4/src/sage/misc/decorators.py\n", "\u001b[0;31mType:\u001b[0m function" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "?plot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Section**](#complete-access-to-source-code)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Complete Access to Source Code \n", "\n", "Unlike other commercial softwares, [SageMath](http://www.sagemath.org/) gives its users a complete access to the source code. For example let's see the source code for the [SageMath](http://www.sagemath.org/) function `is_square` and `is_squarefree`. Both are in the same file. All we need to do is to type the name of the function and after that a double question mark (??) and press the Enter key." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">#### Exercise 1: \n", "Find the source code for the [SageMath](http://www.sagemath.org/) functions: `derivative` and `factor`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\u001b[0;31mSignature:\u001b[0m \u001b[0mfactor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mproof\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malgorithm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'pari'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mDocstring:\u001b[0m\n", " Return the factorization of \"n\". The result depends on the type of\n", " \"n\".\n", "\n", " If \"n\" is an integer, returns the factorization as an object of\n", " type \"Factorization\".\n", "\n", " If \"n\" is not an integer, \"n.factor(proof=proof, **kwds)\" gets\n", " called. See \"n.factor??\" for more documentation in this case.\n", "\n", " Warning:\n", "\n", " This means that applying \"factor()\" to an integer result of a\n", " symbolic computation will not factor the integer, because it is\n", " considered as an element of a larger symbolic ring.EXAMPLES:\n", "\n", " sage: f(n) = n^2\n", " sage: is_prime(f(3))\n", " False\n", " sage: factor(f(3))\n", " 9\n", "\n", " INPUT:\n", "\n", " * \"n\" -- a nonzero integer\n", "\n", " * \"proof\" -- bool or \"None\" (default: \"None\")\n", "\n", " * \"int_\" -- bool (default: \"False\") whether to return answers as\n", " Python ints\n", "\n", " * \"algorithm\" -- string\n", "\n", " * \"'pari'\" -- (default) use the PARI c library\n", "\n", " * \"'kash'\" -- use KASH computer algebra system (requires that\n", " kash be installed)\n", "\n", " * \"'magma'\" -- use Magma (requires magma be installed)\n", "\n", " * \"verbose\" -- integer (default: 0); PARI's debug variable is set\n", " to this; e.g., set to 4 or 8 to see lots of output during\n", " factorization.\n", "\n", " OUTPUT:\n", "\n", " * factorization of n\n", "\n", " The qsieve and ecm commands give access to highly optimized\n", " implementations of algorithms for doing certain integer\n", " factorization problems. These implementations are not used by the\n", " generic \"factor()\" command, which currently just calls PARI (note\n", " that PARI also implements sieve and ecm algorithms, but they are\n", " not as optimized). Thus you might consider using them instead for\n", " certain numbers.\n", "\n", " The factorization returned is an element of the class\n", " \"Factorization\"; use \"Factorization??\" to see more details, and\n", " examples below for usage. A \"Factorization\" contains both the unit\n", " factor (+1 or -1) and a sorted list of \"(prime, exponent)\" pairs.\n", "\n", " The factorization displays in pretty-print format but it is easy to\n", " obtain access to the \"(prime, exponent)\" pairs and the unit, to\n", " recover the number from its factorization, and even to multiply two\n", " factorizations. See examples below.\n", "\n", " EXAMPLES:\n", "\n", " sage: factor(500)\n", " 2^2 * 5^3\n", " sage: factor(-20)\n", " -1 * 2^2 * 5\n", " sage: f=factor(-20)\n", " sage: list(f)\n", " [(2, 2), (5, 1)]\n", " sage: f.unit()\n", " -1\n", " sage: f.value()\n", " -20\n", " sage: factor(-next_prime(10^2) * next_prime(10^7))\n", " -1 * 101 * 10000019\n", "\n", " sage: factor(293292629867846432923017396246429, algorithm='flint')\n", " 3 * 4852301647696687 * 20148007492971089\n", "\n", " sage: factor(-500, algorithm='kash')\n", " -1 * 2^2 * 5^3\n", "\n", " sage: factor(-500, algorithm='magma') # optional - magma\n", " -1 * 2^2 * 5^3\n", "\n", " sage: factor(0)\n", " Traceback (most recent call last):\n", " ...\n", " ArithmeticError: factorization of 0 is not defined\n", " sage: factor(1)\n", " 1\n", " sage: factor(-1)\n", " -1\n", " sage: factor(2^(2^7) + 1)\n", " 59649589127497217 * 5704689200685129054721\n", "\n", " Sage calls PARI's\n", " https://pari.math.u-bordeaux.fr/dochtml/help/factor, which has\n", " \"proof=False\" by default. Sage has a global proof flag, set to\n", " \"True\" by default (see \"sage.structure.proof.proof\", or use\n", " \"proof.[tab]\"). To override the default, call this function with\n", " \"proof=False\".\n", "\n", " sage: factor(3^89 - 1, proof=False)\n", " 2 * 179 * 1611479891519807 * 5042939439565996049162197\n", "\n", " sage: factor(2^197 + 1) # long time\n", " 3 * 197002597249 * 1348959352853811313 * 251951573867253012259144010843\n", "\n", " Any object which has a factor method can be factored like this:\n", "\n", " sage: K. = QuadraticField(-1)\n", " sage: factor(122 - 454*i)\n", " (-i) * (-i - 2)^3 * (i + 1)^3 * (-2*i + 3) * (i + 4)\n", "\n", " To access the data in a factorization:\n", "\n", " sage: f = factor(420); f\n", " 2^2 * 3 * 5 * 7\n", " sage: [x for x in f]\n", " [(2, 2), (3, 1), (5, 1), (7, 1)]\n", " sage: [p for p,e in f]\n", " [2, 3, 5, 7]\n", " sage: [e for p,e in f]\n", " [2, 1, 1, 1]\n", " sage: [p^e for p,e in f]\n", " [4, 3, 5, 7]\n", "\n", " We can factor Python, numpy and gmpy2 numbers:\n", "\n", " sage: factor(math.pi)\n", " 3.141592653589793\n", " sage: import numpy\n", " sage: factor(numpy.int8(30))\n", " 2 * 3 * 5\n", " sage: import gmpy2\n", " sage: factor(gmpy2.mpz(30))\n", " 2 * 3 * 5\n", "\u001b[0;31mSource:\u001b[0m \n", "\u001b[0;32mdef\u001b[0m \u001b[0mfactor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mproof\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malgorithm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'pari'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"\u001b[0m\n", "\u001b[0;34m Return the factorization of ``n``. The result depends on the\u001b[0m\n", "\u001b[0;34m type of ``n``.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m If ``n`` is an integer, returns the factorization as an object\u001b[0m\n", "\u001b[0;34m of type :class:`Factorization`.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m If ``n`` is not an integer, ``n.factor(proof=proof, **kwds)`` gets called.\u001b[0m\n", "\u001b[0;34m See ``n.factor??`` for more documentation in this case.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m .. warning::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m This means that applying :func:`factor` to an integer result of\u001b[0m\n", "\u001b[0;34m a symbolic computation will not factor the integer, because it is\u001b[0m\n", "\u001b[0;34m considered as an element of a larger symbolic ring.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m EXAMPLES::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: f(n) = n^2 # needs sage.symbolic\u001b[0m\n", "\u001b[0;34m sage: is_prime(f(3)) # needs sage.symbolic\u001b[0m\n", "\u001b[0;34m False\u001b[0m\n", "\u001b[0;34m sage: factor(f(3)) # needs sage.symbolic\u001b[0m\n", "\u001b[0;34m 9\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m INPUT:\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``n`` -- a nonzero integer\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``proof`` -- bool or ``None`` (default: ``None``)\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``int_`` -- bool (default: ``False``) whether to return\u001b[0m\n", "\u001b[0;34m answers as Python ints\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``algorithm`` -- string\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``'pari'`` -- (default) use the PARI c library\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``'kash'`` -- use KASH computer algebra system (requires that\u001b[0m\n", "\u001b[0;34m kash be installed)\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``'magma'`` -- use Magma (requires magma be installed)\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - ``verbose`` -- integer (default: 0); PARI's debug\u001b[0m\n", "\u001b[0;34m variable is set to this; e.g., set to 4 or 8 to see lots of output\u001b[0m\n", "\u001b[0;34m during factorization.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m OUTPUT:\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m - factorization of `n`\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m The qsieve and ecm commands give access to highly optimized\u001b[0m\n", "\u001b[0;34m implementations of algorithms for doing certain integer\u001b[0m\n", "\u001b[0;34m factorization problems. These implementations are not used by the\u001b[0m\n", "\u001b[0;34m generic :func:`factor` command, which currently just calls PARI (note that\u001b[0m\n", "\u001b[0;34m PARI also implements sieve and ecm algorithms, but they are not as\u001b[0m\n", "\u001b[0;34m optimized). Thus you might consider using them instead for certain\u001b[0m\n", "\u001b[0;34m numbers.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m The factorization returned is an element of the class\u001b[0m\n", "\u001b[0;34m :class:`~sage.structure.factorization.Factorization`; use ``Factorization??``\u001b[0m\n", "\u001b[0;34m to see more details, and examples below for usage. A :class:`~sage.structure.factorization.Factorization` contains\u001b[0m\n", "\u001b[0;34m both the unit factor (`+1` or `-1`) and a sorted list of ``(prime, exponent)``\u001b[0m\n", "\u001b[0;34m pairs.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m The factorization displays in pretty-print format but it is easy to\u001b[0m\n", "\u001b[0;34m obtain access to the ``(prime, exponent)`` pairs and the unit, to\u001b[0m\n", "\u001b[0;34m recover the number from its factorization, and even to multiply two\u001b[0m\n", "\u001b[0;34m factorizations. See examples below.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m EXAMPLES::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(500)\u001b[0m\n", "\u001b[0;34m 2^2 * 5^3\u001b[0m\n", "\u001b[0;34m sage: factor(-20)\u001b[0m\n", "\u001b[0;34m -1 * 2^2 * 5\u001b[0m\n", "\u001b[0;34m sage: f=factor(-20)\u001b[0m\n", "\u001b[0;34m sage: list(f)\u001b[0m\n", "\u001b[0;34m [(2, 2), (5, 1)]\u001b[0m\n", "\u001b[0;34m sage: f.unit()\u001b[0m\n", "\u001b[0;34m -1\u001b[0m\n", "\u001b[0;34m sage: f.value()\u001b[0m\n", "\u001b[0;34m -20\u001b[0m\n", "\u001b[0;34m sage: factor(-next_prime(10^2) * next_prime(10^7)) # needs sage.libs.pari\u001b[0m\n", "\u001b[0;34m -1 * 101 * 10000019\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(293292629867846432923017396246429, algorithm='flint') # needs sage.libs.flint\u001b[0m\n", "\u001b[0;34m 3 * 4852301647696687 * 20148007492971089\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(-500, algorithm='kash')\u001b[0m\n", "\u001b[0;34m -1 * 2^2 * 5^3\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(-500, algorithm='magma') # optional - magma\u001b[0m\n", "\u001b[0;34m -1 * 2^2 * 5^3\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(0)\u001b[0m\n", "\u001b[0;34m Traceback (most recent call last):\u001b[0m\n", "\u001b[0;34m ...\u001b[0m\n", "\u001b[0;34m ArithmeticError: factorization of 0 is not defined\u001b[0m\n", "\u001b[0;34m sage: factor(1)\u001b[0m\n", "\u001b[0;34m 1\u001b[0m\n", "\u001b[0;34m sage: factor(-1)\u001b[0m\n", "\u001b[0;34m -1\u001b[0m\n", "\u001b[0;34m sage: factor(2^(2^7) + 1) # needs sage.libs.pari\u001b[0m\n", "\u001b[0;34m 59649589127497217 * 5704689200685129054721\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m Sage calls PARI's :pari:`factor`, which has ``proof=False`` by default.\u001b[0m\n", "\u001b[0;34m Sage has a global proof flag, set to ``True`` by default (see\u001b[0m\n", "\u001b[0;34m :mod:`sage.structure.proof.proof`, or use ``proof.[tab]``). To override\u001b[0m\n", "\u001b[0;34m the default, call this function with ``proof=False``.\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(3^89 - 1, proof=False) # needs sage.libs.pari\u001b[0m\n", "\u001b[0;34m 2 * 179 * 1611479891519807 * 5042939439565996049162197\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m ::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(2^197 + 1) # long time (2s) # needs sage.libs.pari\u001b[0m\n", "\u001b[0;34m 3 * 197002597249 * 1348959352853811313 * 251951573867253012259144010843\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m Any object which has a factor method can be factored like this::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: K. = QuadraticField(-1) # needs sage.rings.number_field\u001b[0m\n", "\u001b[0;34m sage: factor(122 - 454*i) # needs sage.rings.number_field\u001b[0m\n", "\u001b[0;34m (-i) * (-i - 2)^3 * (i + 1)^3 * (-2*i + 3) * (i + 4)\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m To access the data in a factorization::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: # needs sage.libs.pari\u001b[0m\n", "\u001b[0;34m sage: f = factor(420); f\u001b[0m\n", "\u001b[0;34m 2^2 * 3 * 5 * 7\u001b[0m\n", "\u001b[0;34m sage: [x for x in f]\u001b[0m\n", "\u001b[0;34m [(2, 2), (3, 1), (5, 1), (7, 1)]\u001b[0m\n", "\u001b[0;34m sage: [p for p,e in f]\u001b[0m\n", "\u001b[0;34m [2, 3, 5, 7]\u001b[0m\n", "\u001b[0;34m sage: [e for p,e in f]\u001b[0m\n", "\u001b[0;34m [2, 1, 1, 1]\u001b[0m\n", "\u001b[0;34m sage: [p^e for p,e in f]\u001b[0m\n", "\u001b[0;34m [4, 3, 5, 7]\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m We can factor Python, numpy and gmpy2 numbers::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(math.pi)\u001b[0m\n", "\u001b[0;34m 3.141592653589793\u001b[0m\n", "\u001b[0;34m sage: import numpy # needs numpy\u001b[0m\n", "\u001b[0;34m sage: factor(numpy.int8(30)) # needs numpy sage.libs.pari\u001b[0m\n", "\u001b[0;34m 2 * 3 * 5\u001b[0m\n", "\u001b[0;34m sage: import gmpy2\u001b[0m\n", "\u001b[0;34m sage: factor(gmpy2.mpz(30))\u001b[0m\n", "\u001b[0;34m 2 * 3 * 5\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m TESTS::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: factor(Mod(4, 100))\u001b[0m\n", "\u001b[0;34m Traceback (most recent call last):\u001b[0m\n", "\u001b[0;34m ...\u001b[0m\n", "\u001b[0;34m TypeError: unable to factor 4\u001b[0m\n", "\u001b[0;34m sage: factor(\"xyz\")\u001b[0m\n", "\u001b[0;34m Traceback (most recent call last):\u001b[0m\n", "\u001b[0;34m ...\u001b[0m\n", "\u001b[0;34m TypeError: unable to factor 'xyz'\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m Test that :issue:`35219` is fixed::\u001b[0m\n", "\u001b[0;34m\u001b[0m\n", "\u001b[0;34m sage: len(factor(2^2203-1,proof=false))\u001b[0m\n", "\u001b[0;34m 1\u001b[0m\n", "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfactor\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;31m# Maybe n is not a Sage Element, try to convert it\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0me\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpy_scalar_to_element\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0me\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;31m# Either n was a Sage Element without a factor() method\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;31m# or we cannot it convert it to Sage\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"unable to factor {!r}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfactor\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mInteger\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mproof\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mproof\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malgorithm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malgorithm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;31m# Polynomial or other factorable object\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mproof\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mproof\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;31m# Maybe the factor() method does not have a proof option\u001b[0m\u001b[0;34m\u001b[0m\n", "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mFile:\u001b[0m ~/Downloads/sage-10.4/src/sage/arith/misc.py\n", "\u001b[0;31mType:\u001b[0m function" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "factor??" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Section**](#just-the-basics)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Just the Basics \n", "\n", "Why do we need computers for math, anyway? Hopefully by now you and I don't need help with the following computations: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# %display latex # this is just for nice print out like LaTeX." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "4 + 2" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-4" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "-2^2" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-4" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "-2**2" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(-2)^2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### SageMath as a Calculator \n", "\n", "Like every scientific calculator, [SageMath](http://www.sagemath.org/) adheres to the standard order of operations, `PEMDAS` (parenthesis, exponents, multiplication, division, addition, subtraction)." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "86015/7" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2+3*4^6-45/21 " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "12287.8571428571" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numerical_approx(86015/7)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of using the numerical approximation function `numerical_approx`, we could also use its alias `n` for short." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "12287.8571428571" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(86015/7).n()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "12287.8571428571" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n(86015/7)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Observe that the above division, after simplification, is the rational number $\\frac{86015}{7}$ and NOT an approximation like $12287.8571428571$. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Continuing, there is no limit to the size of integers or rational numbers, unless otherwise due to the available memory of the computer in use." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> #### Exercise 2: \n", "Find the numerical approximation to $200$ digits of $2^{300}$" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0370359763344860862684456884093781610514683936659362506361404493543812997633367061833973760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e90" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numerical_approx(2**300, digits=200)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0370359763344860862684456884093781610514683936659362506361404493543812997633367061833973760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e90" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n(2**300, digits=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_SageMath_ can compute numerical approximation of numbers to any large precision. Let us increase the precision of the rational number $\\frac{11}{7}$ to show the periodicity of its digit expansion." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Can we confirm if the number of digits is really `100`? Yes we can, see the code below." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum(map(len, str(numerical_approx(11/7, digits=100)).split(\".\")))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Very impressive! Do not panic if you do not understand the above code. Keep calm and relax, hopefully by the end of the session, you should be able to understand it.\n", "\n", "Continuing, the operators `//` and `%` returns the quotient and the remainder of the division of two integers respectively." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "40 // 12" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "40 % 12" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The output of the two operators `//` and `%` can also be obtained directly with the `divmod` function. " ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 4)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "divmod(40, 12)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are several in-built functions that takes integers as inputs. Two of such functions are the `factorial` and the `binomial`." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "factorial(1000)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wow! That was very fast! You may not be impressed by this, but this computation took less than a second. To check it, we can either use `timeit` or `time` functions. " ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "625 loops, best of 3: 8.79 μs per loop" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "timeit(\"factorial(1000)\")" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 61 µs, sys: 8 µs, total: 69 µs\n", "Wall time: 78.4 µs\n" ] }, { "data": { "text/plain": [ "402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "time(factorial(1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Very impressive! If you are still not impressed, then in Exercise 15, I ask you to write a recursive Python function that returns the factorial of any positive integer and compare the time it takes your function to compute $100!$ with that of _SageMath_. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also decompose an integer into prime factors. Let us factor the integer 1729. " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7 * 13 * 19" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "factor(1729)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Do you know anything about this number `1729`? It is a [taxicab number](https://simple.wikipedia.org/wiki/Taxicab_number) and there is a story behind it which goes like this: \n", "\n", " Hardy said that it was just a boring number: 1729. Ramanujan replied that 1729 was not a boring number at all: it was a very interesting one. He explained that it was the smallest number that could be expressed by the sum of two cubes in two different ways. \n", "\n", "I also observed that the consecutive prime factors of the taxicab number $1729$ differ by $6$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#elementary-functions-and-usual-constants)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Elementary Functions and Usual Constants \n", "\n", "Some of the usual mathematical constant in sage includes `pi`, `e`, `golden_ratio`, `euler_gamma`, `catalan`. In other to see their real values, we will have to use Sage functions `numerical_approx` or its short form `n`. " ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.14159265358979" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pi.n()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.718281828" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numerical_approx(e, digits=10)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.61803398874989" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "golden_ratio.n(digits=15)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.577215664901533" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "euler_gamma.n()" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.91597" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "catalan.n(digits=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are also elementary functions like: \n", " - the exponential function `exp`;\n", " - the logarithmic function `log`;\n", " - trigonometric functions and their inverses: `sin`, `cos`, `tan`, and `arcsin`, `arccos`, `arctan` respectively; \n", " - inverse trigonometric functions and their inverses `sec`, `csc`, `cot` and `sec`, `csc`, `cot` respectively;\n", " - hyperbolic functions and their inverses: `sinh`, `cosh`, `tanh`, and `arcsinh`, `arccosh`, `arctanh` respectively;\n", " - inverse hyperbolic functions and their inverses: `sech`, `csch`, `coth` and `arcsech`, `arccsch`, `arccoth` respectively;\n", " \n", "Let's look at a few of them in action. Note that the computations here are again exact. Recall that you can use the _SageMath_ function `numerical_approx` or its alias `n` to get their numerical approximation." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cos(pi)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/2*sqrt(3)" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sin(pi/3)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/2*pi" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arccos(0)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(3 * I * pi)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "+Infinity" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(oo)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(-oo)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "arccos(1/2*sqrt(3))" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arccos(sin(pi/3))" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sqrt(2)" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sqrt(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you may have observed in the previous cell, one does not always get the expected results. Indeed, only few simplifications are done by _SageMath_ automatically. If needed, it is possible to explicitly call the **simplification function** `simplify`." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/6*pi" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "simplify(arccos(sin(pi/3)))" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\frac{1}{6} \\, \\pi\\)" ], "text/latex": [ "$\\displaystyle \\frac{1}{6} \\, \\pi$" ], "text/plain": [ "1/6*pi" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(simplify(arccos(sin(pi/3))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is more we can explore about simplification of symbolic expression. We can talk about this later if there is time. \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#python-variables)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Python Variables \n", "\n", "So far, none of the results of our computations have been saved. So if we want to reuse any result of the previous computations, we will have to either copy and paste it or type them again. This can be very tedious. However, we can avoid all this by using the __assignment operator__, `=` to assign the result to a variable. You should already be familiar with this from your Python class." ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "y = 2 * sin(pi/3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`y` is a Python variable. Note that in general, the result of a computation is not automatically printed when it is assigned to a variable. In other to print the content of a variable in the same cell it is assigned, we will have to do the following." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sqrt(3)" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = 2 * sin(pi/3); y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To reuse later, we only have to type `y`." ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/3*sqrt(3)*(sqrt(3) + sqrt(2))" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(y + sqrt(2)) * 1/y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Additionally, _SageMath_ saves the last three results in the special variables `_`, `__` and `___`:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sqrt(3)" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 * sin(pi/3)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/3*sqrt(3)*(sqrt(3) + sqrt(2))" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(_ + sqrt(2)) * 1/_" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sqrt(3) + sqrt(2)" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "_ * __" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1/3*sqrt(3)*(sqrt(3) + sqrt(2))^2 + sqrt(3)" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "___ - _ * __" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1/3*sqrt(3)*(sqrt(3) + sqrt(2))^2 + sqrt(3)" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "_" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{1: Group( [ (1,2), (1,2,3,4,5,6,7,8) ] ),\n", " 3: x^7+x^2+x,\n", " 10: Graphics object consisting of 1 graphics primitive,\n", " 13: 6,\n", " 14: -4,\n", " 15: -4,\n", " 16: 4,\n", " 17: 86015/7,\n", " 18: 12287.8571428571,\n", " 19: 12287.8571428571,\n", " 20: 12287.8571428571,\n", " 22: 2.0370359763344860862684456884093781610514683936659362506361404493543812997633367061833973760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e90,\n", " 23: 2.0370359763344860862684456884093781610514683936659362506361404493543812997633367061833973760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e90,\n", " 24: 100,\n", " 25: 3,\n", " 26: 4,\n", " 27: (3, 4),\n", " 28: 402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,\n", " 29: 625 loops, best of 3: 8.79 μs per loop,\n", " 30: 402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,\n", " 31: 7 * 13 * 19,\n", " 32: 3.14159265358979,\n", " 33: 2.718281828,\n", " 34: 1.61803398874989,\n", " 35: 0.577215664901533,\n", " 36: 0.91597,\n", " 37: -1,\n", " 38: 1/2*sqrt(3),\n", " 39: 1/2*pi,\n", " 40: -1,\n", " 41: +Infinity,\n", " 42: 0,\n", " 43: arccos(1/2*sqrt(3)),\n", " 44: sqrt(2),\n", " 45: 1/6*pi,\n", " 49: sqrt(3),\n", " 50: 1/3*sqrt(3)*(sqrt(3) + sqrt(2)),\n", " 51: sqrt(3),\n", " 52: 1/3*sqrt(3)*(sqrt(3) + sqrt(2)),\n", " 53: sqrt(3) + sqrt(2),\n", " 54: -1/3*sqrt(3)*(sqrt(3) + sqrt(2))^2 + sqrt(3),\n", " 55: -1/3*sqrt(3)*(sqrt(3) + sqrt(2))^2 + sqrt(3)}" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Out" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "x^7+x^2+x" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Out[3]" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "x^7+x^2+x" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "_3" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['', \"S_8 = gap('Group( (1,2), (1,2,3,4,5,6,7,8) )'); S_8\", \"get_ipython().run_cell_magic('gap', '', '\\\\nS := Group( (1,2), (1,2,3,4,5,6,7,8) )\\\\n')\", \"maxima('lsum(x^i, i, [1, 2, 7])')\", \"get_ipython().run_cell_magic('maxima', '', '\\\\nlsum (x^i, i, [1, 2, 7]);\\\\n')\", \"get_ipython().run_cell_magic('python', '', '\\\\nprint(map(lambda x : x**2, [1,3,5])) # note the operation ** and not the same as ^ in Python but in Sage they are.\\\\n')\", \"get_ipython().run_cell_magic('singular', '', '\\\\nring R = 0,(x,y,z), lp; R;\\\\n')\", 'get_ipython().run_cell_magic(\\'r\\', \\'\\', \\'library(\"MASS\")\\\\ndata(Cars93)\\\\nmean(Cars93$MPG.city)\\\\nxtabs( ~ Origin + MPG.city, data=Cars93)\\\\n\\')', \"get_ipython().run_cell_magic('r', '', '\\\\nd = c(1,2,3,4)\\\\n')\", \"get_ipython().run_cell_magic('octave', '', 'rand (3, 2) # This is will output a 3x2 matrix whose entries are randomly generated between 0 and 1.\\\\n')\", \"x,y = var('x y')\\ncapacity = Integer(3) # thousand\\ngrowth_rate = RealNumber('0.7') # population increases by 70% per unit of time\\nplot_slope_field(growth_rate * (Integer(1)-y/capacity) * y, (x,Integer(0),Integer(5)), (y,Integer(0),capacity*Integer(2)))\", \"get_ipython().run_line_magic('pinfo', 'plot')\", \"get_ipython().run_line_magic('pinfo2', 'factor')\", 'Integer(4) + Integer(2)', '-Integer(2)**Integer(2)', '-Integer(2)**Integer(2)', '(-Integer(2))**Integer(2)', 'Integer(2)+Integer(3)*Integer(4)**Integer(6)-Integer(45)/Integer(21) ', 'numerical_approx(Integer(86015)/Integer(7))', '(Integer(86015)/Integer(7)).n()', 'n(Integer(86015)/Integer(7))', 'numerical_approx(Integer(2)**Integer(300), digists=Integer(200))', 'numerical_approx(Integer(2)**Integer(300), digits=Integer(200))', 'n(Integer(2)**Integer(300), digits=Integer(200))', 'sum(map(len, str(numerical_approx(Integer(11)/Integer(7), digits=Integer(100))).split(\".\")))', 'Integer(40) // Integer(12)', 'Integer(40) % Integer(12)', 'divmod(Integer(40), Integer(12))', 'factorial(Integer(1000))', 'timeit(\"factorial(1000)\")', \"get_ipython().run_line_magic('time', '(factorial(1000))')\", 'factor(Integer(1729))', 'pi.n()', 'numerical_approx(e, digits=Integer(10))', 'golden_ratio.n(digits=Integer(15))', 'euler_gamma.n()', 'catalan.n(digits=Integer(5))', 'cos(pi)', 'sin(pi/Integer(3))', 'arccos(Integer(0))', 'exp(Integer(3) * I * pi)', 'exp(oo)', 'exp(-oo)', 'arccos(sin(pi/Integer(3)))', 'sqrt(Integer(2))', 'simplify(arccos(sin(pi/Integer(3))))', 'show(simplify(arccos(sin(pi/Integer(3)))))', 'show(simplify(arccos(sin(pi/Integer(3)))))', 'y = Integer(2) * sin(pi/Integer(3))', 'y = Integer(2) * sin(pi/Integer(3)); y', '(y + sqrt(Integer(2))) * Integer(1)/y', 'Integer(2) * sin(pi/Integer(3))', '(_ + sqrt(Integer(2))) * Integer(1)/_', '_ * __', '___ - _ * __', '_', 'Out', 'Out[Integer(3)]', '_3', 'print(In)']\n" ] } ], "source": [ "print(In)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You already know from the Programming with Python lectures that you should avoid using keywords as variables. It is a bad practise to redefine predefined constants and functions in _SageMath_. Although doing this does not influence the internal behaviour of _SageMath_, it could yield surprising results." ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len = 3; len" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'sage.rings.integer.Integer' object is not callable", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[61], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2292\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[0;31mTypeError\u001b[0m: 'sage.rings.integer.Integer' object is not callable" ] } ], "source": [ "len([3,3, 2292,3])" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.14159265358979" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n(pi)" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1/3*I" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pi = -I/3; pi" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-0.333333333333333*I" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n(pi)" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "e" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(3*I*pi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To restore the original value, one can type for example:" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [], "source": [ "from sage.all import pi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's check if this corrects our previous computation." ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(3*I*pi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, you can also call the `restore()` function. Doing this will restore all predefined variables and functions to their default values. Let us try this on the previous example." ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1/3*I" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pi = -I/3; pi" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "e" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(3*I*pi)" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "restore()" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1" ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(3*I*pi)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But this does not correct the Python function `len`. Let us try to find the length of the list object `[1,3,5]`." ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'sage.rings.integer.Integer' object is not callable", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[72], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[0;31mTypeError\u001b[0m: 'sage.rings.integer.Integer' object is not callable" ] } ], "source": [ "len([1,3,5])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To correct this you will have to call the function `reset()`. However it is importatnt to note that calling `reset()` does a complete reset. That is, it clears all user-defined variables. Let's call `reset()` to reset the Python function `len` to its default definition and test it by finding the length of the list object `[1,3,5]`." ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [], "source": [ "reset()" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len([1,3,5])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#symbolic-variables)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Symbolic Variables \n", "\n", "_SageMath_ is especially useful in dealing with expressions containing variables like $x^{2} - y^{2}\\,z^{2} + z^{3}$ or $\\sin^{3}(x) - 2\\,\\cos^{2}(x) + \\sin(x) - 1$. These are the kind of expressions that mathematicians and physicists are used to. The variables $x$, $y$, and $z$ that appear in those expressions are symbolic variables. In general, they differ from the Python variables discussed in the previous [subsection](#python-variables). In _SageMath_, the symbolic variables should be explicitly declared before being used except for the symbolic variable $x$ which is already defined. To declare a symbolic variable, we do the following: " ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "y" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" }, { "name": "stderr", "output_type": "stream", "text": [ "IOStream.flush timed out\n", "IOStream.flush timed out\n" ] } ], "source": [ "y = SR.var('y'); y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also use double quote instead of single quote. That is " ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "y" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" }, { "name": "stderr", "output_type": "stream", "text": [ "IOStream.flush timed out\n", "IOStream.flush timed out\n" ] } ], "source": [ "y = SR.var(\"y\"); y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The $\\texttt{SR}$ here stands for $\\texttt{Symbolic Ring}$. Let me briefly explain what exactly is happening in the commands just above. The command `SR.var('y')` or `SR.var(\"y\")` builds and returns a symbolic variable which is then assigned to the Python variable `y` on the left hand side. Note that we could have use any other name for the Python variable instead of `y`. That is, we could also have done " ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "y" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = SR.var(\"y\"); z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Thus, assigning the symbolic variable $y$ to the Python variable `y` is just a convention, which is however recommended to avoid confusion. Let us see if the Python variables `y` and `z` are the same in memory. " ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "id(y) == id(z)" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\u001b[0;31mSignature:\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m/\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mDocstring:\u001b[0m \n", "Return the identity of an object.\n", "\n", "This is guaranteed to be unique among simultaneously existing objects.\n", "(CPython uses the object's memory address.)\n", "\u001b[0;31mInit docstring:\u001b[0m Initialize self. See help(type(self)) for accurate signature.\n", "\u001b[0;31mFile:\u001b[0m \n", "\u001b[0;31mType:\u001b[0m builtin_function_or_method" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "id?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have the symbolic variable $y$ saved in the Python variables `y` or `z`, we can use it to build more complex symbolic expressions. " ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4*y^2 + y^(2/3) + sin(pi*y)" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y^(2/3)+ 4*y^2 + sin(y*pi)" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle y^{\\frac{3}{2}} + 6 \\, \\sqrt{y} + e^{\\left(\\pi y\\right)}\\)" ], "text/latex": [ "$\\displaystyle y^{\\frac{3}{2}} + 6 \\, \\sqrt{y} + e^{\\left(\\pi y\\right)}$" ], "text/plain": [ "y^(3/2) + 6*sqrt(y) + e^(pi*y)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(z^(3/2)+ 6*z^(1/2) + exp(z*pi))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is something important to note: The Python variables `y` or `z` does not interact with the symbolic variable $y$. Here is what I mean: Let's build a complex expression with the symbolic variable $y$ and assign it to a Python variable. Here, I choose to call my Python variable `my_expr`. " ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "y + 3" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_expr = y + 3; my_expr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's assign the Python variable `z` to 1." ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = 1; z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What do you think the value of the expression `my_expr` is?" ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "y + 3" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_expr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You may be surprised at the result of the last cell. Perhaps you taught it should return `4` right? But if this is the case, how can we evaluate any symbolic expression for example the symbolic expression assigned to the Python variable `my_expr`? In other to do this, we use the `substitution` operation." ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "Substitution using function-call syntax and unnamed arguments has been removed. You can use named arguments instead, like EXPR(x=..., y=...)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[87], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmy_expr\u001b[49m\u001b[43m(\u001b[49m\u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/Downloads/sage-10.4/src/sage/symbolic/expression.pyx:6186\u001b[0m, in \u001b[0;36msage.symbolic.expression.Expression.__call__\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6184\u001b[0m z^2 + x^y\n\u001b[1;32m 6185\u001b[0m \"\"\"\n\u001b[0;32m-> 6186\u001b[0m return self._parent._call_element_(self, *args, **kwds)\n\u001b[1;32m 6187\u001b[0m \n\u001b[1;32m 6188\u001b[0m def variables(self):\n", "File \u001b[0;32m~/Downloads/sage-10.4/src/sage/symbolic/ring.pyx:1041\u001b[0m, in \u001b[0;36msage.symbolic.ring.SymbolicRing._call_element_\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1039\u001b[0m d = args[0]\n\u001b[1;32m 1040\u001b[0m else:\n\u001b[0;32m-> 1041\u001b[0m raise TypeError(\"Substitution using function-call syntax \"\n\u001b[1;32m 1042\u001b[0m \"and unnamed arguments has been removed. You \"\n\u001b[1;32m 1043\u001b[0m \"can use named arguments instead, like \"\n", "\u001b[0;31mTypeError\u001b[0m: Substitution using function-call syntax and unnamed arguments has been removed. You can use named arguments instead, like EXPR(x=..., y=...)" ] } ], "source": [ "my_expr(1)" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_expr(y=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is more I can say about the `substitution` operation but I will leave that one for you to explore. \n", "\n", "Continuing, what if you would like to create a large number of symbolic variables. This can be tedious as you may think. However, you can use the shortcut `x = SR.var(x, n)` where `n` a positive number which is the number of symbolic variables you would like to create. Note that the indexing starts from $0$. Let us create the symbolic variables $t_{0}, t_{1}, \\dots, t_{199}$." ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [], "source": [ "t = SR.var(\"t\", 200); # This creates a tuple of 200 symbolic variables." ] }, { "cell_type": "code", "execution_count": 90, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(t0^3 + t4)*t199" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(t[0]^3 + t[4]) * t[199]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use the `show` function to get a pretty display of the output." ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle {\\left(t_{0}^{3} + t_{4}\\right)} t_{199}\\)" ], "text/latex": [ "$\\displaystyle {\\left(t_{0}^{3} + t_{4}\\right)} t_{199}$" ], "text/plain": [ "(t0^3 + t4)*t199" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In other computer algebra systems like `Maple`, `Mathematica` or `Maxima`, one does not declare symbolic variables before using them. As you have seen already in this [**Subsection**](#symbolic-variables), this is not so with _SageMath_. However, when one uses the old SageNB notebook interface (which is obsolete), and typing the command, `automatic_names(True)`, one can make _SageMath_ behave like the computer algebra systems I mentioned earlier. That is, one can decide not to declare symbolic variables before using them and _SageMath_ will not complain. However, this do not work when one uses the Jupyter notebook. But it does not mean that it can not be done. In fact, if you are able to this, you will be improving on _SageMath_ and you will become famous. Therefore, I propose this exercise which is a project in itself." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> #### Exercise 3: Hard\n", "Build a _SageMath_ package so that if one types in the command `automatic_names(True)` when one is running _SageMath_ in the Jupyter notebook, _SageMath_ works like the old SageNB notebook or like the computer algebra `Maple`, `Mathematica` or `Maxima`. In other words, one does not have to declare symbolic variables before using them." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#linear-algebra-some-basics)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Linear Algebra — Some Basics \n", "\n", "What about matrix algebra? Can we perform computations with matrices in _SageMath_? " ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1 2 3]\n", "[4 5 7]\n", "[6 8 9]" ] }, "execution_count": 92, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M = matrix([[1, 2, 3], [4, 5, 7], [6, 8, 9]]); M" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_SageMath_ can tell me the domain over which the entries of the matrix $M$ is defined." ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Full MatrixSpace of 3 by 3 dense matrices over Integer Ring" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parent(M)" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\newcommand{\\Bold}[1]{\\mathbf{#1}}\\mathrm{Mat}_{3\\times 3}(\\Bold{Z})\\)" ], "text/latex": [ "$\\displaystyle \\newcommand{\\Bold}[1]{\\mathbf{#1}}\\mathrm{Mat}_{3\\times 3}(\\Bold{Z})$" ], "text/plain": [ "Full MatrixSpace of 3 by 3 dense matrices over Integer Ring" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I can compute the determinant of $M$." ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "det(M)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I can also compute the inverse." ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[-11/7 6/7 -1/7]\n", "[ 6/7 -9/7 5/7]\n", "[ 2/7 4/7 -3/7]" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M^-1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I can also specify the domain over which the entries of a matrix should be defined. For example I want to define a matrix whose elements are from the finite field $\\mathbb{Z}_{5}$. " ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1 3 0]\n", "[2 4 4]\n", "[4 2 2]" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = matrix(GF(5), 3, [1, 3, 5, 2, 4, 9, -1, -3, 7]); A" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "det(A)" ] }, { "cell_type": "code", "execution_count": 99, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" } ], "source": [ "l = [1,2,3,4]; type(l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#calculus-some-basics)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Calculus — Some Basics \n", "\n", "Many of you are in the applied sciences and will need integrals. But even look up tables can have errors (and often had many more before they were checked against computer integration).  We can use _SageMath_ to evaluate some complicated integrals. Here are a few examples.\n", "\n", "$$\\int_{1}^{2} \\frac{3 \\, x}{\\sqrt{25\\,x^{2}-3}} \\, {\\rm d} x, \\int_{1}^{e} x \\, \\log(x) \\, {\\rm d} x, \\int e^{x} \\, \\log(x) \\, {\\rm d} x.$$" ] }, { "cell_type": "code", "execution_count": 100, "metadata": {}, "outputs": [], "source": [ "# %display latex" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/4*e^2 + 1/4" ] }, "execution_count": 101, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integrate( log(x)*x, x, 1, e)" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "e^x*log(x) - Ei(x)" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integrate( log(x)*e^x, x)" ] }, { "cell_type": "code", "execution_count": 103, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3/50*sqrt(25*x^2 - 3)*x + 9/250*log(50*x + 10*sqrt(25*x^2 - 3))" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integral(3*x^2/sqrt(25*x^2-3), x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hmm, the computation is okay, but nowadays computers look nicer than that!  This antiderivative looks kind of ugly.  Let me try to simplify it and typeset it nicely." ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\frac{3}{50} \\, \\sqrt{25 \\, x^{2} - 3} x + \\frac{9}{250} \\, \\log\\left(50 \\, x + 10 \\, \\sqrt{25 \\, x^{2} - 3}\\right)\\)" ], "text/latex": [ "$\\displaystyle \\frac{3}{50} \\, \\sqrt{25 \\, x^{2} - 3} x + \\frac{9}{250} \\, \\log\\left(50 \\, x + 10 \\, \\sqrt{25 \\, x^{2} - 3}\\right)$" ], "text/plain": [ "3/50*sqrt(25*x^2 - 3)*x + 9/250*log(50*x + 10*sqrt(25*x^2 - 3))" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(expand(integral(3*x^2/sqrt(25*x^2-3),x)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 105, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\\frac{3}{50} \\, \\sqrt{25 \\, x^{2} - 3} x + \\frac{9}{250} \\, \\log\\left(50 \\, x + 10 \\, \\sqrt{25 \\, x^{2} - 3}\\right)" ] }, "execution_count": 105, "metadata": {}, "output_type": "execute_result" } ], "source": [ "latex(expand(integral(3*x^2/sqrt(25*x^2-3),x)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That's better.  Well, maybe I should just type it in my notes, so I don't forget. \n", "\n", "$$\\frac{3}{50}\\sqrt{25x^2-3x}+\\frac{9}{250}\\log\\left(50x+10\\sqrt{25x^2-3}\\right)$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_SageMath_ can also handle definite integral. For example: \n", "\n", "$$\\int_{1}^{2} \\frac{3 \\, x}{\\sqrt{25\\,x^{2}-3}} {\\rm d}x.$$" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3/25*sqrt(97) - 3/50*sqrt(22) + 9/250*log(10*sqrt(97) + 100) - 9/250*log(10*sqrt(22) + 50)" ] }, "execution_count": 106, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integral(3*x^2/sqrt(25*x^2-3),x,1,2)" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\(\\displaystyle \\frac{3}{25} \\, \\sqrt{97} - \\frac{3}{50} \\, \\sqrt{22} + \\frac{9}{250} \\, \\log\\left(10 \\, \\sqrt{97} + 100\\right) - \\frac{9}{250} \\, \\log\\left(10 \\, \\sqrt{22} + 50\\right)\\)" ], "text/latex": [ "$\\displaystyle \\frac{3}{25} \\, \\sqrt{97} - \\frac{3}{50} \\, \\sqrt{22} + \\frac{9}{250} \\, \\log\\left(10 \\, \\sqrt{97} + 100\\right) - \\frac{9}{250} \\, \\log\\left(10 \\, \\sqrt{22} + 50\\right)$" ], "text/plain": [ "3/25*sqrt(97) - 3/50*sqrt(22) + 9/250*log(10*sqrt(97) + 100) - 9/250*log(10*sqrt(22) + 50)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(integral(3*x^2/sqrt(25*x^2-3),x,1,2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And maybe I needed it numerically approximated, with a built-in error bound computed." ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.9262503194124578, 1.0283444311781162e-14)" ] }, "execution_count": 108, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numerical_integral( 3*x^2/sqrt(25*x^2-3), 1,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And maybe I need to visualize that as well..." ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAASIAAADWCAYAAAB1yo8NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAbJElEQVR4nO3df1xUdb4/8NcIAlZK+QuHxF9bO4IWVxEVE1ujxaBc3bqud2uTa3UL88dVlluibd5+ibbestZRc8O61vbrOoBu6k3W+OHP/YqBgCgpIZDCA38Ug5gMwuf7x+cL30UGZGBmPmdmXs/H4/wxh3PmvOdjvR6fc87nfI5OCCFARKRQL9UFEBExiIhIOQYRESnHICIi5RhERKQcg4iIlGMQEZFyLhFEQgiYzWZwyBORe3KJIKqrq4O/vz/q6upUl0JEDuASQURE7o1BRERddvky8OWX9v9eb/t/JRG5o7Q0YMECQKcDSkuBW26x33ezR0REnbpwAZg7F3j0UWDSJODYMfuGEKDxIDIajQgJCUF4eLjqUog8jhDA558DISHAvn3AJ58A6elAYKD9j6VzhWlAzGYz/P39UVtbi379+qkuh8jtVVcDzz8vT8fmzAH+9CcgIMBxx+M1IiJqJQTw0UfA0qVA797A9u3AY485/riaPjUjIuf5/nvgkUeAuDggNhY4ccI5IQSwR0Tk8YQAtm4FEhKAW28FduwAfvUr59bAHhGRBzt7FoiOBp55RvZ+ioudH0IAg4jIIzU3Axs3AvfcA5SUAHv2yF7R7berqYdBRORhSkuBqChg4ULgiSeAoiLgoYfU1sQgIvIQTU3A+vWyF3T2rBwbtHkzoIURMZoOIg5oJLKPkhJg2jRg2TJ5PaiwEHjgAdVV/X8c0Ejkxq5fB956C3j5ZSAoSF4HioxUXVV7mu4REVH3FRUBU6YASUnAokXA8ePaDCGAQUTkdhobgddfB8aPB65cAQ4eBNats/+DqvbEAY1EbiQ/H5g/X14DeuEFeUrm56e6qptjj4jIDTQ0yNAJD5d3x/7+d2D1atcIIYA9IiKXd/So7AWVlAAvvSSvCfn4qK7KNuwREbmoa9eA5cuByZMBX185YdmqVa4XQgB7REQu6dAh4KmngLIyeWE6MVFO2+GqNN0j4oBGorauXpWDEqdOlc+F5eXJUzFXDiGAAxqJXEZ2NvD008C5c7IXtHQp4OWluir70HSPiIiAujr5gOovfgHo9XJg4u9/7z4hBPAaEZGm/e1v8tmwCxeAd9+VgdTLDbsPbviTiFzfjz/KAPrlL4FRo+QAxcWL3TOEAPaIiDTnyy+B556Tp2TvvQf827/Jlxq6M5vzNScnBzNnzkRgYCB0Oh3S09M73T4rKws6na7dcurUqe7WTOSWLl0Cfvc7YOZMIDRUTl7/7LPuH0JAN3pE9fX1CA0Nxfz58/GYDVP8l5SUtLnjNWjQIFsPTeS2tm+X138aG4Ft22QgeUIAtbA5iGJiYhATE2PzgQYPHozbuzghbkNDAxoaGlo/m81mm49H5Aqqq+UUHSYT8Otfy3mkhwxRXZXzOe3S17hx46DX6xEVFYXMzMxOt01OToa/v3/rEhQU5KQqiZyj5UWGISFATg7wxRcyjDwxhAAnBJFer8eWLVtgMpmQmpoKg8GAqKgo5OTkdLhPUlISamtrW5fKykpHl0nkNC0vMpw3D4iJka/wmTPHs07FbuTwu2YGgwEGg6H1c0REBCorK7Fu3TpMmzbN6j6+vr7w9fV1dGlETiUE8Oc/A//xH+peZKhVSkYlTJ48GadPn1ZxaCIlvvsOePBBeVt+zhx1LzLUKiVBlJeXB71er+LQRE7V3Az86U/yFT6lpcBXXwHvv6/uRYZaZfOp2ZUrV3DmzJnWz2VlZcjPz0f//v0xbNgwJCUl4dy5c9i2bRsAYP369RgxYgTGjBkDi8WCjz/+GCaTCSaTyX6/gkiDSkrkQ6oHD8pb88nJQN++qqvSJpuDKDc3F9OnT2/9nJCQAACIi4vDhx9+iKqqKlRUVLT+3WKxIDExEefOnUOfPn0wZswY7Nq1C7GxsXYon0h7bnyFT3a2fKcYdYzTgBDZUWGhnLDsm2+AhATglVe0/fYMrXDTR+iInMtikaETFiYnLzt0CPjjHxlCXcWHXol66NgxOXl9cbGcLfGll+Qc0tR1mu4RcapY0rJr12TwTJokJyk7ehR47TWGUHfwGhFRN/zj5PUvvyxfZujq80arpOkeEZHW1Ne3n7x+5UqGUE/xGhFRF2VmylkTz5+X75L/9393r3mjVWKPiOgmzGYgPh544AFg6FCgoEDemmcI2Q97RESd2LNHzpL444+A0SgDyV3njVaJTUpkxeXLwL/+KxAbK+cMKioCnn+eIeQo7BER3SAtDViwQN6e37pVBpInzxXkDMx3ov+npgaYOxd49FFg4kQ5QHH+fIaQM2g6iDigkZxBCODTT+Up2L59wCefyEnLAgNVV+Y5OKCRPNr58/I0bOdO4De/kXMHDR6suirPw2tE5JGEAD74QN6G9/MDUlPlWzRIDU2fmhE5Qnk5MGOGnLRs9mx5LYghpBaDiDxGc7N8b9jYscDJk8Du3cCHHwL9+6uujBhE5BHOnAGmT5dTtj7xhHydczfeE0oOwmtE5NYsFnkKZjIBej3w9dcykEhbGETktnbuBB5/XKC+HpgzR4cPPpDvEyPt4akZuZ2rV+U7xGbNEmhoEHjttYv44guGkJZpOog4oJFs9Ze/AAMGCOzbJxASYkZa2kE88cQV1WXRTXBAI7mFy5eB2FiBv/8d8PVtRmJiCR58sAYAMHz4cIwcOVJxhdQZTfeIiLrCaASGDJEhFBb2A9LTD7aGELkGXqwml3X+PDBjhkBRkQ633NKEV14pRkTEZdVlUTewR0Qu6Y03gGHDBIqKgMjIGqSnH2AIuTD2iMillJbKXlBpqQ59+17H668X4d57a1WXRT3EHhG5BCGAxETg5z8XKC0FHnqoCunpBxlCboI9ItK8ggIgJkbg/Hkd+ve3YM2aAtx9d73qssiOGESkWc3NcuL6rVvlCJN//ucKPP/8d5wx0Q1pOoiMRiOMRiOamppUl0JOduAAMHu2wKVLOuj11/DmmwUYOvQn1WWRg3BAI2lKYyPw+OPA9u0CvXoB8+adRVxceY++kwMatU/TPSLyLHv2AHPnCtTV6TBiRD3Wri3A4MEW1WWREzCISLmffpIzJH71lYC3t8CiRWfw2GPnVJdFTsQgIqU+/RR4+mmBn34CDIY6rF17HP7+vCboaRhEpMQPP8iHVI8cAXx8mvHiiyV46CE+H+apbB7QmJOTg5kzZyIwMBA6nQ7p6ek33Sc7OxthYWHw8/PDqFGjsHnz5u7USm5iwwYgIECG0Pjx8iFVhpBnszmI6uvrERoaig0bNnRp+7KyMsTGxiIyMhJ5eXlYsWIFlixZApPJZHOx5Nq+/x4YO1Zg8WLA27sJb7xRiP/6rwL06dOsujRSzOZTs5iYGMTYMOv45s2bMWzYMKxfvx4AEBwcjNzcXKxbtw6PPfaYrYcnF/XKK8Brrwk0NcmHVP/wh2L07q26KtIKh18jOnz4MKKjo9usmzFjBlJSUtDY2IjeVv5rbGhoQENDQ+tns9ns6DLJQUpKgIceEjh7Vod+/a7j9dcLcc89/Pekthz+0Gt1dTUCAgLarAsICMD169dx8eJFq/skJyfD39+/dQkKCnJ0mWRnzc3A4sVAcLDA2bPAww+fR1raQYYQWeWUp+91Nzwc1DKY+8b1LZKSklBbW9u6VFZWOrxGsp+jR4HAQIENG4CBAxuQknIUiYnfohfneqAOOPzUbMiQIaiurm6zrqamBt7e3hgwYIDVfXx9feHr6+vo0sjOmpqAefOATz6Rj2f89rflePbZMtVlkQtweBBFRETgr3/9a5t1e/fuxYQJE6xeHyLX9L//Kx/PMJt1GDr0J7z55nHo9Q0335EI3Tg1u3LlCvLz85Gfnw9A3p7Pz89HRUUFAHlaNW/evNbt4+PjUV5ejoSEBJw8eRJbt25FSkoKEhMT7fMLSKmrV4EZM+R8QfX1AvHxZ/DRR/+HIUQ2sblHlJubi+n/8M7ehIQEAEBcXBw+/PBDVFVVtYYSAIwcORK7d+/GsmXLYDQaERgYiHfffZe37t3ARx8Bzz4rcO0aMHp0HdasKYC//3XVZZEL4jQgZLOLF+Ut+WPH5DvEEhJKEB2t3ZHRnAZE+3gfg2yybh2g18sQmjjxMtLTD2o6hMg18KFX6pKyMvn2jNOndbj11iasXl2E8PAfVZdFbkLTPSKj0YiQkBCEh4erLsVjCQH8/vfAXXcJnD4NPPhgNdLTDzCEyK54jYg69M03wMMPC1RX69C/fwNWry6EwXBFdVk24zUi7eOpGbXT1ATExQF/+YuATse3Z5DjMYiojT17gH/5Fzkw8c47f8Latcdx550cE0SOxSAiAMCVK8Ds2cC+fQJeXgLx8aWYO/d71WWRh2AQEVJSgIULBRoagJAQM1avLuTARHIqBpEHq6qSAxMLCgA/v2a8/PIpTJ9+QXVZ5IE0ffueHOc//xMICpIhdN99l7BjxwGGECnDHpGHKSwEHnlEoKJCzpj46quFCA3lZGWklqZ7RBzQaD8tt+RDQwUqK4Ff/eoc0tIOMoRIEzig0QPs2QP89rcCtbU63HnnVSQnFyAo6JrqspyGAxq1j6dmbqyuDpg1C8jM5C150jYGkZvauBFYtkzAYgHGjJG35Pv14y150iYGkZspL5e35E+d0qFPn2a88spJTJtm/W0pRFqh6YvV1HXNzcCyZcCoUQKnTgG/+EUNduzYzxAil8AekRs4cAB49FGBCxd06N/fgjfeKMTo0a73lDx5LgaRC7t6FZgzB9i9W76+5/HHy/HMM2V8Sp5cDoPIRaWkAIsWyYnr77rrCtasKcCAAY2qyyLqFk0HkdFohNFoRFNTk+pSNKO8XE5WduKEDr6+zVixogS//CXnjCbXxgGNLqK5GVi6FDAaBZqbgalTL+IPfyiGj4/m//mU44BG7dN0j4ikv/1NvkX18mUdBgyw4LXXihAcXKe6LCK7YRBpWG0t8Otft4yMBubNK8P8+eWqyyKyOwaRRv3xj8DKlQKNjXKysjfeKMTtt3NkNLknBpHGlJYCUVEC5eXy/WEvv3wSU6deUl0WkUNxZLVGXL8OvPMOMG4cUF0NxMZWYceOAwwh8gjsEWnAkSPAggXA8eNAfDzw4ot1KCsrUV0WkdOwR6TQpUvAc88BU6YAvXrJQNq4EbjjDtWVETkXe0QKNDUBf/4zsHKlPCV7913ZI/LyUl0ZkRqa7hG541SxBw4AEybI4Jk1C/j2W2DRIoYQeTZNB9HChQtRXFyMo0ePqi6lx86fB373OyAyEujdW56Gbd0KBASoroxIPU0HkTuwWIA33wQMBmDvXvmw6pEjwKRJqisj0g5eI3KgPXvk82GlpcDixcCqVcDtt6uuikh72CNygFOngJkzgdhYYOhQeVv+7bcZQkQd6VYQbdy4ESNHjoSfnx/CwsKwf//+DrfNysqCTqdrt5w6darbRWvVhQvywvPYsUBREfA//yMfWB0zRnVlRNpm86nZ559/jqVLl2Ljxo2477778N577yEmJgbFxcUYNmxYh/uVlJS0mcJj0KBB3atYg65dk6OiV68GdDpgzRp5Kubrq7oyItdgc4/orbfewtNPP41nnnkGwcHBWL9+PYKCgrBp06ZO9xs8eDCGDBnSuni5wf1qIYBPPwVGjwZeekm+SfXMGSAxkSFEZAubgshiseDYsWOIjo5usz46OhqHDh3qdN9x48ZBr9cjKioKmZmZnW7b0NAAs9ncZtESIeQdsEmTgMcfB/7pn4ATJ+TAxIEDVVdH5HpsCqKLFy+iqakJATcMfgkICEB1dbXVffR6PbZs2QKTyYTU1FQYDAZERUUhJyenw+MkJyfD39+/dQkKCrKlTIfavx+4/35gxgzA2xvIygLS04Gf/1x1ZUSuq1u373U3vCZCCNFuXQuDwQCDwdD6OSIiApWVlVi3bh2mTZtmdZ+kpCQkJCS0fjabzcrDKDdXnn599ZXsAX35pbwrxjdmEPWcTT2igQMHwsvLq13vp6ampl0vqTOTJ0/G6dOnO/y7r68v+vXr12ZR5eBBeSs+PFxOXP/FF8CxY8DDDzOEiOzFpiDy8fFBWFgYMjIy2qzPyMjAlClTuvw9eXl50Ov1thzaqYQAdu2Sj2NMnQp89x2wbRtQWCjfI9aLo6+I7MrmU7OEhAQ8+eSTmDBhAiIiIrBlyxZUVFQgPj4egDytOnfuHLZt2wYAWL9+PUaMGIExY8bAYrHg448/hslkgslksu8vsYPaWuC//1tOxVFSAkyeDOzYATzyCMOHyJFsDqK5c+fi0qVLePXVV1FVVYWxY8di9+7dGD58OACgqqoKFRUVrdtbLBYkJibi3Llz6NOnD8aMGYNdu3YhNjbWfr+iBxob5R2wTz6RF50tFuDRR+U0HVOn8vSLyBk87r1mtbVy6o38fGDfPiAjA7h8GQgJAZ54Apg/H1B91mg2m/HNN9+oLcKN8L1m2udRD71Ony5vtwPyVGviROD55+V1n3vuYe+HSBWPCqIFC4Bnn5VjfgwG4LbbVFdERIDGg8hoNMJoNKKpqcku3/eb39jla4jIzjzuGpEr4DUi++I1Iu3jTWkiUo5BRETKMYiISDkGEREpxyAiIuUYRESkHIOIiJTTdBC54yuniag9DmjUIA5otC8OaNQ+TfeIiMgzMIiISDkGEREpxyAiIuUYRESkHIOIiJRjEBGRcgwiIlJO00HEkdVEnoEjqzWII6vtiyOrtU/TPSIi8gwMIiJSjkFERMoxiIhIOQYRESnHICIi5RhERKScpoOIAxqJPAMHNGoQBzTaFwc0ap+me0RE5BkYRESkHIOIiJRjEBGRct0Koo0bN2LkyJHw8/NDWFgY9u/f3+n22dnZCAsLg5+fH0aNGoXNmzd3q1gick82B9Hnn3+OpUuXYuXKlcjLy0NkZCRiYmJQUVFhdfuysjLExsYiMjISeXl5WLFiBZYsWQKTydTj4onIPdh8+37SpEkYP348Nm3a1LouODgYs2fPRnJycrvtX3zxRezcuRMnT55sXRcfH4/jx4/j8OHDVo/R0NCAhoaG1s9msxlBQUE2374XQqCurq7L22uF2WzG8ePHVZfhNoKCgjBixAjVZbi1vn37QqfTdf8LhA0aGhqEl5eXSE1NbbN+yZIlYtq0aVb3iYyMFEuWLGmzLjU1VXh7ewuLxWJ1n1WrVgkA7Zba2lpbyhW1tbVWv4cLFy72XWz9f/NG3rDBxYsX0dTUhICAgDbrAwICUF1dbXWf6upqq9tfv34dFy9ehF6vb7dPUlISEhISWj+39Ihs1bdvX9TW1rb7nsrKyg57VuHh4Th69Gin33uzbXr6d0+q0xm/wxXq7EqN9qizp7+jozr79u3b6XfejE1B1OLGLpgQotNumbXtra1v4evrC19f3+6U1u641v5R+/Xr1+E/tpeX101P/262TU//7kl1OuN3uFKdndVoj2PY43d0pU5b2XSxeuDAgfDy8mrX+6mpqWnX62kxZMgQq9t7e3tjwIABNpbreAsXLuzxNj39e1e4S53O+B1d4Sl12uN3OISt53ITJ04UCxYsaLMuODhYLF++3Or2L7zwgggODm6zLj4+XkyePLnLx2y51tPT81B7fY+jsU77coU6XaFGIRxXp81B9Nlnn4nevXuLlJQUUVxcLJYuXSpuvfVWcfbsWSGEEMuXLxdPPvlk6/bfffeduOWWW8SyZctEcXGxSElJEb179xbbt2/v8jGbm5tFbW2taG5utrXcNq5duyZWrVolrl271qPvcTTWaV+uUKcr1CiE4+q0OYiEEMJoNIrhw4cLHx8fMX78eJGdnd36t7i4OHH//fe32T4rK0uMGzdO+Pj4iBEjRohNmzb1qGgici8uMQ0IEbk3PmtGRMoxiIhIOQYRESnHICIi5dwuiGyZoiQrKws6na7dcurUKYfVl5OTg5kzZyIwMBA6nQ7p6ek33UfFNCq21qmiLZOTkxEeHo6+ffti8ODBmD17NkpKSm66n7Pbszt1qmjPTZs24d57720dNR0REYE9e/Z0uo+92tKtgsjWKUpalJSUoKqqqnW5++67HVZjfX09QkNDsWHDhi5tr2oaFVvrbOHMtszOzsbChQtx5MgRZGRk4Pr164iOjkZ9fX2H+6hoz+7U2cKZ7Tl06FCsWbMGubm5yM3NxQMPPIBZs2bhxIkTVre3a1uqHj9gTxMnThTx8fFt1o0ePbrDUd+ZmZkCgPjhhx+cUF17AERaWlqn27zwwgti9OjRbdY999xzNo1M76mu1Km6LYUQoqamRgBoM67tRlpoz67UqYX2FEKIO+64Q7z//vtW/2bPtnSbHpHFYsGxY8cQHR3dZn10dDQOHTrU6b7jxo2DXq9HVFQUMjMzHVmmzQ4fPtzuN82YMQO5ublobGxUVFXHVLZly0wL/fv373AbLbRnV+psoao9m5qa8Nlnn6G+vh4RERFWt7FnW7pNEHVnihK9Xo8tW7bAZDIhNTUVBoMBUVFRyMnJcUbJXXKzaVS0QnVbCiGQkJCAqVOnYuzYsR1up7o9u1qnqvYsLCzEbbfdBl9fX8THxyMtLQ0hISFWt7VnW3ZrGhAts2WKEoPBAIPB0Po5IiIClZWVWLduHaZNm+bQOm1h6zQqKqhuy0WLFqGgoAAHDhy46bYq27OrdapqT4PBgPz8fPz4448wmUyIi4tDdnZ2h2Fkr7Z0mx5Rd6YosWby5Mk4ffq0vcvrNlebRuUfOastFy9ejJ07dyIzMxNDhw7tdFuV7WlLndY4oz19fHxw1113YcKECUhOTkZoaCjeeecdq9vasy3dJoh8fHwQFhaGjIyMNuszMjIwZcqULn9PXl6e1VkjVYmIiGj3m/bu3YsJEyagd+/eiqrqGke3pRACixYtQmpqKr7++usuvVZaRXt2p05rVPy3KYRoM3/8P7JrW9p8eVvDbJ2i5O233xZpaWni22+/FUVFRWL58uUCgDCZTA6rsa6uTuTl5Ym8vDwBQLz11lsiLy9PlJeXW63RHtOoOKNOFW25YMEC4e/vL7KyskRVVVXrcvXq1dZttNCe3alTRXsmJSWJnJwcUVZWJgoKCsSKFStEr169xN69e63WaM+2dKsgEsK2KUrWrl0rfvaznwk/Pz9xxx13iKlTp4pdu3Y5tL6W27I3LnFxcVZrFELNNCq21qmiLa3VB0B88MEHrdtooT27U6eK9nzqqada/98ZNGiQiIqKag0hazUKYb+25DQgRKSc21wjIiLXxSAiIuUYRESkHIOIiJRjEBGRcgwiIlKOQUREyjGIiEg5BhERKccgIiLlGEREpNz/BQIi2iBZRvg+AAAAAElFTkSuQmCC", "text/plain": [ "Graphics object consisting of 3 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "This shows \\(\\int_1^2 \\frac{3\\,x^2}{\\sqrt{25\\,x^2-3}}\\; \\mathrm{d}x\\)" ], "text/plain": [ "This shows \\(\\int_1^2 \\frac{3\\,x^2}{\\sqrt{25\\,x^2-3}}\\; \\mathrm{d}x\\)" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "show(plot(3*x^2/sqrt(25*x^2-3),(x,1,2),fill=True)+plot(3*x^2/sqrt(25*x^2-3),(x,.5,3)),figsize=3)\n", "html(r\"This shows $\\int_1^2 \\frac{3\\,x^2}{\\sqrt{25\\,x^2-3}}\\; \\mathrm{d}x$\")" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 3 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(\n", " plot(\n", " 3*x^2/sqrt(25*x^2-3),\n", " (x,1,2),\n", " fill=True\n", " )\n", " +\n", " plot(\n", " 3*x^2/sqrt(25*x^2-3)\n", " ,(x,.5,3)\n", " ),\n", " figsize=3, \n", " title=r\"This shows $\\int_1^2 \\frac{3x^2}{\\sqrt{25x^2-3}}\\; \\mathrm{d}x$\"\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Even if you haven't done these sorts of things yourself, you know you can do so with the help of a computer, and you possibly have something in the computer lab or on your laptop which can do them - or you use some [web applications](http://www.wolframalpha.com/) or other softwares." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#plotting-in-brief)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting in Brief \n", "\n", "\n", "_SageMath_ is not only useful in dealing with symbolic expressions but also with plotting. There are lots of plotting commands in _SageMath_. In the previous [Subsection](#calculus-some-basics), we saw some examples of the _SageMath_ `plot` function. In addition, to the `plot` function, I will give examples of the _SageMath_ functions: `plot3d` and `parametric_plot3d`. As you may have have observed in the previous [Subsection](#calculus-some-basics), the `plot` command makes it easy to draw the curve of a real function on a given interval. On the other hand, the `plot3d` command is its counterpart for three-dimensional graphics, or for the graph of a real function of two variables. A similar description applies to the `parametric_plot3d`. Here are examples of those three commands:" ] }, { "cell_type": "code", "execution_count": 112, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot(cos(sqrt(2) * x), x, -pi, pi)" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [], "source": [ "y = SR.var('y')" ] }, { "cell_type": "code", "execution_count": 114, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot3d(cos(pi*sqrt(x^2 + y^2))/sqrt(x^2+y^2),(x,-5,5), (y,-5,5))" ] }, { "cell_type": "code", "execution_count": 115, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "u, v = var('u, v')\n", "f1 = (4+(3+cos(v))*sin(u), 4+(3+cos(v))*cos(u), 4+sin(v))\n", "f2 = (8+(3+cos(v))*cos(u), 3+sin(v), 4+(3+cos(v))*sin(u))\n", "p1 = parametric_plot3d(f1, (u,0,2*pi), (v,0,2*pi), texture=\"red\")\n", "p2 = parametric_plot3d(f2, (u,0,2*pi), (v,0,2*pi), texture=\"blue\")\n", "show(p1 + p2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook. Otherwise, continue to the next [**Subsection**](#demonstration-of-some-sagemath-components)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Demonstration of Some SageMath Components \n", "\n", "One reason _SageMath_ is so powerful is that it uses the \"best of\" other softwares. Click on this [**link**](https://www.sagemath.org/links-components.html) to see the complete list of all software packages that constitutes _SageMath_.  We've already seen it contains [R](http://www.r-project.org/), and it also includes [Numpy](http://www.numpy.org/)/[SciPy](https://www.scipy.org/), which I believe you were introduced to in your Python course.\n", "\n", "Let us see a more theoretical example of this.  It isn't important whether you have seen any of the things here before, just that you can see us using many subsystems." ] }, { "cell_type": "code", "execution_count": 116, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 7 graphics primitives" ] }, "execution_count": 116, "metadata": {}, "output_type": "execute_result" } ], "source": [ "K_3 = graphs.CompleteGraph(3); K_3.plot(figsize=2) # Takes NetworkX graph" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "I can use _SageMath_ to compute some properties of the complete graph $K_{3}$ defined in the previous cell. As an example, let's count the number of [spanning trees](https://en.wikipedia.org/wiki/Spanning_tree#Definitions) of the complete graph $K_{3}$." ] }, { "cell_type": "code", "execution_count": 117, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 117, "metadata": {}, "output_type": "execute_result" } ], "source": [ "K_3.spanning_trees_count()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_SageMath_ cannot only count the number of spanning trees of the complete graph $K_{3}$ but it can plot them as well." ] }, { "cell_type": "code", "execution_count": 118, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 6 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 6 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 6 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[None, None, None]" ] }, "execution_count": 118, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M = Matroid(K_3);\n", "M_bases = M.bases(); \n", "[K_3.subgraph(edges = list(M_bases[basis])).show(figsize=1.5) for basis in range(len(M_bases))]" ] }, { "cell_type": "code", "execution_count": 119, "metadata": {}, "outputs": [], "source": [ "H = K_3.cartesian_product(K_3) # Uses SageMath's functionality" ] }, { "cell_type": "code", "execution_count": 120, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 28 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(H) # Uses matplotlib" ] }, { "cell_type": "code", "execution_count": 121, "metadata": {}, "outputs": [], "source": [ "Sym = H.automorphism_group() # Native Sage Code using C backend for graphs" ] }, { "cell_type": "code", "execution_count": 122, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "72" ] }, "execution_count": 122, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len( Sym.list() ) # Needs GAP to calculate" ] }, { "cell_type": "code", "execution_count": 123, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[ ]" ] }, "execution_count": 123, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Sym._gap_().ComputedPCentralSeriess() # Directly within GAP" ] }, { "cell_type": "code", "execution_count": 124, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "x^9 - 18*x^8 + 147*x^7 - 711*x^6 + 2220*x^5 - 4545*x^4 + 5878*x^3 - 4308*x^2 + 1336*x" ] }, "execution_count": 124, "metadata": {}, "output_type": "execute_result" } ], "source": [ "chrom_poly = H.chromatic_polynomial(); chrom_poly # Uses compiled C code from Cython in SageMath" ] }, { "cell_type": "code", "execution_count": 125, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9*x^8 - 144*x^7 + 1029*x^6 - 4266*x^5 + 11100*x^4 - 18180*x^3 + 17634*x^2 - 8616*x + 1336" ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" } ], "source": [ "deriv = derivative(chrom_poly, x); deriv # Uses Ginac/Pynac for symbolics" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Believe it or not, this has meaning! It tells us the graph is connected." ] }, { "cell_type": "code", "execution_count": 126, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1336" ] }, "execution_count": 126, "metadata": {}, "output_type": "execute_result" } ], "source": [ "deriv.subs(x=0)" ] }, { "cell_type": "code", "execution_count": 127, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "H.is_connected()" ] }, { "cell_type": "code", "execution_count": 128, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1/10*x^10 - 2*x^9 + 147/8*x^8 - 711/7*x^7 + 370*x^6 - 909*x^5 + 2939/2*x^4 - 1436*x^3 + 668*x^2" ] }, "execution_count": 128, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integral(chrom_poly,x) # Uses Maxima for integration, symbolic summation, etc." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "No one knows if this has any meaning.  The book \"Quo Vadis, Graph Theory?: A Source Book for Challenges and Directions\" asks for interpretations of such things." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Click [**here**](#day-01-toc) if you want to go back to the table of content of this notebook." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "****\n", "\n", "\n", "< [Table of contents](ems_2020_table_of_contents.ipynb) | [2. Review of Python programming](ems_2020_day_02_short_review_on_python_programming.ipynb) >\n", "\n", "\n", "****" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Back to previous page" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "SageMath 10.4", "language": "sage", "name": "sagemath" }, "language": "python", "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.2" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }