AbstractExplicitMatrixArray#

class named_arrays.AbstractExplicitMatrixArray#

Bases: AbstractMatrixArray, AbstractExplicitVectorArray

Attributes

`axes`	A `tuple` of `str` representing the names of each dimension of this array.
`axes_flattened`	Combine `axes` into a single `str`.
`broadcasted`	if this array has multiple components, broadcast them against each other.
`cartesian_nd`	Convert all cartesian vectors making up the matrix to instances of `AbstractCartesianNdVectorArray`
`column_prototype`	Return a vector representing a column of the matrix with each component zeroed.
`components`	The vector components of this array expressed as a `dict`, where the keys are the names of the component.
`determinant`	The determinant of this matrix
`entries`	The scalar entries that compose this object.
`explicit`	Converts this array to an instance of `named_arrays.AbstractExplicitArray`.
`indices`	Compute the index of each element of this array.
`inverse`	The inverse of this matrix
`is_consistent`	Check if all the rows of the matrix have the same abstract type.
`is_square`	Check if this matrix has the same number of rows and columns.
`length`	L2-norm of this array.
`matrix`	Cast this vector into its matrix representation.
`matrix_transpose`	Swap the rows and columns of this matrix.
`ndim`	Number of dimensions of the array.
`prototype_vector`	Return vector of same type with all components zeroed.
`row_prototype`	Return a vector of the same type as each row of the matrix.
`rows`	Rows of the matrix, same as `components`
`shape`	The number of elements along each axis of the array.
`size`	Total number of elements in the array.
`type_abstract`	The `named_arrays.AbstractArray` type corresponding to this array.
`type_explicit`	The `named_arrays.AbstractExplicitArray` type corresponding to this array.
`type_matrix`	The corresponding `named_arrays.AbstractMatrixArray` class
`type_vector`	The corresponding `named_arrays.AbstractVectorArray` class
`value`	Returns a new array with its units removed, if they exist.

Methods

`__init__`()
`add_axes`(axes)	Add new singleton axes to this array.
`all`([axis, where])	Return `True` if all of the elements along the given axes are `True`.
`any`([axis, where])	Return `True` if any of the elements along the given axes are `True`.
`astype`(dtype[, order, casting, subok, copy])	Copy of the array cast to a specific data type.
`broadcast_to`(shape[, append])	A new view of this array with the specified shape.
`cell_centers`([axis, random])	Convert an array from cell vertices to cell centers.
`combine_axes`([axes, axis_new])	Combine some of the axes of the array into a single new axis.
`copy`()	Create a deep copy of this array.
`copy_shallow`()	Create a shallow copy of this array.
`from_cartesian_nd`(array[, like])	Construct a new instance of this class using an instance of `named_arrays.CartesianNdVectorArray`.
`from_components`(components)	Construct a new instance of this class using a `dict` of components.
`from_scalar`(scalar[, like])	Convert a scalar (an instance of `named_arrays.AbstractScalar`) into a vector.
`from_scalar_array`(a[, like])	Constructs a new version of this array using `a` as the underlying data.
`index`(value[, axis])
`index_secant`(value[, axis])
`interp_linear`(item)	Linearly interpolate this array to find its value at the given fractional index.
`max`([axis, initial, where])	The maximum value of this array along the given axes.
`mean`([axis, where])	The mean value of this array along the given axes.
`median`([axis])	The median value of this array along the given axes.
`min`([axis, initial, where])	The minimum value of this array along the given axes.
`ndindex`([axis_ignored])	An iterator that yields the index of each element of this array.
`percentile`(q[, axis, out, overwrite_input, ...])	The requested percentile of this array along the given axes.
`prototype_matrix`([row])
`ptp`([axis])	The peak-to-peak value of this array along the given axes.
`replace`(**changes)	A method version of `dataclasses.replace()` for named arrays.
`reshape`(shape)	Reorganize this array into a new shape.
`rms`([axis, where])	The root-mean-square of this array along the given axes.
`std`([axis, where])	The standard deviation of this array along the given axes.
`sum`([axis, where])	The sum of each element of this array along the given axes.
`take_along_axis`(indices, axis)	Take values from this array by matching `indices` along `axis`.
`to`(unit[, equivalencies, copy])	Convert this array to a new unit.
`to_string`([prefix, multiline])	Convert this array instance to a string representation.
`to_string_array`([format_value, format_unit, ...])	Convert to an array of strings where each string has an appropriately-formatted unit attached to the value.
`to_value`(unit[, equivalencies])	The numerical value of this array, possibly in a different unit.
`transpose`([axes])	Reorder the axes of this array to the given sequence.
`var`([axis, where])	The variance of this array along the given axes.
`vmr`([axis, where])	The variance-to-mean ratio of this array along the given axes.
`volume_cell`(axis)	Computes the n-dimensional volume of each cell formed by interpreting this array as a logically-rectangular grid of vertices.

