API Reference¶

Initialize a Chebfun object.

Parameters:

Initialize an empty Chebfun.

Returns:

Examples:

>>> f = Chebfun.initempty()
>>> f.isempty
True

Initialize a Chebfun representing the identity function f(x) = x.

Parameters:

Returns:

Examples:

>>> import numpy as np
>>> x = Chebfun.initidentity([-1, 1])
>>> float(x(0.5))
0.5
>>> np.allclose(x([0, 0.5, 1]), [0, 0.5, 1])
True

Initialize a Chebfun representing a constant function f(x) = c.

Parameters:

Returns:

Examples:

>>> import numpy as np
>>> f = Chebfun.initconst(3.14, [-1, 1])
>>> float(f(0))
3.14
>>> float(f(0.5))
3.14
>>> np.allclose(f([0, 0.5, 1]), [3.14, 3.14, 3.14])
True

Initialize a Chebfun by adaptively sampling a function.

This method determines the appropriate number of points needed to represent the function to the specified tolerance using an adaptive algorithm.

Parameters:

Returns:

Examples:

>>> import numpy as np
>>> f = Chebfun.initfun_adaptive(lambda x: np.sin(x), [-np.pi, np.pi])
>>> bool(abs(f(0)) < 1e-10)
True
>>> bool(abs(f(np.pi/2) - 1) < 1e-10)
True

Initialize a Chebfun with a fixed number of points.

This method uses a specified number of points to represent the function, rather than determining the number adaptively.

Parameters:

Returns:

Raises:

Initialize a Chebfun from a function.

This is a general-purpose constructor that delegates to either initfun_adaptive or initfun_fixedlen based on whether n is provided.

Parameters:

Returns:

Add a Chebfun with another Chebfun or a scalar.

Parameters:

Returns:

Evaluate the Chebfun at points x.

This method evaluates the Chebfun at the specified points. It handles interior points, breakpoints, and points outside the domain appropriately.

Parameters:

Returns:

Return an iterator over the functions in this Chebfun.

Returns:

Return the total number of coefficients across all funs.

Returns:

Test for equality between two Chebfun objects.

Two Chebfun objects are considered equal if they have the same domain and their function values are equal (within tolerance) at a set of test points.

Parameters:

Returns:

Multiply a Chebfun with another Chebfun or a scalar.

Parameters:

Returns:

Return the negative of this Chebfun.

Returns:

Return the positive of this Chebfun (which is the Chebfun itself).

Returns:

Return the absolute value of this Chebfun.

Returns:

Raise this Chebfun to a power.

Parameters:

Returns:

Divide a scalar by this Chebfun.

This method is called when a scalar is divided by a Chebfun, i.e., c / self.

Parameters:

Returns:

Return a string representation of the Chebfun.

This method returns a detailed string representation of the Chebfun, including information about its domain, intervals, and endpoint values.

Returns:

Subtract this Chebfun from another object.

This method is called when another object is subtracted by this Chebfun, i.e., f - self.

Parameters:

Returns:

Raise another object to the power of this Chebfun.

This method is called when another object is raised to the power of this Chebfun, i.e., f ** self.

Parameters:

Returns:

Divide this Chebfun by another object.

Parameters:

Returns:

Return a human-readable string representation of the Chebfun.

This method returns the same detailed representation as __repr__, so that print(f) shows the full summary table. This is consistent with the behaviour of numpy and pandas objects.

Returns:

Subtract another object from this Chebfun.

Parameters:

Returns:

Get the imaginary part of this Chebfun.

Returns:

Get the real part of this Chebfun.

Returns:

Create a deep copy of this Chebfun.

Returns:

Restrict a Chebfun to a subinterval.

This method creates a new Chebfun that is restricted to the specified subinterval and simplifies the result.

Parameters:

Returns:

Restrict a Chebfun to a subinterval, modifying the object in place.

This method modifies the current Chebfun by restricting it to the specified subinterval and simplifying the result.

Parameters:

Returns:

Compute the roots of a Chebfun.

This method finds the values x for which f(x) = 0, by computing the roots of each piece of the Chebfun and combining them.

Parameters:

Returns:

Examples:

>>> import numpy as np
>>> f = Chebfun.initfun_adaptive(lambda x: x**2 - 1, [-2, 2])
>>> roots = f.roots()
>>> len(roots)
2
>>> np.allclose(sorted(roots), [-1, 1])
True

Simplify each fun in the chebfun.

Translate a chebfun by c, i.e., return f(x-c).

Compute the indefinite integral (antiderivative) of the Chebfun.

This method computes the indefinite integral of the Chebfun, with the constant of integration chosen so that the indefinite integral evaluates to 0 at the left endpoint of the domain. For piecewise functions, constants are added to ensure continuity across the pieces.

