__init__(self, *diffs, axes=0, contract=False): 

Constructs an object to take finite differences derivatives of grids of data

• diffs: FiniteDifference1D

  A set of differences to take along successive axes in the data

• axes: int | Iterable[int]

  The axes to take the specified differences along

• contract: bool

  Whether to reduce the shape of the returned tensor if applicable after application

apply(self, vals, axes=None, mesh_spacing=None, contract=None): 

Iteratively applies the stored finite difference objects to the vals

• vals: np.ndarray

  The tensor of values to take the difference on

• axes: int | Iterable[int]

  The axis or axes to take the differences along (defaults to self.axes)

• :returns: np.ndarray

  T h e

t e n s o r

o f

d e r i v a t i v e s

__call__(self, vals, axes=None, mesh_spacing=None): 

@property
order(self): 

• :returns: tuple[int]

  t h e

o r d e r

o f

t h e

d e r i v a t i v e

r e q u e s t e d

@property
weights(self): 

• :returns: tuple[np.array[float]]

  t h e

w e i g h t s

f o r

t h e

s p e c i f i e d

s t e n c i l

@property
widths(self): 

• :returns: tuple[(int, int)]

  t h e

n u m b e r

o f

p o i n t s

i n

e a c h

d i m e n s i o n ,

l e f t

a n d

r i g h t ,

f o r

t h e

s p e c i f i e d

s t e n c i l

@classmethod
regular_difference(cls, order, mesh_spacing=None, accuracy=2, stencil=None, end_point_accuracy=2, axes=0, contract=True, **kwargs): 

Constructs a FiniteDifferenceFunction appropriate for a regular grid with the given stencil

• order: tuple[int]

  the order of the derivative

• mesh_spacing: None | float | tuple[float]

  the spacing between grid points in the regular grid h

• accuracy: None | int | tuple[int]

  the accuracy of the derivative that we’ll try to achieve as a power on h

• stencil: None | int | tuple[int]

  the stencil to use for the derivative (overrides accuracy)

• end_point_accuracy: None | int | tuple[int]

  the amount of extra accuracy to use at the edges of the grid

• axes: None | int | tuple[int]

  the axes of the passed array for the derivative to be applied along

• contract: bool

  whether to eliminate any axes of size 1 from the results

• kwargs: Any

• :returns: _

@classmethod
from_grid(cls, grid, order, accuracy=2, stencil=None, end_point_accuracy=2, axes=0, contract=True, **kwargs): 

Constructs a FiniteDifferenceFunction from a grid and order. Deconstructs the grid into its subgrids and builds a different differencer for each dimension

• grid: np.ndarray

  The grid to use as input data when defining the derivative

• order: int or list of ints

  order of the derivative to compute

• stencil: int or list of ints

  number of points to use in the stencil

• :returns: FiniteDifferenceFunction

  d e r i v

f u n c