Inheritance Diagram

classmethod from_cartesian_nd(array, like=None)#

Construct a new instance of this class using an instance of named_arrays.CartesianNdVectorArray.

Parameters:

array (CartesianNdMatrixArray) – The $n$-dimensional cartesian vector to convert.
like (None | AbstractExplicitMatrixArray) – A reference instance of the result. This is needed if the resulting class has components that are themselves vectors.

Return type:

AbstractExplicitMatrixArray

classmethod from_components(components)#

Construct a new instance of this class using a dict of components.

Parameters:: components (dict[str, AbstractArray]) – A dict of component names and values. The keys of the dict must match the names of the components in this class.
Return type:: AbstractExplicitVectorArray

classmethod from_scalar(scalar, like=None)#

Convert a scalar (an instance of named_arrays.AbstractScalar) into a vector.

Parameters:

scalar (int | float | complex | ndarray | Quantity | AbstractScalar)
like (None | AbstractExplicitVectorArray)

Return type:

AbstractExplicitVectorArray

classmethod from_scalar_array(a, like=None)#

Constructs a new version of this array using a as the underlying data.

Parameters:

a (None | float | Quantity | AbstractArray) – Anything that can be coerced into an instance of named_arrays.AbstractScalarArray.
like (None | AbstractExplicitVectorArray) – Optional reference object. If provided, the result will be defined by this object.

Return type:

AbstractExplicitVectorArray

add_axes(axes)#

Add new singleton axes to this array.

Parameters:

axes (str | Sequence[str]) – Either a single axis name or a sequence of axis names add to this array.
self (Self)

Return type:

AbstractExplicitVectorArray

See also

named_arrays.add_axes(): A functional version of this method.

all(axis=None, where=<no value>)#

Return True if all of the elements along the given axes are True.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.all(): A functional version of this method.

any(axis=None, where=<no value>)#

Return True if any of the elements along the given axes are True.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.any(): A functional version of this method.

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)#

Copy of the array cast to a specific data type.

Equivalent to numpy.ndarray.astype().

Parameters:

self (Self)
dtype (str | dtype | Type | dict[str, str | dtype | Type])
order (str)
subok (bool)
copy (bool)

Return type:

Self

broadcast_to(shape, append=False)#

A new view of this array with the specified shape.

Parameters:

shape (dict[str, int]) – The shape of the new array.
append (bool) – If True, shape will be appended to the current shape of this array before broadcasting.
self (Self)

Return type:

Self

See also

named_arrays.broadcast_to(): A functional version of this method.

cell_centers(axis=None, random=False)#

Convert an array from cell vertices to cell centers.

Parameters:

axis (None | str | Sequence[str]) – The axes of the array to average over.
random (bool) – If true, select a random point within each cell instead of the geometric center.

Return type:

AbstractExplicitArray

combine_axes(axes=None, axis_new=None)#

Combine some of the axes of the array into a single new axis.

Parameters:

axes (Sequence[str]) – The axes to combine into a new axis
axis_new (str) – The name of the new axis
self (Self)

Return type:

Array with the specified axes combined

copy()#

Create a deep copy of this array.

Parameters:: self (Self)
Return type:: Self

copy_shallow()#

Create a shallow copy of this array.

Parameters:: self (Self)
Return type:: Self

index(value, axis=None)#

Parameters:

self (Self)
value (Self)
axis (None | str | Sequence[str])

Return type:

dict[str, Self]

index_secant(value, axis=None)#

Parameters:

self (Self)
value (Self)
axis (None | str | Sequence[str])

Return type:

dict[str, Self]

interp_linear(item)#

Linearly interpolate this array to find its value at the given fractional index.