Returns:

Examples:

>>> import numpy as np
>>> f = Chebfun.initconst(1.0, [-1, 1])
>>> F = f.cumsum()
>>> bool(abs(F(-1)) < 1e-10)
True
>>> bool(abs(F(1) - 2.0) < 1e-10)
True

Compute the derivative of the Chebfun.

This method calculates the nth derivative of the Chebfun with respect to x. It creates a new Chebfun where each piece is the derivative of the corresponding piece in the original Chebfun.

Parameters:

Returns:

Examples:

>>> from chebpy import chebfun
>>> f = chebfun(lambda x: x**3)
>>> df1 = f.diff()    # first derivative: 3*x**2
>>> df2 = f.diff(2)   # second derivative: 6*x
>>> df3 = f.diff(3)   # third derivative: 6
>>> bool(abs(df1(0.5) - 0.75) < 1e-10)
True
>>> bool(abs(df2(0.5) - 3.0) < 1e-10)
True
>>> bool(abs(df3(0.5) - 6.0) < 1e-10)
True

Compute the convolution of this Chebfun with g.

Computes h(x) = (f ★ g)(x) = ∫ f(t) g(x-t) dt, where domain(f) is [a, b] and domain(g) is [c, d]. The result is a piecewise Chebfun on [a + c, b + d] whose breakpoints are the pairwise sums of the breakpoints of f and g.

Both f and g may be piecewise (contain an arbitrary number of funs).

When both inputs are single-piece with equal-width domains, the fast Hale-Townsend Legendre convolution algorithm is used. Otherwise, each output sub-interval is constructed adaptively using Gauss-Legendre quadrature.

Parameters:

Returns:

Examples:

>>> import numpy as np
>>> from chebpy import chebfun
>>> f = chebfun(lambda x: np.ones_like(x), [-1, 1])
>>> h = f.conv(f)
>>> bool(abs(h(0.0) - 2.0) < 1e-10)
True
>>> bool(abs(h(-1.0) - 1.0) < 1e-10)
True
>>> bool(abs(h(1.0) - 1.0) < 1e-10)
True

Compute the definite integral of the Chebfun over its domain.

This method calculates the definite integral of the Chebfun over its entire domain of definition by summing the definite integrals of each piece.

Returns:

Examples:

>>> import numpy as np
>>> f = Chebfun.initfun_adaptive(lambda x: x**2, [-1, 1])
>>> bool(abs(f.sum() - 2.0/3.0) < 1e-10)
True
>>> g = Chebfun.initconst(1.0, [-1, 1])
>>> bool(abs(g.sum() - 2.0) < 1e-10)
True

Compute the dot product of this Chebfun with another function.

This method calculates the inner product (dot product) of this Chebfun with another function f by multiplying them pointwise and then integrating the result over the domain.

Parameters:

Returns:

Compute the Lp norm of the Chebfun over its domain.

This method calculates the Lp norm of the Chebfun. The L2 norm is the default and is computed as sqrt(integral(|f|^2)). For p=inf, returns the maximum absolute value by checking critical points (extrema).

Parameters:

Returns:

Examples:

>>> from chebpy import chebfun
>>> import numpy as np
>>> f = chebfun(lambda x: x**2, [-1, 1])
>>> np.allclose(f.norm(), 0.6324555320336759)  # L2 norm
True
>>> np.allclose(f.norm(np.inf), 1.0)  # Maximum absolute value
True

Absolute value of a Chebfun.

Sign function of a Chebfun.

Computes the piecewise sign of a Chebfun by finding its roots and splitting the domain at those points, then creating constant pieces with the appropriate sign values.

Returns:

Ceiling function of a Chebfun.

Computes the piecewise ceiling of a Chebfun by finding where the function crosses integer values and splitting the domain at those points, then creating constant pieces with the appropriate ceiling values.

Returns:

Floor function of a Chebfun.

Computes the piecewise floor of a Chebfun by finding where the function crosses integer values and splitting the domain at those points, then creating constant pieces with the appropriate floor values.

Returns:

Pointwise maximum of self and another chebfun.

Pointwise mimimum of self and another chebfun.

Plot the Chebfun over its domain.

This method plots the Chebfun over its domain using matplotlib. For complex-valued Chebfuns, it plots the real part against the imaginary part.

For Chebfuns with ±inf endpoints (containing :class:CompactFun pieces), each unbounded endpoint is replaced for plotting purposes with the corresponding plot_support endpoint of the outermost :class:CompactFun piece, so the decay-to-zero region is visible.

Parameters:

Returns:

Plot the coefficients of the Chebfun on a semilogy scale.

This method plots the absolute values of the coefficients for each piece of the Chebfun on a semilogy scale, which is useful for visualizing the decay of coefficients in the Chebyshev series.

