DiffEq 2 Mathematica crash course

Numbers

Numbers will be represented symbolically when possible

A floating point approximation can be computed using the N function.

You can go to arbitrary precision

You can apply the N function after an operation

Arithmetic

Addition, subtraction, multiplication, and division are defined as usual. Multiplication is implicit for symbols separated by whitespace

Warning: a missing whitespace can cause a subtle error.

This is a common beginner’s mistake. If you look carefully you can see that *u** **v* and uv are rendered in different fonts.

To be on the safe side, you can always use the “*” operator for multiplication

Math functions

The usual mathematical functions are defined. All built-in function names are capitalized. Function arguments are put in square brackets not parentheses.

Warning: See what happens if you forget to capitalize:

This error can be hard to detect. Notice that the word “sin” is rendered in a colored font (indicating that it hasn’t been defined yet). Notice also that Mathematica can’t recognize that sin[Pi] is zero, because the “sin” function (as opposed to the “Sin” function) isn’t defined.

Warning: See what happens if you use parentheses instead of square brackets:

All of your familiar friends are available as built-in functions:

Here are some new friends you’ll meet later this semester

Plotting functions of one variable

Plot a function

Plot two functions together

Make the plot a little prettier. See the documentation for lots of plotting options.

Defining your own functions

You can define your own functions very easily, as long as you pay attention to one small detail: put an underscore after the variable name.

The following defines a function *f* of a variable *x*

When I evaluate *f* at different arguments it does the right thing

Warning: the following defines the value of a function *g* at a specific argument value *x*.

When I try to evaluate *g* at different arguments it doesn’t know how to compute *g* except at the specific input *x*. This is probably not what you want.

Most of the time you’ll want to put an underscore after argument names when defining functions. See the documentation for further information about function arguments; if you want to get fancy you can define optional arguments, handle different argument types differently, set default values, and other neat tricks, but you’ll not need to do that for any problems in this course.

You can also make multivariable functions

and you can plot them in several ways:

Lists

I’ve been using lists enclosed in curly braces already. Here’s a little more information on them.

You can nest lists inside of lists:

You can access list elements by index

You can access elements by index relative to the end

Ranges of indices are specified with the double semicolon operator (analogous to Matlab’s colon operator)

You can index into more than one level

You can “flatten” a structured list into a simple list

Many operations “thread” over lists

Table: generating lists from a formula for the elements

We’ll often be given a formula for the *i*-th entry in a list, such as

We can make 2D tables by iterating over two indices. The first index is for the rows, the second for the columns

Tables don’t have to be rectangular

Vectors

A vector is just a list

Access vector elements just like you do with a list: use x[[1]] to access the first element of a vector.

Vector addition and subtraction are done using the + and - operators

Dot product is done with the period (“.”) operator or the Dot function

The 3D cross product is done with the Cross function

What does the multiplication operator do?

How about the division operator?

Warning: Mathematica makes no distinction between row vectors and column vectors. This is a significant difference from MATLAB, which carefully distinguishes between the two. It’s convenient when you don’t care about the difference, but can sometimes cause trouble.

Matrices

Matrices are just rectangular lists.

The usual matrix-matrix operations are defined:

Matrix-matrix multiplication uses the dot (“period”, “.”) operator, just like the dot product

Warning: be sure to use the dot, not * or implicit multiplication!

Matrix-vector multiplication also uses the dot operator

Warning: don’t forget to use the dot!

Linear algebra

You can solve A x=b

Choose a vector for the answer *x*

Multiply our answer by *A* to produce a RHS

Solve the system using the LinearSolve function

You can also solve the system numerically. This will be more efficient for large systems.

You can compute the inverse

and then use it to solve the system:

I’ll explain in a few days why that’s usually not a good idea. For now, I’ll just tell you: you should always solve linear systems of equations using LinearSolve rather than multiplying by an inverse. And never, never, never use Cramer’s Rule.

Finding eigenvalues and eigenvectors

You can find eigenvalues and eigenvectors symbolically for simple enough matrices.

The Eigensystem function finds both together.

You’ll soon learn that it’s generally impossible to find exact eigenvalues and eigenvectors for matrices above size four-by-four, and even for three-by-three the exact eigenvalues might be messy to compute.

However, there are efficient algorithms for computing approximate eigenvalues numerically. Just give a floating point matrix to the Eigenvalues function and a good algorithm will be used.

(Unfortunately, at the level of this course I can’t explain to you the wonderfully ingenious algorithms used to compute approximate eigenvalues. Practical eigenvalue algorithms are nothing like the methods you’ll learn soon for simple hand calculations. But you can trust that Mathematica, MATLAB, and similar programs have good “black box” algorithms for finding approximate eigenvalues for matrices of dimension up to a few thousand rows.)

Polynomials

You can factor any polynomial that has integer roots

You can solve polynomial equations exactly (up to degree four, and in special cases higher degree):

Most polynomials of degree 5 or above can’t be solved exactly

In such cases, use NSolve to find a numerical solution

The Solve function will find complex roots:

Manipulating expressions

Calculus

Limits

Derivatives

Compute derivatives of through order 10

Partial derivatives

Partial wrt x

Partial wrt y

Second partial wrt x

Laplacian:

Indefinite integrals

Mathematica can do elementary integrals

Some may return results in terms of functions that probably aren’t familiar to you:

Some can’t be done exactly at all in terms of any known functions. If the result returned is a integral, that means Mathematica’s integration algorithms weren’t able to compute it.

Definite integrals

In this course we will be doing very many definite integrals (for reasons that will become clear later). So get used to working with the Integrate function!

You can do simple definite integrals easily with Mathematica

Complicated integrals might return unfamiliar functions

You can do improper integrals

Some integrals are too hard even for Mathematica. If the result is returned as an “undone” integral, that means Mathematica couldn’t find an exact result with its algorithms.

In such cases, numerical integration can be used.

Finally, if you try to integrate a function that hasn’t yet been defined, Mathematica won’t know what to do and will simply return an “undone” integral.

Laplace transforms

Differential equations

General soln

Initial value problem

Boundary value problem

The result is returned as a substitution rule. The expression

is a rule that, when executed, replaces the symbol *y**(**t**)* by the stuff after the arrow.

Notice also that the result is a list of substitution rules. This is because, in general, differential equations can have more than one solution.

Digression: substitution rules

Here's a simple example or using a subst rule:

Here’s a more complicated example:

Working with DSolve solutions

Capture the result of DSolve into a variable. Select the first list element (since in this course we’ll always have unique solutions).

Now create a function using the symbol *y**(**t**)* acted upon by the rule:

Warning: I always use different names to distinguish between the symbolic unknown *y**(**t**)* and the solution ySoln*(**t**)*. The reason is that once you define a value for *y**(**t**)*, then if you use that symbol in another call to DSolve Mathematica will evaluate all expressions involving it, including the equality tests such as y[0]==1. That evaluation will return True or False depending on the equation and the value of y[t]. DSolve won’t know what to do with that input, and will give you a strange error message. About all you can do at that point is restart Mathematica.

Long story short: never do something like

y[t_]=y[t] /. solnRule. Always use a variable name for your evaluatable solution function different from the name you used for the unknown.

Warning #2: Be very, very careful to use double-equals operators (“==”) instead of single-equals (“=”) in defining your equations. Double equals tests for equality, single equals does an assignment (if you know C, C++, Python, Java, etc this will be familiar). If you use single equals the input to DSolve will confuse it. I know of no way to recover from this error except to restart Mathematica.