Parameters:

item (dict[str, Self]) – A fractional index at which to evaluate the array.
self (Self)

Return type:

Self

max(axis=None, initial=<no value>, where=<no value>)#

The maximum value of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
initial (ArrayLike) – The initial value of the minimum, required if where provided.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.max(): A functional version of this method.

mean(axis=None, where=<no value>)#

The mean value of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.mean(): A functional version of this method.

median(axis=None)#

The median value of this array along the given axes.

Parameters:: axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.

See also

numpy.median(): A functional version of this method.

min(axis=None, initial=<no value>, where=<no value>)#

The minimum value of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
initial (ArrayLike) – The initial value of the minimum, required if where provided.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.min(): A functional version of this method.

ndindex(axis_ignored=None)#

An iterator that yields the index of each element of this array.

Parameters:

axis_ignored (None | str | Sequence[str]) – The of the array to ignore when generating the iterator.
self (Self)

Return type:

Iterator[dict[str, int]]

See also

named_arrays.ndindex(): A functional version of this method.

percentile(q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False)#

The requested percentile of this array along the given axes.

Parameters:

q (int | float | Quantity | Self) – The percentile to compute.
axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
out (None | Self) – An optional output array in which to place the result.
overwrite_input (bool) – Whether to overwrite the input array.
method (str) – How to interpolate the result.
keepdims (bool) – A boolean flag indicating whether to keep the reduced dimensions.
self (Self)

See also

numpy.percentile(): A functional version of this method.

prototype_matrix(row=None)#

Parameters:: row (AbstractVectorArray)

ptp(axis=None)#

The peak-to-peak value of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
self (Self)

Return type:

Self

See also

numpy.ptp(): A functional version of this method.

replace(**changes)#

A method version of dataclasses.replace() for named arrays.

Parameters:: changes – The fields of the dataclass to be overwritten
Return type:: Self

reshape(shape)#

Reorganize this array into a new shape.

Parameters:

shape (dict[str, int]) – The new shape of the array, must be compatible with this array.
self (Self)

Return type:

Self

rms(axis=None, where=<no value>)#

The root-mean-square of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

std(axis=None, where=<no value>)#

The standard deviation of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.std(): A functional version of this method.

sum(axis=None, where=<no value>)#

The sum of each element of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.sum(): A functional version of this method.

take_along_axis(indices, axis)#

Take values from this array by matching indices along axis.

Parameters:

indices (AbstractArray) – The integer indices to take along axis.
axis (str) – The axis of this array along which the values are taken.
self (Self)

Return type:

Self

See also

named_arrays.take_along_axis(): A functional version of this method.

to(unit, equivalencies=[], copy=True)#

Convert this array to a new unit.

Equivalent to astropy.units.Quantity.to().

Parameters:

unit (UnitBase | dict[str, None | UnitBase]) – New unit of the returned array
equivalencies (None | list[tuple[Unit, Unit]]) – A list of equivalence pairs to try if the units are not directly convertible.
copy (bool) – Boolean flag controlling whether to copy the array.
self (Self)

Return type:

AbstractExplicitVectorArray

to_string(prefix=None, multiline=None)#

Convert this array instance to a string representation.

Parameters:

prefix (None | str) – the length of this string is used to align the output
multiline (None | bool) – flag which controls if the output should be spread over multiple lines.

Return type:

array represented as a str

to_string_array(format_value='%.2f', format_unit='latex_inline', pad_unit='$\\,$')#

Convert to an array of strings where each string has an appropriately-formatted unit attached to the value.

Parameters:

format_value (str) – The string used to format the numeric value of each element.
format_unit (str) – The string used to format the units of each element.
pad_unit (str) – The string used to add horizontal space between the value and unit.

Return type:

AbstractExplicitVectorArray

to_value(unit, equivalencies=[])#

The numerical value of this array, possibly in a different unit.

Equivalent to astropy.units.Quantity.to_value().

Parameters:

unit (UnitBase | dict[str, None | UnitBase]) – New unit of the returned array
equivalencies (None | list[tuple[Unit, Unit]]) – A list of equivalence pairs to try if the units are not directly convertible.
self (Self)

Return type:

AbstractExplicitVectorArray

transpose(axes=None)#

Reorder the axes of this array to the given sequence.

