For a more thorough introduction, visit Calculus with Julia.
This is a collection of notes for exploring calculus concepts with the
Julia programming language, as is done with MTH229 at the College of Staten Island.
These notes are broken into different sections, where most all sections have some self-grading questions at the end that allow you to test your knowledge of that material. The code should be copy-and-pasteable into a
julia session. The code output is similar to what would be shown if evaluated in an
IJulia cell, our recommended interface while learning
The notes mostly follow topics of a standard first-semester calculus course after some background material is presented for learning
julia within a mathematical framework.
The notes assume that the MTH229 add-on package is installed. In the lab this will be the case. If using
juliabox then it must be done (once). The process involves:
Clicking on the packages menu item at the top of the juliabox page
Click the "Yours" tab of the "Package Builder" window
Under "Unregistered Packages", copy and paste the url "
https://github.com/mth229/MTH229.jl" into the textbox and click the "+" button for Julia version
Click the "Start" button and wait.
(For other Julia installations the command
Pkg.clone("https://github.com/mth229/MTH229.jl") should work.)
Accompanying each set of notes is a "project" that is to be completed in the lab time. For the lab machines these are pre-loaded.
juliabox usage, the projects may be copied in all at once. This is completed by:
Clicking the "Git" menu item at the top of the juliabox page
Copying and pasting the "Git Clone URL": "
https://github.com/mth229/229-projects.git" into the text box
Clicking the "+" button to the right (accepting the defaults for the
other two text boxes.)
Waiting for it too happen
If all goes to plan, a "folder" titled "229-projects" will contain the projects for your usage.
Otherwise, each project individually comes as an "
ipynb" file. These can be downloaded from this page, and then "uploaded" into juliabox using the "upload" button of the file manager.
Basics of types, order of operations, assignment and variables.
Shows how to define and call a function. Technical parts include ternary operator, multiple arguments, and return values (tuples).
This demonstrates the use of the
Plots package for plotting. This package provides a very simple
plot interface for graphing one or more functions.
As well, a discussion about arrays and mapping a function over an array is given. This will be useful later on with limits, ...
Finding zeros for polynomials, graphically finding zeros, and using the bisection method.
Roots package provides some convenient functionality.
Basics of limits.
Discussion on floating point representation and potential issues (subtracting like-sized objects!)
Explore forward difference and central difference with a bit on error analysis.
We end with a brief discussion on automatic differentiation, as implemented in the
ForwardDiff add-on package via the
A look at the relationship between a function and its first and second derivatives.
Basics of Newton's method with a copy-and-paste function to do the work after the student explores a bit.
Discusses iterative algorithms, approximation, some analysis.
fzero function of the
Roots package is discussed.
A project on minimization and maximization. Some standard applied problems are presented.
Basics of integration with applications including rectangle, trapezoid, Simpson's, and the
quaggk function. Applications to volumes of solids of revolution.
Discusses how to do some symbolic math in
julia through the
Applications of the integral: area between two curves, volume of solids of revolution, other volumes
Techniques of integration: substitution, integration by parts, partial fractions
Parametric equations and polar coordinates
Vectors and vector-valued functions, $f: R -> R^n$
Functions of several variables, $f:R^n -> R$.
Double and triple integration.
Julia makes an excellent choice for this material as its syntax is very similar to standard mathematical syntax. The ability to define mathematical functions using the familiar
f(x) = ... notation makes getting started really easy. Further, the fact that functions are first-class objects means that it is possible to create higher-order julia functions that mirror the standard operators of calculus. The following pattern is used throughout:
For example, the notes use:
plot(f, a, b) to plot
plot([f,g], a, b) to plot both
g over the interval
fzeros(f) to find the real roots of a polynomial function
fzero(f, a, b) to find a root inside the bracketing interval
limit(f, c) to find the limit of
D(f) to return a function that computes the derivative of
f (from the
fzero(f, a) to search for a zero of
f starting at
quadgk(f, a, b) to find the numeric integral of
(a,b) (from the
integrate(f) to find the symbolic integral of
f (from the
integrate(f, a, b) to find the definite integral over
[a,b] symbolically (from the
With just this basic set of actions, akin to buttons on the calculator, a rich variety of problems can be addressed.
Julia is a young language, with the bulk of its development being done since its initial announcement. It has relatively few online resources. Some are compiled here. Many of these are linked to from a julia web brain.
The Julia manual provides a comprehensive overview
some blog posts are collected here.
Before starting out with
Julia it must be available.
We recommend taking advantage of the free web service at juliabox.com, but
Julia can be easily installed on a local computer, as described in the following.
In order to get started with
Julia it needs to be installed. If this is not done already, you have a bit of work to do to get
julia and the notebook interface provided by
First to install
julia you can download a copy or install it from source. Likely a download is easiest. Official releases are available from julialang.org. Download the latest released version. Installation is hopefully similar to what you do for other software on your system.
julia varies amongst the different operating systems. All have a console where commands are typed for
julia to interpret and execute. This is known as the command line and though a long familiar means of interacting with computers, it is generally not familiar to the average student. We will need to learn to like the command line. Once done, you may think it is great, but it can a bit frustrating getting to that attitude.
Here is what the command line looks like on startup from a mac book pro within the terminal:
_ _ _ _(_)_ | A fresh approach to technical computing (_) | (_) (_) | Documentation: https://docs.julialang.org _ _ _| |_ __ _ | Type "?help" for help. | | | | | | |/ _` | | | | |_| | | | (_| | | Version 0.6.2 (2017-12-13 18:08 UTC) _/ |\__'_|_|_|\__'_| | Official http://julialang.org/ release |__/ | x86_64-apple-darwin14.5.0 julia>
The command line is the last line: a prompt beginning with
julia>. Here is where you type an expression and then the enter key to ask
julia to evaluate it.
A simple command is then typed into the computer followed by the enter key. This is then sent to
julia's interpreter and an answer returned:
2 + 2
If you get
4, you are able to use
One command that the notes assume you have typed is the one to install the add-on
MTH229 package. If you haven't done so, try this:
This may take a while to complete.
The command line is not the most comfortable learning experience for
julia, rather it is suggested that the
IJulia notebook interface be used. In the
IJulia notebook, the command line is replaced by a cell where commands can be entered and executed in batches. The editing of commands is much easier and some features for integrated help are available.
The above graphic is from the main web page for
julia (julialang.com) and shows the
IJulia notebook with some graphics provided by the
IJulia will require one more additional installation step:
The above commands form the basics of
julia's package system. Like most computer languages,
julia can be extended by user-contributed packages. The complete list of available packages is kept on the computer you are using
julia at. This list is updated by the command
Pkg.update(). New packages are made available for use by installing or
adding them to your system via
Pkg.add. Adding packages will automatically install any dependent packages. As well, external libraries should also be installed for you. This magic attempts to automatically identify what your computer system needs and acts accordingly.
The above commands need only be done when new packages are being installed. However, each time you wish to actually use an external package in a session, it must be added. This is done with the
using command, as
Afterwards those commands are successful, the following command will start the notebook interface:
using IJulia notebook()
Julia can be extended through external packages. Although a relatively young language, there are already around 1000 add-on packages readily available for Julia through its package manager.
For example, the
MTH229 package installs the
Plots package for making plots, the
Roots package for finding zeros of functions and the
SymPy package for symbolic math within
julia world, a package author may publish his or her package so that it is easy for an end user to use and install. For the end user there are just a handful of important commands to install a package:
Pkg.udpate() to update the currently installed external packages and to update the list of available packages to install. Though this command can be a bit slow, it is a good idea to run it periodically.
To add a new package, call
Pkg.add("package_name"), where you have to put the appropriate package name in. For example, the command
Pkg.add("Plots") will install the
Plots package. In the process, any external dependencies will be resolved. These include installing any packages that the one you want depends on and in some cases, additional software.
There are other useful commands, but those two are basically it:
Pkg.update() to update and
Pkg.add() to add a new package.
External packages must be loaded into a session. This need only be done once. The easiest way is to use the keyword
using, a in
using Plots. This must be done before you try to use any functionality related to the package. For interactive use, it is a good idea to just pull in familiar packages at the outset.
This has some cost, as some packages are slow to load.
So, to make a plot using
Plots, the sequence might go like:
using Plots plotly() f(x) = x^2 - 2x plot(f, -2, 1)
using MTH229 will load the
Plots package for you.)
The manual has some more information.