The Chebfun team is pleased to release Version 5.3, incorporating many speedups and other improvements and new capabilities. Here is a summary of some of the main items.

## General

### Fast discrete Legendre transforms (`legcoeffs2legvals`

etc.)

For several years Chebfun has had codes `leg2cheb`

and `cheb2leg`

for fast conversion between Legendre and Chebyshev expansion coefficients.
We now also have fast conversion between Legendre coefficients and
values at Legendre points. In fact there is now a suite of 12
codes with names `legcoeffs2legvals`

, `legcoeffs2chebcoeffs`

,
`chebcoeffs2legvals`

, etc., all of which compute the corresponding
transforms in close to linear time.
For example, the following takes less than 1 second on a desktop
machine and produces vectors `x`

and `x2`

that differ by about 1e-11.

```
x = randn(1e4,1);
y = legcoeffs2chebvals(x);
x2 = chebvals2legcoeffs(y);
```

[Thanks to Nick Hale and Alex Townsend.]

### New chopping algorithm, removal of `epslevel`

, and `doublelength'

The Chebfun constructor has been redesigned (a paper
is in preparation). Most users won't notice a difference,
but one change is that the accuracy estimate `epslevel`

, which
wasn't as reliable as we had hoped, has been removed.
To explore how Chebfun chops a Chebyshev series, try e.g.

```
f = chebfun('exp(x)','doublelength'); plotcoeffs(f,'.')
```

which constructs a chebfun with twice the usual number of coefficients, revealing a plateau of rounding errors. [Thanks to Jared Aurentz, Anthony Austin, Nick Hale, and Nick Trefethen.]

`'turbo'`

for higher accuracy Chebyshev coefficients

Though most Chebfun computations remain limited to about 15 digits
of accuracy relative to the scale of the function, you can construct
certain Chebyshev coefficients beneath this level with the experimental
new flag `'turbo'`

, based on a very simple form of the complex contour
integrals investigated by Bornemann, Huybrechs, and Wang. Try e.g.

```
f = chebfun('exp(x)','turbo'); plotcoeffs(f,'.')
```

[Thanks to Anthony Austin and Nick Trefethen.]

`plotregion`

for ellipses and strips of analyticity

The command `chebellipseplot`

used to plot the "Chebfun ellipse"
of a chebfun, an estimate of its region of analyticity in
the complex plane (see Chapter 8 of *Approximation Theory and
Approximation Practice*). This is now deprecated in favor of a new
command `plotregion`

that will also plot a "Chebfun strip"
of analyticity for a periodic chebfun. Try e.g.

```
f = chebfun('1./(1+25*x.^2)'); plotregion(f), axis equal
```

or

```
f = chebfun('exp(cos(5*pi*x))','trig'); plotregion(f), axis equal
```

[Thanks to Kuan Xu.]

`explain`

for a movie describing a chebfun2

If `f`

is a chebfun2, `explain(f)`

shows a movie of how `f`

is constructed and represented. Try e.g.
`explain(cheb.gallery2('smokering'))`

, or add a second argument
`explain(...,4)`

to make it faster.
[Thanks to Asgeir Birkisson and Alex Townsend.]

## Differential equations

`quiver`

for displaying the phase plane of a chebop

The new command `quiver`

displays the phase plane for a chebop
(`help quiver`

).
Try e.g. the simple harmonic oscillator

```
L = chebop(@(u) diff(u,2) + u,[0 1]);
quiver(L,[-1 1 -1 1])
```

or the Lotka-Volterra predator-prey system

```
N = chebop(@(t,u,v) [diff(u)-2*u+u*v; diff(v)+v-u*v],[0 10]);
quiver(N,[0 3 0 4],'normalize',true)
```

[Thanks to Asgeir Birkisson.]

### Simpler format `[u, v]`

for multiple outputs (both ODEs and PDEs)

In solving a system of differential equations, the output
used to be a chebmatrix, from which one could extract
components via the command `deal`

(`help chebmatrix/deal`

).
This is no longer necessary. To find solutions $u,v,w$ for
the Lorentz equations, for example, one can now execute

```
N = chebop(0,30);
N.op = @(t,u,v,w) [diff(u)-10*(v-u); ...
diff(v)-u*(28-w)+v; diff(w)-u*v+(8/3)*w];
N.lbc = @(u,v,w) [u+15; v+15; w-20];
[u,v,w] = N\0;
plot(u,w), ylim([2 48])
```

A similar change has been made in `pde15s`

for time-dependent PDEs.
See `help chebop/solvebvp`

or `help chebop/solveivp`

and
`help chebfun/pde15s`

. [Thanks to Asgeir Birkisson.]

### Simpler format `[a; b]`

for specifying derivative BCs

Before, to specify $u=a$ and $u'=b$ at a left boundary,
say, you had to write e.g. `L.lbc = @(u) [u-a; diff(u)-b]`

.
Now, for scalar problems, you can write `L.lbc = [a; b]`

.
See the boundary conditions section under `help chebop`

.
[Thanks to Asgeir Birkisson.]

### New command `deriv`

for evaluating derivatives

To evaluate the derivative of a chebfun, you used to have
to write e.g. `fp = diff(f);`

`fp(0)`

. Now you can also
use `deriv(f,0)`

. This makes specification of
internal "boundary" conditions for ODEs much more
convenient. You used to have to write e.g.
`L.bc = @(x,u) feval(diff(u),0) - 1`

, but now
you can write `L.bc = @(x,u) deriv(u,0) - 1`

.
See `help chebfun/deriv`

.
[Thanks to Asgeir Birkisson.]

`followpath`

for pseudo-arclength continuation of ODE solutions

A new code `followpath`

enables one to track solutions of ODEs
as a parameter is varied. Type `help followpath`

for syntax and
examples. [Thanks to Asgeir Birkisson.]

### Coefficients or values spectral options, both Chebyshev and Fourier

Chebfun uses spectral methods to solve ODE BVPs. The default is spectral collocation ("pseudospectral" methods), but coefficient-based methods are also available. On Chebyshev grids, this is the ultraspherical technology of Olver and Townsend. On Fourier grids, this is a new option based on classical Fourier expansions. The default, factory discretizations are equivalent to what you get with

```
cheboppref.setDefaults('discretization','values')
```

and for the alternative discretizations you can specify

```
cheboppref.setDefaults('discretization','coeffs')
```

See `help cheboppref`

.
[Thanks to Hadrien Montanelli.]