Parameters:

axes (None | Sequence[str]) – The new axis ordering of this array.
self (Self)

Return type:

Self

See also

numpy.transpose(): The numpy version of this method.

var(axis=None, where=<no value>)#

The variance of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.
self (Self)

Return type:

Self

See also

numpy.var(): A functional version of this method.

vmr(axis=None, where=<no value>)#

The variance-to-mean ratio of this array along the given axes.

Parameters:

axis (None | str | Sequence[str]) – The logical axis or axes along which the operation is computed.
where (Self) – An optional mask which selects which elements to be considered.

volume_cell(axis)#

Computes the n-dimensional volume of each cell formed by interpreting this array as a logically-rectangular grid of vertices.

Note that this method is usually only used for sorted arrays.

If self is a scalar, this method computes the length of each edge, and is equivalent to numpy.diff(). If self is a 2d vector, this method computes the area of each quadrilateral, and if self is a 3d vector, this method computes the volume of each cuboid.

Parameters:: axis (None | str | Sequence[str]) – The axis or axes defining the logically-rectangular grid. If self is a physical scalar, there should only be one axis. If self is a physical vector, there should be one axis for each component of the vector.
Return type:: AbstractScalar

property axes: tuple[str, ...]#

A tuple of str representing the names of each dimension of this array.

Must have the same length as the number of dimensions of this array.

property axes_flattened: str#

Combine axes into a single str.

This is useful for functions like numpy.flatten() which returns an array with only one dimension.

property broadcasted: AbstractExplicitArray#

if this array has multiple components, broadcast them against each other.

Equivalent to a.broadcast_to(a.shape).

property cartesian_nd: AbstractCartesianNdMatrixArray#: Convert all cartesian vectors making up the matrix to instances of AbstractCartesianNdVectorArray

property column_prototype: AbstractMatrixArray#: Return a vector representing a column of the matrix with each component zeroed.

property components: dict[str, AbstractVectorArray]#: The vector components of this array expressed as a dict, where the keys are the names of the component.

abstract property determinant: int | float | complex | ndarray | Quantity | AbstractScalar#: The determinant of this matrix

property entries: dict[tuple[str, ...], int | float | complex | ndarray | Quantity | AbstractScalar]#: The scalar entries that compose this object.

property explicit: AbstractExplicitVectorArray#: Converts this array to an instance of named_arrays.AbstractExplicitArray.

property indices: dict[str, ScalarArrayRange]#

Compute the index of each element of this array.

See also

named_arrays.indices(): A functional version of this method.

property inverse: AbstractMatrixArray#: The inverse of this matrix

property is_consistent: bool#: Check if all the rows of the matrix have the same abstract type.

property is_square#: Check if this matrix has the same number of rows and columns.

abstract property length: AbstractScalar#: L2-norm of this array.

property matrix: AbstractMatrixArray#: Cast this vector into its matrix representation.

property matrix_transpose#

Swap the rows and columns of this matrix.

This is distinct from numpy.transpose() since this operates on the physical components instead of the logical ones.

property ndim: int#: Number of dimensions of the array. Equivalent to numpy.ndarray.ndim.

property prototype_vector: AbstractExplicitVectorArray#: Return vector of same type with all components zeroed.

property row_prototype: AbstractVectorArray#: Return a vector of the same type as each row of the matrix.

property rows: dict[str, AbstractVectorArray]#: Rows of the matrix, same as components

property shape: dict[str, int]#: The number of elements along each axis of the array. Analogous to numpy.ndarray.shape but represented as a dict where the keys are the axis names and the values are the axis sizes.

property size: int#: Total number of elements in the array. Equivalent to numpy.ndarray.size

abstract property type_abstract: Type[AbstractArray]#: The named_arrays.AbstractArray type corresponding to this array.

abstract property type_explicit: Type[AbstractExplicitVectorArray]#: The named_arrays.AbstractExplicitArray type corresponding to this array.

abstract property type_matrix: Type[AbstractExplicitMatrixArray]#: The corresponding named_arrays.AbstractMatrixArray class

abstract property type_vector: Type[AbstractExplicitVectorArray]#: The corresponding named_arrays.AbstractVectorArray class

property value: AbstractExplicitVectorArray#: Returns a new array with its units removed, if they exist.