Today I am presenting the IPython notebook at the meeting of the Sage Paris group. This post gathers what I prepared.
First you can install the ipython notebook in Sage as explained in this previous blog post. If everything works, then you run:
sage -ipython notebook
and this will open a browser.
Create a new notebook and type:
In [1]: 3 + 3 6 In [2]: 2 / 3 0 In [3]: matrix Traceback (most recent call last): ... NameError: name 'matrix' is not defined
By default, Sage preparsing is turn off and Sage commands are not known. To turn on the Sage preparsing (thanks to a post of Jason on sage-devel):
%load_ext sage.misc.sage_extension
You now get Sage commands working in ipython:
In [4]: 3 + 4 Out[4]: 7 In [5]: 2 / 3 Out[5]: 2/3 In [6]: type(_) Out[6]: <type 'sage.rings.rational.Rational'> In [7]: matrix(3, range(9)) Out[7]: [0 1 2] [3 4 5] [6 7 8]
If the output is too big, click on Out to scroll or hide the output:
In [8]: range(1000)
3D graphics works but open in a new Jmol window:
In [9]: sphere()
Similarly, 2D graphics works but open in a new window:
In [10]: plot(sin(x), (x,0,10))
To create inline matplotlib graphics, the notebook must be started with this command:
sage -ipython notebook --pylab=inline
Then, a matplotlib plot can be drawn inline (example taken from this notebook):
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 3*np.pi, 500)
plt.plot(x, np.sin(x**2))
plt.title('A simple chirp');
Or with:
%load http://matplotlib.org/mpl_examples/showcase/integral_demo.py
According to the previous cited notebook, it seems, that the inline mode can also decided from the notebook using a magic command, but with my version of ipython (0.13.2), I get an error:
In [11]: %matplotlib inline ERROR: Line magic function `%matplotlib` not found.
Change an input cell into a markdown cell and then you may use latex:
Test $\alpha+\beta+\gamma$
The output can be shown with latex and mathjax using the ipython display function:
from IPython.display import display, Math def my_show(obj): return display(Math(latex(obj))) y = 1 / (x^2+1) my_show(y)
Create a new notebook with only one cell. Name it range_10 and save:
In [1]: range(10) Out[1]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
The file range_10.ipynb is saved in the directory. You can also download it from File > Download as > IPython (.ipynb). Here is the content of the file range_10.ipynb:
{
"metadata": {
"name": "range_10"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "code",
"collapsed": false,
"input": [
"range(10)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "pyout",
"prompt_number": 1,
"text": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
]
}
],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [],
"language": "python",
"metadata": {},
"outputs": []
}
],
"metadata": {}
}
]
}
A ipynb file is written in json format. Below, we use json to open the file `range_10.ipynb as a Python dictionnary.
sage: s = open('range_10.ipynb','r').read()
sage: import json
sage: D = json.loads(s)
sage: type(D)
dict
sage: D.keys()
[u'nbformat', u'nbformat_minor', u'worksheets', u'metadata']
sage: D
{u'metadata': {u'name': u'range_10'},
u'nbformat': 3,
u'nbformat_minor': 0,
u'worksheets': [{u'cells': [{u'cell_type': u'code',
u'collapsed': False,
u'input': [u'range(10)'],
u'language': u'python',
u'metadata': {},
u'outputs': [{u'output_type': u'pyout',
u'prompt_number': 1,
u'text': [u'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]']}],
u'prompt_number': 1},
{u'cell_type': u'code',
u'collapsed': False,
u'input': [],
u'language': u'python',
u'metadata': {},
u'outputs': []}],
u'metadata': {}}]}
Download the file vaucanson.ipynb from the last meeting of Paris Sage Users. You can view the complete demo including pictures of automaton.
In a Python file, separate your code with the following line to create cells:
# <codecell>
For example, create the following Python file. Then, import it in the notebook. It will get translated to ipynb format automatically.
# -*- coding: utf-8 -*- # <nbformat>3.0</nbformat> # <codecell> %load_ext sage.misc.sage_extension # <codecell> matrix(4, range(16)) # <codecell> factor(2^40-1)
Since release 1.0 of IPython, many conversion from ipynb to other format are possible (html, latex, slides, markdown, rst, python). Unfortunately, the version of IPython in Sage is still 0.13.2 as of today but the version 1.2.1 seems available in the new Sage git format for spkg.
by Vincent Knight (noreply@blogger.com) at February 21, 2014 03:58 AM
Goal 1. Increase resource for Sage: Generate a different longterm revenue stream to support development of Sage, i.e., open source mathematical software. By "different", I mean different than government and foundation grants and donations, which are relatively limited for primarily pure mathematics software development, which is what Sage specializes in. Even in my wildest dreams, it is very unlikely Sage will get more than a million dollars a year in funding (and in practice it gets a lot less); however, a successful commercial product with wide adoption has the potential to generate significantly more than a million dollars a year in revenue -- of course most would go back into the product... but when the product is partly Sage, that's fine. The National Science Foundation (and other donors) have played a major part during the last 8 years in funding Sage, but I think everybody would benefit from another funding source.
Goal 2. Increase the usage of Sage: The number of unique visitors per month to http://sagemath.org grew nicely from 2005 (when I started Sage) until Summer 2011, after which point it has remained fairly constant at 70,000 unique visitors. There is no growth at all: it was 70,332 in Jan 2011, and it was 70,449 last month (Jan 2014), both with a bounce rate of about 50%. A significant obstruction to growth is accessible, which SMC helps to address for certain users (last month the SMC website has 17,700 unique visitors with a bounce rate of about 30%).
Here's an actual email I received from somebody literally as I was writing this, which I think illustrates how SMC addresses the second goal:
Hey William,
Today I stopped by cloud.sagemath.com because
I wanted to do some computation with sage, and
cloud is announced in a big way on sagemath.org
This is after a lengthy hiatus from computing
with sage ( maybe a year ).
Using cloud.sagemath.com completely blew my
mind. At first I did not really understand
why sagenb was ditched after all the work that
went into it. But man, cloud is really a
pleasure to use !
I just wanted to share the joy :)
Thanks for all that you do !
There is, however, a large amount of interesting backend code, which is really the "cloud" part of SMC, and which we do not intend to release as open source. We do intend to sell licenses (with support) for the complete package, when it is sufficiently polished, since many organizations want to run their own private SMC servers, mainly for confidentiality reasons.
Goal 2 above mainly impacts how we market SMC. However, it's easy to completely ignore Sage and still get a lot of value out of SMC. I just glanced at what people are doing as I write this, and the result seems pretty typical: latex'ing documents, some Sage worksheets, some IPython notebooks, editing a perl script.
It's important to understand how SMC is different than other approaches to cloud computing. It's designed to make certain things very easy, but they are quite different things than what "traditional" cloud stacks like OpenStack are designed to make easy. SMC is supposed to make the following easy:
The above design goals are useful for certain target audiences, e.g., people doing Sage/Python/etc. development, teachers and students in courses that make use of Sage/Python/etc., collaborative math research projects. SMC is designed so that a large number of people can make simultaneous small use of ever-expanding resources. SMC should also fully support the "social networks" that form in this context. At the same time, it's critical that SMC have excellent uptime and availability (and offsite backups, just in case), so that people can trust it. By trust, I don't mean so much in the sense of "trust it with proprietary info", but in the sense of "trust it to not just loose all my data and to be there when I'm giving a talk/teaching a class/need to do homework/etc.".
However, exactly the above design goals are at odds with some of goals of large-scale scientific/supercomputing. The following are not design goals of SMC:
What happens in practice with SMC is that people run smaller-scale computations on SMC (say things that just take a few cores), and when they want to run something bigger, they ssh from SMC to other resources they have (e.g., a supercomputer account) and launch computations there. All project collaborators can see what anybody types in a terminal, which can be helpful when working with remote compute clusters.
Anyway, I hope this helps to clarify what exactly SMC actually is.
by William Stein (noreply@blogger.com) at February 12, 2014 06:41 AM
Aujourd'hui avait lieu une rencontre de l'ANR DynA3S. Suite à une présentation de Brigitte Vallée, j'ai codé quelques lignes en Sage pour étudier une fonction qu'elle a introduite. Cette fonction est reliée à la compréhension de la densité des termes sous-diagonaux dans l'exécution de l'algorithme LLL.
D'abord voici mon fichier: brigitte.sage.
Pour utiliser ce fichier, il faut d'abord l'importer dans Sage en utilisant la commande suivante. En ligne de commande, ça fonctionne bien. Dans le Sage notebook, je ne sais plus trop si la commande load permet encore de le faire (?):
sage: %runfile brigitte.sage # not tested
On doit générer plusieurs orbites pour visualiser quelque chose, car les orbites de la fonction sont de taille 1, 2 ou 3 en général avant que la condition d'arrêt soit atteinte. Ici, on génère 10000 orbites (les points initiaux sont choisis aléatoirement et uniformément dans \([0,1]\times[-0.5, 0.5]\). On dessine les derniers points des orbites:
sage: D = plusieurs_orbit(10000)
Note: la plus longue orbite est de taille 3
sage: A = points(D[0], color='red', legend_label='derniers')
sage: B = points(D[1], color='blue', legend_label='avant derniers')
sage: C = points(D[2], color='black', legend_label='2e avant derniers')
sage: G = A + B + C
sage: G.axes_labels(("$x$", r"$\nu$"))
sage: title = r"$(x,\nu) \mapsto (\frac{x}{(x+\nu^2)^2},\frac{\nu}{(x+\nu^2)})$"
sage: G.show(title=title, xmax=2)
Un raccourci pour faire à peu près le même dessin que ci-haut:
sage: draw_plusieurs_orbites(10000).show(xmax=2)
On dessine des histogrammes surperposés de la densité de ces points une fois projetés sur l'axe des \(\nu\):
sage: histogrammes_nu(10000, nbox=10)
Le dessin semble indiquer que la densité non uniforme semble provenir simplement par les points \((x,\nu)\) tels que \(x\leq 1\).
On dessine des histogrammes superposés de la densité de ces points une fois projetés sur l'axe des \(x\) (on donne des couleurs selon la valeur de \(\nu\)):
sage: histogrammes_x(30000, nbox=5, ymax=1500, xmax=8)
Le dessin semble indiquer que la densité ne dépend pas de \(\nu\) pour \(x\geq 1\).
by Vincent Knight (noreply@blogger.com) at January 23, 2014 09:59 AM
by Vincent Knight (noreply@blogger.com) at December 19, 2013 11:49 PM
by William Stein (noreply@blogger.com) at December 16, 2013 09:27 AM
by William Stein (noreply@blogger.com) at December 10, 2013 02:24 PM
f(x) = (x + 2) / (x ^ 2 + 3 * x + 2) # Define the function
discontinuity = -1 # The above function has two discontinuities, this one I don't want to plot
hole = -2 # The hole described by Patrick Honner
def make_list_for_plot(f, use_floats=False, zoom_level=10^7, points=1001):
count = 0 # Adding this to count how many tries fail
z = zoom_level
xmin = hole - 10/z # Setting lower bound for plot
xmax = min(hole + 10/z, discontinuity - 1/10) # Setting upper bound for plot only up until the second (messy) discontinuity
x_vals = srange(start=xmin, end=xmax, step=(xmax-xmin)/(points-1), universe=QQ, check=True, include_endpoint=True)
# If we are using floating point arithmetic, cast all QQ numbers to floating point numbers using the n() function.
if use_floats:
x_vals = map(n, x_vals)
lst = []
for x in x_vals:
if x != hole and x != discontinuity: # Robert originally had a try/except statement here to pick up ANY discontinuities. This is not as good but I thought was a bit fairer...
y = f(x)
lst.append((x, y))
return lst
exact_arithmetic = make_list_for_plot(f)
p = list_plot(exact_arithmetic, plotjoined=True) # Plot f
p += point([hole, -1], color='red', size=30) # Add a point
show(p).png)
float_arithmetic = make_list_for_plot(f, use_floats=True)
p = list_plot(float_arithmetic, plotjoined=True) # Plot f
p += point([hole, -1], color='red', size=30) # Add a point
show(p).png)
try except method but I thought that in a way this was a 'fairer' way of doing things. Ultimately though it's very possible and easy to get an error-less plot.)by Vincent Knight (noreply@blogger.com) at December 01, 2013 07:57 AM
.png)
by Vincent Knight (noreply@blogger.com) at November 23, 2013 01:55 AM
f = sqrt(x) + 1 / x complex_plot(sqrt, (-5,5), (-5, 5))
def complex_point_plot(pts): """ A function that returns a plot of a list of complex points. Arguments: pts (a list of complex numbers) Outputs: A list plot of the imaginary numbers """ return list_plot([(real(i), imag(i)) for i in pts], axes_labels = ['Re($z$)', 'Im($z$)'], size=30) complex_point_plot([3*I, e^(I*pi), e^(I*3*pi/4), 4-4*I])
.png)
pts = [e^(I*(theta)) for theta in srange(0, 2*pi, .1)] complex_point_plot(pts) .png)
by Vincent Knight (noreply@blogger.com) at November 16, 2013 08:07 AM
 |
| SMC accounts over time |
 |
| Concurrent connections to SMC |
import jinja2 as j2The last step of the script is to actually publish the files to the webserver. That's rather straight forward. First and only once, create ssh keys via ssh-keygen without a password and then use ssh-copy-id -i ~/.ssh/id_dsa.pub name@server to copy over your keys. Subsequent ssh connections will be established without any questions asked, because the remote server knows your identity. I'm using scp to copy the files: scp *.png stats.html name@remote-server:~/target/dir/
env = j2.Environment(loader=j2.FileSystemLoader("."))
stats = env.get_template("stats.tmpl")
data = {
'date' : "%s UTC" % datetime.utcnow(),
'recent_data' : totals.ix[-24:].to_html()
}
with open("stats.html", "wb") as output:
output.write(stats.render(**data))
by Harald Schilly (noreply@blogger.com) at November 07, 2013 10:04 AM
For a while now there's been a 'game' going on with our pigeon holes where people would put random objects in other people's pigeon holes (like the water bottle you see in the picture). These objects would then follow a random walk around the pigeon holes as each individual would find an object in their pigeon hole and absent-mindedly move it to someone else's pigeon hole.
As such each pigeon hole could be thought of as being a transient state in a Markov chain (http://en.wikipedia.org/wiki/Markov_chain). What is really awesome is that one of the PhD students here didn't seem to care when these random objects appeared in her pigeon hole. Her pigeon hole was in fact an absorbing state. This has now resulted in more or less all random objects (including a wedding photo that no one really knows the origin of) to be in her pigeon hole.I thought I'd have a go at modelling this as an actual Markov chain. Here's a good video by a research student of mine (+Jason Young) describing the very basics of a Markov chain:
N = 12
P = random_matrix(QQ, N, N)
P = [[abs(k) for k in row] for row in P] # This ensures all our numbers are positive
P = matrix([[k / sum(row) for k in row] for row in P]) # This ensures that our rows all sum to 1
P.plot(cmap='hsv',colorbar=True)
eigen = P.eigenvectors_left() # This finds the eigenvalues and eigenvectors
pi = [k[1][0] for k in eigen if k[0] == 1][0] # Find eigenvector corresponding to unit eigenvalue
pi = [k / sum(pi) for k in pi] # normalise eigenvector
bar_chart(pi)
bar_chart function in Sage still needs a bit of work and at the moment can only print a single list of data so it automatically has the axis indexed from 0 onwards (not from 1 to 12 as we would want). We can easily fix this using some matplotlib code (Sage is just wrapping matplotlib anyway):
import matplotlib.pyplot as plt
plt.figure()
plt.bar(range(1, N + 1), pi)
plt.savefig("betterbarplot.png")
import random
def nextstate(i, P):
"""
A function that takes a transition matrix P, a current state i (assumingstarting at 0) and returns the next state j
"""
r = random.random()
cumulativerow = [P[i][0]]
for k in P[i][1:]: # Iterate through elements of the transition matrix
cumulativerow.append(cumulativerow[-1] + k) # Obtain the cumulative distribution
for j in range(len(cumulativerow)):
if cumulativerow[j] >= r: # Find the next state using inverse sampling
return j
return j
states = [0]
numberofiterations = 1000
for k in range(numberofiterations):
states.append(nextstate(states[-1],P))import matplotlib.pyplot as plt
plt.figure()
plt.bar(range(1, N + 1), pi, label='Theory') # Plots the theoretical results
plt.hist([k + 1 for k in states], color='red', bins=range(1, N + 2), alpha=0.5, normed=True, histtype='bar', label='Sim') # Plots the simulation result in a transparent red
plt.legend() # Tells matplotlib to place the legend
plt.xlim(1, N) # Changes the limit of the x axis
plt.xlabel('State') # Include a label for the x axis
plt.ylabel('Probability') # Include a label for the y axis
plt.title("After %s steps" % numberofiterations) # Write the title to the plot
plt.savefig("comparingsimulation.png")
by Vincent Knight (noreply@blogger.com) at October 23, 2013 05:21 AM
by William Stein (noreply@blogger.com) at October 19, 2013 10:18 PM
The other day some students and I met to do some development on the Sage cell server. We each opened up our shared project on cloud.sagemath.com on our own laptops, and started going through the code. We had a specific objective. The session went something like this:
Jason: Okay, here's the function that we need to modify. We need to change this line to do X, and we need to change this other line to do Y. We also need to write this extra function and put it here, and change this other line to do Z. James: can you do X? David: can you look up somewhere on the net how to do Y and write that extra function? I'll do Z.
Then in a matter of minutes, cursors scattering out to the different parts of the code, we had the necessary changes written. I restarted the development sage cell server running inside the cloud account and we were each able to test the changes. We realized a few more things needed to be changed, we divided up the work, and in a few more minutes each had made the necessary changes.
It was amazing: watching all of the cursors scatter out into the code, each person playing a part to make the vision come true, and then quickly coming back together to regroup, reassess, and test the final complete whole. Forgive me for waxing poetic, but it was like a symphony of cursors, each playing their own tune in their lines of the code file, weaving together a beautiful harmony. This fluid syncing William wrote takes distributed development to a new level.
Thanks!
by William Stein (noreply@blogger.com) at October 12, 2013 09:57 PM
by William Stein (noreply@blogger.com) at October 04, 2013 09:10 AM
by Veronica (noreply@blogger.com) at September 22, 2013 12:21 AM
'This is the curse of computing: giving up understanding for an easy verification.'
by Vincent Knight (noreply@blogger.com) at September 20, 2013 12:30 PM
plot method on matrices):
import os
size = 500
nbrofmatrices = 100
for i in range(nbrofmatrices):
print "Ploting matrix: %i of %s" % (i + 1, nbrofmatrices)
A = random_matrix(RR,size)
p = A.plot(cmap='hsv')
p.save('./plots/%.3d.png' % i)
print "Converting plots to gif"
os.system("convert -loop 0 ./plots/*png %sanimatedmatricesofsize%s.gif" % (nbrofmatrices, size))by Vincent Knight (noreply@blogger.com) at September 14, 2013 05:31 AM
by William Stein (noreply@blogger.com) at September 13, 2013 11:48 AM
| Legend |
|---|
| Green: Available in Sage |
| Blue: Patch implementing it is available |
| Yellow: Partially available |
| Violet: Available, and patch with improvements exists |
| Orange: Implemented in mpmath but not in Sage |
| Pink: Not available in mpmath nor Sage |
| 4 Elementary Functions | |
|---|---|
| 5 Gamma Function | |
| §5.24(ii) $\mathop{\Gamma}\nolimits\!\left(x\right), x\in\mathbb{R}$ | ✓ |
| §5.24(iii) $\mathop{\psi}\nolimits\!\left(x\right), \mathop{\psi^{{(n)}}}\nolimits\!\left(x\right), x\in\mathbb{R}$ | ✓ |
| §5.24(iv) $\mathop{\Gamma}\nolimits\!\left(z\right), \mathop{\psi}\nolimits\!\left(z\right), \mathop{\psi^{{(n)}}}\nolimits\!\left(z\right), z\in\mathbb{C}$ | ✓ |
| §5.24(v) $\mathop{\mathrm{B}}\nolimits\!\left(a,b\right), a,b\in\mathbb{R}$ | ✓ |
| §5.24(vi) $\mathop{\mathrm{B}}\nolimits\!\left(a,b\right), a,b\in\mathbb{C}$ | http://trac.sagemath.org/ticket/12521 would fix this, but a better solution (both for speed and precision) would be to use mpmath. |
| 6 Exponential, Logarithmic, Sine, and Cosine Integrals | ✓ |
| 7 Error Functions, Dawson’s and Fresnel Integrals | |
| §7.25(ii) $\mathop{\mathrm{erf}}\nolimits x, \mathop{\mathrm{erfc}}\nolimits x, \mathop{\mathrm{i}^{{n}}\mathrm{erfc}}\nolimits\!\left(x\right), x\in\mathbb{R}$ | ✓ |
| §7.25(iii) $\mathop{\mathrm{erf}}\nolimits z, \mathop{\mathrm{erfc}}\nolimits z, z\in\mathbb{C}$ | $\mathrm{erfc}$ is not yet implemented for complex numbers. |
| §7.25(iv) $\mathop{C}\nolimits\!\left(x\right), \mathop{S}\nolimits\!\left(x\right), \mathop{\mathrm{f}}\nolimits\!\left(x\right), \mathop{\mathrm{g}}\nolimits\!\left(x\right), x\in\mathbb{R}$ | |
| §7.25(v) $\mathop{C}\nolimits\!\left(z\right), \mathop{S}\nolimits\!\left(z\right), z\in\mathbb{C}$ | |
| §7.25(vi) $\mathop{\mathcal{F}}\nolimits\!\left(x\right), \mathop{G}\nolimits\!\left(x\right), \mathop{\mathsf{U}}\nolimits\!\left(x,t\right), \mathop{\mathsf{V}}\nolimits\!\left(x,t\right), x\in\mathbb{R}$ | |
| §7.25(vii) $\mathop{\mathcal{F}}\nolimits\!\left(z\right), \mathop{G}\nolimits\!\left(z\right), z\in\mathbb{C}$ | |
| 8 Incomplete Gamma and Related Functions | |
| §8.28(ii) Incomplete Gamma Functions for Real Argument and Parameter | ✓ |
| §8.28(iii) Incomplete Gamma Functions for Complex Argument and Parameter | ✓ |
| §8.28(v) Incomplete Beta Functions for Complex Argument and Parameters | |
| §8.28(vi) Generalized Exponential Integral for Real Argument and Integer Parameter | ✓ |
| §8.28(vii) Generalized Exponential Integral for Complex Argument and Parameter | ✓ |
| 9 Airy and Related Functions | |
| §9.20(ii) $\mathop{\mathrm{Ai}}\nolimits\!\left(x\right), {\mathop{\mathrm{Ai}}\nolimits^{{\prime}}}\!\left(x\right), \mathop{\mathrm{Bi}}\nolimits\!\left(x\right), {\mathop{\mathrm{Bi}}\nolimits^{{\prime}}}\!\left(x\right), x\in\mathbb{R}$ | ✓ |
| §9.20(iii) $\mathop{\mathrm{Ai}}\nolimits\!\left(z\right), {\mathop{\mathrm{Ai}}\nolimits^{{\prime}}}\!\left(z\right), \mathop{\mathrm{Bi}}\nolimits\!\left(z\right), {\mathop{\mathrm{Bi}}\nolimits^{{\prime}}}\!\left(z\right), z\in\mathbb{C}$ | See http://trac.sagemath.org/ticket/12455 |
| §9.20(iv) Real and Complex Zeros | |
| §9.20(v) Integrals of $\mathop{\mathrm{Ai}}\nolimits\!\left(x\right), \mathop{\mathrm{Bi}}\nolimits\!\left(x\right), x\in\mathbb{R}$ | See http://trac.sagemath.org/ticket/12455 |
| §9.20(vi) Scorer Functions | |
| 10 Bessel Functions | |
| §10.77(ii) Bessel Functions–Real Argument and Integer or Half-Integer Order (including Spherical Bessel Functions) | ✓ |
| §10.77(iii) Bessel Functions–Real Order and Argument | ✓ |
| §10.77(iv) Bessel Functions–Integer or Half-Integer Order and Complex Arguments, including Kelvin Functions | Kelvin functions are not implemented. They are in mpmath however. |
| §10.77(v) Bessel Functions–Real Order and Complex Argument (including Hankel Functions) | See http://trac.sagemath.org/ticket/15024 |
| §10.77(viii) Bessel Functions–Complex Order and Argument | ✓ |
| §10.77(ix) Integrals of Bessel Functions | |
| §10.77(x) Zeros of Bessel Functions | |
| 11 Struve and Related Functions | |
| §11.16(ii) Struve Functions | |
| §11.16(iii) Integrals of Struve Functions | |
| §11.16(iv) Lommel Functions | |
| §11.16(v) Anger and Weber Functions | |
| §11.16(vi) Integrals of Anger and Weber Functions | |
| 12 Parabolic Cylinder Functions | |
| 13 Confluent Hypergeometric Functions | |
| §13.32(ii) Real Argument and Parameters | See http://trac.sagemath.org/ticket/14896 |
| §13.32(iii)Complex Argument and/or Parameters | See http://trac.sagemath.org/ticket/14896 |
| 14 Legendre and Related Functions | |
| §14.34(ii)Legendre Functions: Real Argument and Parameters | |
| §14.34(iii)Legendre Functions: Complex Argument and/or Parameters | |
| §14.34(iii)Legendre Functions: Complex Argument and/or Parameters | |
| 15 Hypergeometric Function | |
| §15.20(ii) Real Parameters and Argument | See http://trac.sagemath.org/ticket/2516 |
| §15.20(iii) Complex Parameters and Argument | See http://trac.sagemath.org/ticket/2516 |
| 16 Generalized Hypergeometric Functions and Meijer G-Function | |
| §16.27(ii) Real Argument and Parameters | See http://trac.sagemath.org/ticket/2516 |
| §16.27(iii) Complex Argument and/or Parameters | See http://trac.sagemath.org/ticket/2516 |
| 18 Orthogonal Polynomials | ✓ |
| 19 Elliptic Integrals | |
| §19.39(ii) Legendre’s and Bulirsch’s Complete Integrals | See http://trac.sagemath.org/ticket/15046 |
| §19.39(iii) Legendre’s and Bulirsch’s Incomplete Integrals | See http://trac.sagemath.org/ticket/15046 |
| §19.39(iv) Symmetric Integrals | |
| 20 Theta Functions | |
| 21 Multidimensional Theta Functions | |
| 22 Jacobian Elliptic Functions | See http://trac.sagemath.org/ticket/14996 |
| 23 Weierstrass Elliptic and Modular Functions | |
| 24 Bernoulli and Euler Polynomials | Euler polynomials are not implemented. |
| 25 Zeta and Related Functions | |
| §25.21(ii) Zeta Functions for Real Arguments | ✓ |
| §25.21(iii) Zeta Functions for Complex Arguments | ✓ |
| §25.21(iv) Hurwitz Zeta Function | See http://trac.sagemath.org/ticket/15095 |
| §25.21(v) Dilogarithms, Polylogarithms | ✓ |
| §25.21(vi) Clausen’s Integral | |
| §25.21(vii) Fermi–Dirac and Bose–Einstein Integrals | |
| §25.21(viii) Lerch’s Transcendent | |
| §25.21(ix) Dirichlet L-series | |
| 26 Combinatorial Analysis | ✓ |
| 27 Functions of Number Theory | ✓ |
| 28 Mathieu Functions and Hill’s Equation | |
| 30 Spheroidal Wave Functions | |
| 33 Coulomb Functions | |
| 34 3j,6j,9j Symbols | ✓ |
| 35 Functions of Matrix Argument |
import csv
f = open(DATA + 'reg', 'r') # Open the data file using the special DATA variable
data = csv.reader(f)
data = [row for row in data] # Read data using csv library
f.close()
data = [[row[2], row[1]] for row in data[1:]] # Only use data that is of interest, remove unwanted columns and 1st row
a, b = var('a, b') # Declare symbolic variables
model(t) = a * t + b # Define model
fit = find_fit(data, model, solution_dict=True) # Find fit of model to data
model.subs(fit) # View the model
p = plot(model.subs(fit), 5, 11, color='red') # Plot fit
p += list_plot(data) # Plot data
pby Vincent Knight (noreply@blogger.com) at September 09, 2013 04:45 PM
by Vincent Knight (noreply@blogger.com) at September 09, 2013 06:54 AM
by Veronica (noreply@blogger.com) at September 08, 2013 10:30 PM
gets all http requests automatically proxied to the given port at the indicated project. Only logged in users with write access to that project can access this url -- with a lot of work, I think I've set things up so that one can safely create password-less non-ssl web services for a groub of collaborators, and all the authentication just piggy backs on cloud.sagemath accounts and projects: it's SSL-backed (with a valid cert) security almost for free, which solves what I know to be a big problem users have.
https://cloud.sagemath.com/[project-id]/port/[port number]/...
and here's what it's going to look like in cloud.sagemath:
iframe class="notebookiframe" id="" src="https://prod-vz-10.wakari.io:9014/auto_login/acd84627972f91a0838e512f32e09c9823782ec0?next=/notebook_relative/Listing 2.ipynb"
With the wakari.io approach, some users will find that notebooks just don't work, e.g., students at University of Arizona, at least if their wifi still doesn't allow connecting to nonstandard ports, like it did when I tried to setup a Sage notebook server there once for a big conference. By having exactly the same page origin and no nonstandard orts, the way I set things up, the parent page can also directly call javascript functions in the iframe (and vice versa), which is potentially very useful.
iframe class="notebookiframe" id="" src="https://cloud.sagemath.com/70a37ef3-4c3f-4bda-a81b-34b894c89701/port/9100/Listing 2.ipynb"
by William Stein (noreply@blogger.com) at September 02, 2013 11:47 AM
by Veronica (noreply@blogger.com) at September 02, 2013 01:12 AM
by William Stein (noreply@blogger.com) at August 28, 2013 12:41 PM
by Veronica (noreply@blogger.com) at August 25, 2013 12:01 PM
After much revision and cleaning-up, the Sage Android application is now at a point where most basic features are functional, and bug reporting, feature requests, and general feedback are needed as work on the application progresses. If you’d like to try the latest APK, you can download it here. Features are always being added (an updated APK with History and Favorites will be available soon!), and you can track the latest updates at the GitHub repository.
As always, feedback and suggestions are much appreciated. Thank you!
I'll start with the conclusion: making backwards incompatible version of a language is a terrible idea, and it was bad a mistake. This mistake was somewhat corrected over the years by eventually adding features to both Python 2.7 and 3.3 that actually allow to run a single code base on both Python versions --- which, as I show below, was discouraged by both Guido and the official Python documents (though the latest docs mention it)... Nevertheless, a single code base fixes pretty much all the problems and it actually is fun to use Python again. The rest of this post explains my conclusion in great detail. My hope is that it will be useful to other Python projects to provide tips and examples how to support both Python 2 and 3, as well as to future language designers to keep languages backwards compatible.
When Python 3.x got released, it was pretty much a new language, backwards incompatible with Python 2.x, as it was not possible to run the same source code in both versions. I was extremely unhappy about this situation, because I simply didn't have time to port all my Python code to a new language.
I read the official documentation about how the transition should be done, quoting:
You should have excellent unit tests with close to full coverage.
- Port your project to Python 2.6.
- Turn on the Py3k warnings mode.
- Test and edit until no warnings remain.
- Use the 2to3 tool to convert this source code to 3.0 syntax. Do not manually edit the output!
- Test the converted source code under 3.0.
- If problems are found, make corrections to the 2.6 version of the source code and go back to step 3.
- When it's time to release, release separate 2.6 and 3.0 tarballs (or whatever archive form you use for releases).
I've also read Guido's blog post, which repeats the above list and adds an encouraging comment:
Python 3.0 will break backwards compatibility. Totally. We're not even aiming for a specific common subset.
In other words, one has to maintain a Python 2.x code base, then run 2to3 tool to get it converted. If you want to develop using Python 3.x, you can't, because all code must be developed using 2.x. As to the actual porting, Guido says in the above post:
If the conversion tool and the forward compatibility features in Python 2.6 work out as expected, steps (2) through (6) should not take much more effort than the typical transition from Python 2.x to 2.(x+1).
So sometime in 2010 or 2011 I started porting SymPy, which is now a pretty large code base (sloccount says over 230,000 lines of code, and in January 2010 it said almost 170,000 lines). I remember spending a few full days on it, and I just gave up, because it wasn't just changing a few things, but pretty fundamental things inside the code base, and one cannot just do it half-way, one has to get all the way through and then polish it up. We ended up using one full Google Summer of Code project for it, you can read the final report. I should mention that we use metaclasses and other things, that make such porting harder. Conclusion: this was definitely not "the typical transition from Python 2.x to 2.(x+1)".
Ok, after months of hard work by a lot of people, we finally have a Python 2.x code base that can be translated using the 2to3 tool and it works and tests pass in Python 3.x.
The next problem is that Python 3.x is pretty much like a ghetto -- you can use it as a user, but you can't develop in it. The 2to3 translation takes over 5 minutes on my laptop, so any interactivity is gone. It is true that the tool can cache results, so the next pass is somewhat faster, but in practice this still turns out to be much much worse than any compilation of C or Fortran programs (done for example with cmake), both in terms of time and in terms of robustness. And I am not even talking about pip issues or setup.py issues regarding calling 2to3. What a big mess... Programming should be fun, but this is not fun.
I'll be honest, this situation killed a lot of my enthusiasm for Python as a platform. I learned modern Fortran in the meantime and with admiration I noticed that it still compiles old F77 programs without modification and I even managed to compile a 40 year old pre-F77 code with just minimal modifications (I had to port the code to F77). Yet modern Fortran is pretty much a completely different language, with all the fancy features that one would want. Together with my colleagues I created a fortran90.org website, where you can compare Python/NumPy side by side with modern Fortran, it's pretty much 1:1 translation and a similar syntax (for numerical code), except that you need to add types of course. Yet Fortran is fully backwards compatible. What a pleasure to work with!
Fast forward to last week. A heroic effort by Sean Vig who ported SymPy to single code base (#2318) was merged. Earlier this year similar pull requests by other people have converted NumPy (#3178, #3191, #3201, #3202, #3203, #3205, #3208, #3216, #3223, #3226, #3227, #3231, #3232, #3235, #3236, #3237, #3238, #3241, #3242, #3244, #3245, #3248, #3249, #3257, #3266, #3281, #3191, ...) and SciPy (#397) codes as well. Now all these projects have just one code base and it works in all Python versions (2.x and 3.x) without the need to call the 2to3 tool.
Having a single code base, programming in Python is fun again. You can choose any Python version, be it 2.x or 3.x, and simply submit a patch. The patch is then tested using Travis-CI, so that it works in all Python versions. Installation has been simplified (no need to call any 2to3 tools and no more hacks to get setup.py working).
In other words, this is how it should be, that you write your code once, and you can use any supported language version to run it/compile it, or develop in. But for some reason, this obvious solution has been discouraged by Guido and other Python documents, as seen above. I just looked up the latest official Python docs, and that one is not upfront negative about a single code base. But it still does not recommend this approach as the one. So let me fix that: I do recommend a single code base as the solution.
The newest Python documentation from the last paragraph also mentions
Regardless of which approach you choose, porting is not as hard or time-consuming as you might initially think.
Well, I encourage you to browse through the pull requests that I linked to above for SymPy, NumPy or SciPy. I think it is very time consuming, and that's just converting from 2to3 to single code base, which is the easy part. The hard part was to actually get SymPy to work with Python 3 (as I discussed above, that took couple months of hard work), and I am pretty sure it was pretty hard to port NumPy and SciPy as well.
The docs also says:
It /single code base/ does lead to code that is not entirely idiomatic Python
That is true, but our experience has been, that with every Python version that we drop, we also delete lots of ugly hacks from our code base. This has been true for dropping support for 2.3, 2.4 and 2.5, and I expect it will also be true for dropping 2.6 and especially 2.7, when we can simply use the Python 3.x syntax. So not a big deal overall.
To sum this blog post up, as far as I am concerned, pretty much all the problems with supporting Python 2.x and 3.x are fixed by having a single code base. You can read the pull requests above to see how to implemented things (like metaclasses, and other fancy stuff...). Python is still quite the same language, you write your code, you use a Python version of your choice and things will just work. Not a big deal overall. The official documentation should be fixed to recommend this approach, and deprecate the other approaches.
I think that Python is great and I hope it will be used more in the future.
Written with StackEdit.
by Ondřej Čertík (noreply@blogger.com) at August 04, 2013 01:48 AM
by Ioana Tamas (noreply@blogger.com) at July 20, 2013 07:09 PM
by Ondřej Čertík (noreply@blogger.com) at July 02, 2013 12:05 PM
The first and most immediately important task of updating the Sage Android application as part of Google’s Summer of Code is to update the way the app interacts with the Sage Cell Server, which performs the calculations in the cloud so that the Android device doesn’t have to locally. Currently, the application communicates with the server through a series of HTTP requests — the client (our app) initializes the connection, then sends and receives query data back and forth from the server. This all sounds fine and efficient, but by relying solely on HTTP requests, the client ends up having to constantly poll the server to check the status of the calculation (to see if there are any updates), which is inefficient and not ideal for a light application on a light device. It’s a decent way of doing things, but the year is 2013, and the Sage Cell Server now supports WebSocket, so my first task is to update the app’s client-server interactions so that users can once again send calculations and receive results.
First, the client must make initial contact with the server in a sort of “handshake” between the two. The app will send an HTTP request, and the server will reply with connection details, at which point the WebSocket connection may be established. This seems easy to implement, but as someone who hasn’t spent much time with networking in Java, I had some difficulty getting hands to shake. The requests I was sending were seemingly correct, but the response I received was similar to that of visiting the site directly from a web browser — 405: Method Not Allowed. How could I let the server know that the app was special, and that it wanted to have meaningful interactions together? With some help from Volker, I was able to see that the issue was in the headers of my request. First, it seemed as if I should use GET instead of POST, which turned out not to be the case.
The POST I was looking for (via the Python client), as revealed by WireShark.
I was advised to make use of WireShark to inspect each request I was making (using the Python sample client as my example of proper HTTP ettiquette). A POST request was being made, but it was being made to the wrong URI — I ended up using Java’s built-in URI functionality to generate one properly. At this point, all that was holding my request back from serverside acceptance was its headers. By adding Accept-Econding:identity, I finally had intialized a proper POST request, as indicated by the server’s response.
Success!
At this point, the server responds with a simple JSON object that contains a “kernel_id” and the “ws_url”, indicating that it is ready to begin our session with the information provided. Using the WebSocket URL and the kernel ID, it is simple at this point to establish a connection through one of the many fine WebSocket libraries that exist for Android. Two connections are made: an IOPub socket and a Shell socket. Once the connection is established, the rest is simply a matter of sending and receiving calculations and results in JSON form on both channels. The IOPub channel details the status of the calculation, while the Shell channel deals with the calculation and results themselves. Data is only sent and received when something has actually happened (at which point either the client or server can react accordingly), and once everything is done, the connection is closed. Especially when considering more advanced features such as Interacts, the improvement in networking and overall efficiency and simplicity from switching over to these sockets is clear.
Handling results and sending/receiving calculation data in general should be simpler now that the client/sever networking process is simplified. Now, it is a matter of getting everything to work together in order for us to run calculations from the app itself.
Although at this moment it has no functional networking capabilities (and therefore cannot perform calculations), you can download the older version of the Sage Math Android app from the Play Store and view (and even contribute to!) the source on GitHub. You can also read more about the Sage Cell Server and its interactions on the GitHub Wiki.
"Why don't more academics use open educational resources?". This offers a good general discussion about open education resources.by Vincent Knight (noreply@blogger.com) at June 16, 2013 05:43 AM
Time Frame | Milestone |
17 June - 24 June | Prepare unit tests for a wrapper class that works with CUDD in the background |
25 June - 5 July | Implement a C++ reference counting method |
6 July - 11 July | Add the new method to the wrapper and test |
12 July - 26 July | Implement a C++ cache management method |
27 July - 2 August | Add the new method to the wrapper and test Prepare for midterm evaluation |
3 August - 16 August | Re-implement the DdManager, DdNode and DdChild and test them |
17 August - 31 August | Implement a C++ ZDD class, with all the operations and methods available in CUDD |
1 September - 9 September | Write unit tests that are independent from CUDD |
10 September - 15 September | Optional: Make an independent C++ library using the new implementations (with a proper build system) Test everything without CUDD |
16 September - 23 September | Finalize documentation Prepare for final evaluation |
by Ioana Tamas (noreply@blogger.com) at June 04, 2013 09:57 PM
by Harald Schilly (noreply@blogger.com) at May 28, 2013 11:45 AM
find_fit command to fit a quintic to the few points I wanted to have on there... There might be a better way to do that though...)by Vincent Knight (noreply@blogger.com) at May 21, 2013 07:16 AM
sage: f(x) = e ^ (x / 2)/(sqrt(1 - x))sage: plot(f(x),x,-10,1)
sage: taylor(f(x),x,0,5)69/160*x^5 + 47/96*x^4 + 7/12*x^3 + 3/4*x^2 + x + 1sage: def SMS(n,2):
....: return taylor(f(x),x,0,n).coeff(x^n)*(factorial(n)^2)coeff method on the polynomials in sage.sage: print [SMS(n,2) for n in range(11)][0, 1, 3, 21, 282, 6210, 202410, 9135630, 545007960, 41514583320]by Vincent Knight (noreply@blogger.com) at May 05, 2013 11:18 AM
by Alexander Dreyer of PolyBoRi (noreply@blogger.com) at April 10, 2013 12:46 PM
by Harald Schilly (noreply@blogger.com) at April 09, 2013 12:13 AM
standalone document class. Once you've done that you can just use normal tikz code:\documentclass[tikz]{standalone}
\usepackage{tikz,amsmath}
\tikzstyle{end} = [circle, minimum width=3pt, fill, inner sep=0pt, right]
\begin{document}
\begin{tikzpicture}
\draw (0,0) -- (4,0) node [below] {$u_1$};
\draw (0,0) -- (0,4) node [left] {$u_2$};
\draw (3,0) node[end] (A) {} node [above=.3cm,right] {$(3,0)$};
\draw (0,3) node[end] (B) {} node [above=.3cm,right] {$(0,3)$};
\draw (1,1) node[end] (C) {} node [below,left] {$(1,1)$};
\draw (2,2) node[end] (D) {} node [above=.3cm,right] {$(2,2)$};
\draw (A) -- (D);
\draw (D) -- (B);
\draw (B) -- (C);
\draw (C) -- (A);
\draw [dashed,thick] (C) -- ++(0,1.5);
\draw [dashed,thick] (C) -- ++(1.5,0);
\draw [->] (2,3.5) node[above] {\tiny{Feasible average payoffs}} -- (.75,2);
\draw [->] (4,1.5) node[above] {\tiny{Individually rational payoffs}} -- (1.5,1.25);
\end{tikzpicture}
\end{document}
pdflatex it you obviously get a pdf which would be great if you were just pdflatex'ing a bigger document but I'll get to creating a png next):
#!/usr/bin/env python
from sys import argv
from os import system
system("pdflatex %s" % (argv[1]))
system("convert -density 300 %s.pdf %s.png" % (argv[1][:-4], argv[1][:-4]))
convert which is a program that can convert pdf to png (more info here but it's natively on Mac OS and *nix I believe).convert_tex_to_png.py and so I can convert any tex file by doing:
python convert_tex_to_png.py file.teximages and there's (now that I'm done) about 70 image files in there so every time I change or write a new tex file I don't want to compile all the files and I also don't want to have to waste time compiling the particular file I've written.c code. For those who don't know, a makefile is basically a short program that gives instructions to compile certain files. When written well these are great as by simply typing make you can recompile any file that has been modified (and not necessarily all of them!).
tex = $(wildcard *.tex)
pngs = $(tex:%.tex=%.png)
all: $(pngs)
%.png: %.tex
./convert_tex_to_png.py $<;
clean:
rm *.aux
rm *.log
rm *.pdf
make clean to remove all auxiliary files (aux, log and pdf).plots directory. Here's an example graph created with sage:
f(a,b)=a^3/3+3/4*b^2+(1-a-b)^2/2
p = contour_plot(f,(0,.5),(0,.5),colorbar=True,axes_labels=["$\\alpha$","$\\beta$"],contours=100, cmap='coolwarm',fill=True)
p.axes_labels(['$\\alpha$','$\\beta$'])
p.save("L18-plot01.png")
sage = $(wildcard *.sage)
pngs = $(sage:%.sage=%.png)
all: $(pngs)
%.png: %.sage
sage $<;
clean:
rm *.py
make clean to remove the .py files that get created when running sage in cli).#!/usr/bin/env python
from sys import argv
from os import system
e = argv[1][:-3]
print e
system("pandoc -s " + e + ".md -N -o " + e + ".html --mathjax")
system("pandoc " + e + ".md -o " + e + ".docx")
system("pandoc " + e + ".md -N -o " + e + ".pdf --latex-engine=xelatex")
pandocipy_given_file.py is the name of the above python script).md = $(wildcard *.md)
htmls = $(md:%.md=%.html)
all: $(htmls)
%.html: %.md
./pandocipy_given_file.py $<;
make to get all the pdf, html and docx files updated.Course_notes contains the md files and corresponding python script and makefile. Course_notes also contains 2 other directories: images and plots which both contain the images and plots as I've described above.
\ref and \label images. The easiest way I've found to do this without messing around with the html (who knows what happens with docx, life is too short to worry about everything) is to use the \text:In the excellently drawn image shown\text{ in Figure \ref{C01-img03}} we see that...
\text when converting to html and docx so that you get documents in html and docx that won't have a reference to the figure (but in general they won't reorder the images) and the pdf will have the documents referenced as you can see in these screenshots (showing pdf and html):
by Vincent Knight (noreply@blogger.com) at April 08, 2013 06:55 AM
self-contained ANSI C implementation as a callable library of the reverse search algorithm for vertex enumeration/convex hull problems and comes with a choice of three arithmetic packages. Basically it's a really smart package that does a lot of things. One of those things is solving normal form games.Gambit is a library of game theory software and tools for the construction and analysis of finite extensive and strategic games. Gambit is designed to be portable across platforms, and runs on Linux, Mac OS X, and Windows. Reading through the website it looks like it can be used to solve normal and extensive form games. Development seems fairly active with various suggestions (including an implementation of the lrs library) for contributions. It basically looks like a C++ library with a nice GUI also available.by Vincent Knight (noreply@blogger.com) at March 24, 2013 08:08 AM
Planet Sage is a central repository of news about Sage, its development and use, brought to you by Sage developers and users. If you would like your blog posts to be aggregated here, please email the Planet Sage maintainer.
Doxdrum
Eviatar Bach
Harald Schilly
Martin Albrecht
Ondrej Certik
PolyBoRi Blog
Rasmi Elasmar
Sébastien Labbé
Verónica Suaste Morales
Vince Knight
William Stein
Last updated:
March 09, 2014 02:01 PM
All times are UTC.
Powered by:
