This notebook is a preview demo of IJulia: a Julia-language backend combined with the IPython interactive environment. This combination allows you to interact with the Julia language using IPython's powerful graphical notebook, which combines code, formatted text, math, and multimedia in a single document.
Basic mathematical expressions work like you expect:
1 + sin(3)
You can define variables, write loops, and execute arbitrary multiline code blocks. Here is an example of an alternating harmonic series $\sum_{n=1}^\infty \frac{(-1)^n}{n}$ from a Julia tutorial by Homer Reid:
s = 0.0
for n = 1:2:10000
s += 1/n - 1/(n+1)
end
s # an expression on the last line (if it doesn't end with ";") is printed as "Out"
Previous outputs can be referred to via Out[n], following the IPython, for example Out[2] for the result above. You can also use the shorthand _2, or _ for the previous result, as in IPython. Like in Matlab, ans can also be used to refer to the previous result, even if it was not printed (when the command ended with ;).
For example, the harmonic series above should be converging (slowly) to $\ln 2$, and we can check this:
Out[2] - log(2)
Like Matlab or Scipy + Numpy, Julia has lots of mathematical functions and linear algebra built in. For example, we can define a $500\times500$ random matrix $R$ and form the positive-definite matrix $R^* R$:
R = rand(500,500)
R' * R
(Notice that, by default, only a portion of a large matrix is shown. You didn't really want to read $500^2 = 250,000$ numbers, did you?)
Tab completion and introspection work
ran
Julia can easily and transparently call external Python code using a package called PyCall, and to illustrate that capability we will show some examples calling SciPy and Matplotlib from Julia.
For example, we can use the Newton solver in scipy.optimize to solve a transcendental equation $\cos(x) - x = 0$ given a Julia function:
using PyCall
@pyimport scipy.optimize as so
so.newton(x -> cos(x) - x, 1)
We can use the same @pyimport syntax to import Matplotlib (specifically, the matplotlib.pyplot module), but to integrate Matplotlib's graphics with the IJulia display requires a little more work. To simplify this, we've created a PyPlot module for Julia:
using PyPlot
x = linspace(0,2*pi,1000)
y = sin(3*x + 4*cos(2*x))
plot(x, y, color="red", linewidth=2.0, linestyle="--")
ylabel("the y axis")
xlabel("the x axis")
title("a sinusoidally-modulated sinusoid")
Notice that, by default, the plots are displayed inline (just as for the %pylab inline "magic" in IPython). This kind of multimedia display can be enabled for any Julia object, as explained in the next section.
To start with, the simplest thing is to provide the MIME type of the data when you call display, which allows you to pass "raw" data in the corresponding format:
display("text/html", """Hello <b>world</b> in <font color="red">HTML</font>!""")
However, it will be more common to attach this information to types, so that they display correctly automatically. For example, let's define a simple HTML type in Julia that contains a string and automatically displays as HTML (given an HTML-capable backend such as IJulia):
type HTML
s::String
end
import Base.writemime
writemime(io::IO, ::MIME"text/html", x::HTML) = print(io, x.s)
Here, writemime is just a function that writes x in the corresponding format (text/html) to the I/O stream io. The MIME is a bit of magic to allow Julia's multiple dispatch to automatically select the correct writemime function for a given MIME type (here "text/html") and object type (here HTML). We also needed an import statement in order to add new methods to an existing function from another module.
This writemime definition is all that we need to make any object of type HTML display automatically as HTML text in IJulia:
x = HTML("<ul> <li> Hello from a bulleted list! </ul>")
display(x)
println(x)