Parameters:

Returns:

Create a new :class:CompactFun instance.

Parameters:

Initialise an empty CompactFun on (-inf, +inf).

Initialise a constant function.

On an unbounded interval the constant c becomes the asymptotic value on each unbounded side: tail_left = tail_right = c. This makes initconst total — every constant is representable on every interval — but note that integrating a non-zero constant over an unbounded logical interval will (correctly) raise :class:~chebpy.exceptions.DivergentIntegralError.

Initialise the identity function f(x) = x.

The identity function is unbounded and so cannot be represented as a :class:CompactFun on an unbounded interval. This method is provided only for completeness and refuses any infinite endpoint.

Initialise from a callable using adaptive sampling.

Discovers the numerical support and asymptotic tail constants of f on the (possibly unbounded) logical interval, then builds a standard adaptive :class:Onefun on that finite storage interval.

Raises:

Initialise from a callable using a fixed number of points.

Discovers numerical support and tails as in :meth:initfun_adaptive, then builds a fixed-length :class:Onefun on the storage interval.

Evaluate the function at x.

Outside the storage interval, returns the corresponding tail constant when the matching logical endpoint is ±inf (default 0.0), or 0.0 when the logical endpoint is finite.

Return a string representation showing the logical interval, size, and tails.

Compute the definite integral over the logical interval.

Raises:

Compute the indefinite integral.

For a :class:CompactFun with zero asymptote on the unbounded left/right side, the antiderivative is well-defined; it is itself a :class:CompactFun whose right-tail equals ∫f and whose left-tail is 0 (anchored so F(-inf) = 0).

Raises:

Compute the derivative.

The derivative of a function with constant asymptotic limits has zero asymptotes, so the result has tail_left = tail_right = 0.

Find the roots, filtering out spurious roots in numerical-noise regions.

The underlying polynomial approximation can produce many spurious roots in regions where the function has decayed to numerical noise (typically near the boundary of the storage interval). We keep a candidate root r only if both:

• f(r - δ) and f(r + δ) have opposite signs (the function actually crosses zero), and
• max(|f(r - δ)|, |f(r + δ)|) exceeds numsupp_tol * vscale (the values are above numerical noise).

Here delta = 1e-3 * storage_width. This heuristic does not preserve double roots; that is a documented limitation since double roots are uncommon in the decay-to-zero functions that :class:CompactFun is designed for.

Restrict to a finite subinterval, returning a :class:Bndfun.

Translate by c along the real line, preserving both intervals and tails.

Return -f; negates both tail constants.

Pointwise addition; combines tail constants additively.

Right-hand addition for scalar + CompactFun.

Pointwise subtraction; combines tail constants additively.

Right-hand subtraction for scalar - CompactFun.

Pointwise multiplication; combines tail constants multiplicatively.

Right-hand multiplication for scalar * CompactFun.

Plot the function over a finite window derived from its numerical support.

For doubly- or singly-infinite logical intervals, the plotting window defaults to the numerical-support interval padded by 10% on each unbounded side. Pass an explicit support=(a, b) keyword to override.

Initialise a Trigtech from a constant c.

Initialise an empty Trigtech.

Trigtech approximation of the identity f(x) = x on [-1, 1].

Note: f(x) = x is not periodic on [-1, 1], so this will not converge to machine precision. It is provided for interface compatibility with Chebtech; in practice Classicfun.initidentity is used instead.

Convenience constructor: adaptive if n is None, fixed-length otherwise.

Initialise a Trigtech from callable fun using n equispaced points.

Initialise a Trigtech from callable fun using the adaptive constructor.

Initialise a Trigtech from function values at equispaced points.

Initialise a Trigtech with FFT-order coeffs on interval.

Coefficients are always stored as complex128. The :attr:iscomplex property returns True only when the function values are complex (i.e., the coefficients do not satisfy the conjugate-symmetry condition C_{n-k} ≈ conj(C_k)).

Parameters:

Evaluate the Trigtech at points x via the DFT summation formula.

f(x) = Σ_k coeffs[k] * exp(iπω_k*(x+1))

where ω_k = fftfreq(n)*n gives integer frequencies in FFT order. For real-valued functions the imaginary part of the result is discarded.

Parameters:

Return a concise string representation.

Return a deep copy.

Return the imaginary part of the function as a real-valued Trigtech.

For a complex function f(x) = g(x) + i·h(x), the Fourier coefficients of h(x) are H[k] = (D[k] - conj(D[n-k])) / (2i) for k ≥ 1, and H[0] = Im(D[0]).

Return a Trigtech of length n (truncate or zero-pad in frequency space).

The operation aligns DC components of the source and target DC-centred representations, then either pads with zeros (n > m) or slices (n < m). This correctly handles the asymmetry between even- and odd-length arrays.

Return the real part of the function as a real-valued Trigtech.

For a complex function f(x) = g(x) + i·h(x), the Fourier coefficients of g(x) are G[k] = (D[k] + conj(D[n-k])) / 2 for k ≥ 1, and G[0] = Re(D[0]).

Truncate high-frequency Fourier coefficients that are below tolerance.

Uses the same one-sided symmetric-maximum criterion as the adaptive constructor: the highest-frequency mode retained is the one where max(|c_k|, |c_{-k}|) / vscale > tol.

Function values at the n equispaced points x_j = -1 + 2j/n.

Add a scalar or another Trigtech.

Divide this Trigtech by a scalar or another Trigtech.

Multiply this Trigtech by a scalar or another Trigtech.

Trig-polynomial multiplication is circular convolution in frequency space. We implement this cleanly by evaluating both on a grid of size n1 + n2 (sufficient to avoid aliasing), multiplying pointwise, and taking the FFT.

Return the negation.

Return self (unary plus).

Raise this Trigtech to a power f (scalar or Trigtech).

Compute f / self where f is a scalar.

Compute f - self.

Compute f ** self.

Subtract f (scalar or Trigtech) from this Trigtech.

Find the roots of this Trigtech on [-1, 1].

Converts to a Chebyshev representation via re-sampling on Chebyshev points and delegates to the Chebtech colleague-matrix root-finder.

Parameters:

Definite integral of the Trigtech over [-1, 1].

Indefinite integral, zero at x = -1, in Fourier coefficient space.

For mode k ≠ 0: antiderivative coefficient = c_k / (iπω_k) For mode k = 0: set to the constant needed so that F(-1) = 0.

Note: if the DC component (self.coeffs[0]) is non-zero the true antiderivative contains a linear trend and is not periodic. We still return a Trigtech representing the periodic part, adjusted so that the result evaluates to 0 at x = -1.

Derivative via the Fourier multiplier iπω_k.

d/dx [c_k * exp(iπω_k(x+1))] = iπω_k * c_k * exp(iπω_k(x+1))

Plot the Trigtech over [-1, 1].

Parameters:

Returns:

Plot the absolute Fourier coefficient magnitudes in DC-centred order.

Uses _coeffs_to_plotorder() so the horizontal axis runs from the most-negative frequency on the left to the most-positive on the right, with DC in the centre.

Parameters:

Returns:

Initialise from a list of Chebfun objects, callables, or scalars.

Column indexing: A[:, k] returns column k as a Chebfun.

Return the number of columns.

Iterate over the columns.

Evaluate every column at x and return the results as an array.

If x is a scalar the result has shape (n,). If x is an array of length m the result has shape (m, n).

Matrix-vector product: A @ c returns a Chebfun.

other must be a 1-D array-like of length n.

Element-wise scalar multiplication.

Right scalar multiplication.

Definite integral of each column (column sums).

Gram matrix self.T @ other (or self.T @ self).

Compute the reduced QR factorization A = Q R.

Uses modified Gram-Schmidt orthogonalisation in function space.

Returns:

Compute the reduced SVD A = U S V^T.

Returns:

Least-squares solution c to A c ~ f.

Equivalent to MATLAB A\f. Computed via QR factorisation.

Compute the norm of the quasimatrix.

Parameters:

2-norm condition number (ratio of largest to smallest singular value).

Numerical rank (number of significant singular values).

Orthonormal basis for the null space of the quasimatrix.

Returns an n x k NumPy array whose columns span null(A).

Orthonormal basis for the column space (range) of the quasimatrix.

Moore-Penrose pseudoinverse (returned as an n x inf row quasimatrix).

pinv(A) @ f gives the same result as A.solve(f).

Plot all columns on the same axes.

Visualise the shape of the quasimatrix.

Draws a rectangle representing the inf x n structure, with a dot for each column to indicate nonzero content.

Return a string representation.

Return a string representation.

Reset default preferences.

.reset() resets all preferences to the DefaultPrefs state .reset(*names) resets only the selected ones. This leaves additional user-added prefs untouched.

Create or return the singleton instance of ChebPreferences.

This method implements the singleton pattern, ensuring that only one instance of ChebPreferences exists. If an instance already exists, it returns that instance; otherwise, it creates a new one.

Parameters:

Returns:

Save current preferences when entering a context.

This method is called when entering a context manager block. It saves the current preferences to a stack so they can be restored when exiting the context.

Parameters:

Returns:

Restore previous preferences when exiting a context.

This method is called when exiting a context manager block. It restores the preferences to their previous values by popping the stashed values from the stack and setting them back on the object.

Parameters: