AbstractCartesian3D

class kgpy.vectors.AbstractCartesian3D

Bases: AbstractCartesian2D[XT, YT], Generic[XT, YT, ZT]

__init__()

Return type:

None

Attributes

array
array_labeled
broadcasted
centers
component_sum
components
coordinates
cylindrical
dtype
indices
length
ndim
normalized
polar
shape
spherical
tuple
type_coordinates
type_matrix
unit
x
xy
y
z
zx

Methods

__init__()
add_axes(axes)	rtype: typing.TypeVar(VectorInterfaceT, bound= VectorInterface)
aligned(shape)	rtype: typing.TypeVar(AbstractVectorT, bound= AbstractVector)
all([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
any([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
astype(dtype[, order, casting, subok, copy])	rtype: typing.TypeVar(VectorInterfaceT, bound= VectorInterface)
broadcast_to(shape)	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
combine_axes(axes[, axis_new])	rtype: typing.TypeVar(VectorInterfaceT, bound= VectorInterface)
copy()	rtype: typing.TypeVar(CopyableT, bound= Copyable)
copy_shallow()	rtype: typing.TypeVar(CopyableT, bound= Copyable)
from_coordinates(coordinates)	rtype: typing.TypeVar(AbstractVectorT, bound= AbstractVector)
index(value[, axis])	rtype: typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]
index_below_brute(value[, axis])	rtype: typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]
index_nearest_brute(value[, axis, where])	rtype: typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]
index_secant(value[, axis, damping])	rtype: typing.Dict[str, typing.TypeVar(ArrayT, bound= Array)]
interp_linear(item)	rtype: typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)
linear_space(start, stop, num[, endpoint])	rtype: typing.TypeVar(AbstractVectorT, bound= AbstractVector)
max([axis, initial, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
mean([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
min([axis, initial, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
ndindex([axis_ignored])	rtype: typing.Iterator[typing.Dict[str, int]]
outer(other)	rtype: typing.TypeVar(AbstractMatrixT, bound= AbstractMatrix)
plot(ax, axis_plot[, where, color, ...])	rtype: typing.Tuple[typing.List[matplotlib.lines.Line2D], typing.Optional[matplotlib.cm.ScalarMappable]]
plot_filled(ax, axis_plot[, component_x, ...])	rtype: typing.List[mpl_toolkits.mplot3d.art3d.Poly3DCollection]
prototype()	rtype: typing.Type[typing.TypeVar(AbstractVectorT, bound= AbstractVector)]
ptp([axis])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
reshape(shape)	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
rms([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
scatter(ax, axis_plot[, where, color, colormap])	rtype: typing.Tuple[typing.List[matplotlib.collections.PathCollection], typing.Optional[matplotlib.cm.ScalarMappable]]
std([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
stratified_random_space(start, stop, num, axis)	rtype: typing.TypeVar(AbstractVectorT, bound= AbstractVector)
sum([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
to(unit)	rtype: typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)
to_3d([z])	rtype: typing.TypeVar(Cartesian3DT, bound= Cartesian3D)
to_matrix()	rtype: typing.TypeVar(AbstractMatrixT, bound= AbstractMatrix)
x_hat()	rtype: typing.TypeVar(AbstractCartesian1DT, bound= AbstractCartesian1D)
y_hat()	rtype: typing.TypeVar(Cartesian1DT, bound= Cartesian1D)
z_hat()	rtype: typing.TypeVar(Cartesian3DT, bound= Cartesian3D)

Inheritance Diagram

digraph inheritancee366b764d2 { bgcolor=transparent; rankdir=TB; size="8.0, 12.0"; "abc.ABC" [URL="https://docs.python.org/3/library/abc.html#abc.ABC",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="Helper class that provides a standard way to create an ABC using"]; "kgpy.labeled.ArrayInterface" [URL="kgpy.labeled.ArrayInterface.html#kgpy.labeled.ArrayInterface",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="ArrayInterface()"]; "kgpy.mixin.Copyable" -> "kgpy.labeled.ArrayInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.labeled.NDArrayMethodsMixin" -> "kgpy.labeled.ArrayInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "numpy.lib.mixins.NDArrayOperatorsMixin" -> "kgpy.labeled.ArrayInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "abc.ABC" -> "kgpy.labeled.ArrayInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "typing.Generic" -> "kgpy.labeled.ArrayInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.labeled.NDArrayMethodsMixin" [URL="kgpy.labeled.NDArrayMethodsMixin.html#kgpy.labeled.NDArrayMethodsMixin",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="NDArrayMethodsMixin()"]; "kgpy.mixin.Copyable" [URL="kgpy.mixin.Copyable.html#kgpy.mixin.Copyable",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top"]; "abc.ABC" -> "kgpy.mixin.Copyable" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.vectors.AbstractCartesian1D" [URL="kgpy.vectors.AbstractCartesian1D.html#kgpy.vectors.AbstractCartesian1D",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="AbstractCartesian1D()"]; "kgpy.vectors.Cartesian" -> "kgpy.vectors.AbstractCartesian1D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "typing.Generic" -> "kgpy.vectors.AbstractCartesian1D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.vectors.AbstractCartesian2D" [URL="kgpy.vectors.AbstractCartesian2D.html#kgpy.vectors.AbstractCartesian2D",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="AbstractCartesian2D()"]; "kgpy.vectors.AbstractCartesian1D" -> "kgpy.vectors.AbstractCartesian2D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "typing.Generic" -> "kgpy.vectors.AbstractCartesian2D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.vectors.AbstractCartesian3D" [URL="kgpy.vectors.AbstractCartesian3D.html#kgpy.vectors.AbstractCartesian3D",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="AbstractCartesian3D()"]; "kgpy.vectors.AbstractCartesian2D" -> "kgpy.vectors.AbstractCartesian3D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "typing.Generic" -> "kgpy.vectors.AbstractCartesian3D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.vectors.Cartesian" [URL="kgpy.vectors.Cartesian.html#kgpy.vectors.Cartesian",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="Cartesian()"]; "kgpy.vectors.VectorInterface" -> "kgpy.vectors.Cartesian" [arrowsize=0.5,style="setlinewidth(0.5)"]; "kgpy.vectors.VectorInterface" [URL="kgpy.vectors.VectorInterface.html#kgpy.vectors.VectorInterface",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="VectorInterface()"]; "kgpy.labeled.ArrayInterface" -> "kgpy.vectors.VectorInterface" [arrowsize=0.5,style="setlinewidth(0.5)"]; "numpy.lib.mixins.NDArrayOperatorsMixin" [URL="https://numpy.org/doc/stable/reference/generated/numpy.lib.mixins.NDArrayOperatorsMixin.html#numpy.lib.mixins.NDArrayOperatorsMixin",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="Mixin defining all operator special methods using __array_ufunc__."]; "typing.Generic" [URL="https://docs.python.org/3/library/typing.html#typing.Generic",fillcolor=white,fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5),filled",target="_top",tooltip="Abstract base class for generic types."]; }

add_axes(axes)

Return type:

typing.TypeVar(VectorInterfaceT, bound= VectorInterface)

Parameters:

• self (VectorInterfaceT) –

• axes (List) –

aligned(shape)

Return type:

typing.TypeVar(AbstractVectorT, bound= AbstractVector)

Parameters:

• self (VectorInterfaceT) –

• shape (Dict[str, int]) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

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

Return type:

typing.TypeVar(VectorInterfaceT, bound= VectorInterface)

Parameters:

• self (VectorInterfaceT) –

• dtype (dtype[Any] | None | type[Any] | _SupportsDType[dtype[Any]] | str | tuple[Any, int] | tuple[Any, SupportsIndex | Sequence[SupportsIndex]] | list[Any] | _DTypeDict | tuple[Any, Any]) –

• order (str) –

• subok (bool) –

• copy (bool) –

broadcast_to(shape)

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• shape (Dict[str, int]) –

combine_axes(axes, axis_new=None)

Return type:

typing.TypeVar(VectorInterfaceT, bound= VectorInterface)

Parameters:

• self (VectorInterfaceT) –

• axes (Sequence[str]) –

• axis_new (str | None) –

copy()

Return type:

typing.TypeVar(CopyableT, bound= Copyable)

Parameters:

self (CopyableT) –

copy_shallow()

Return type:

typing.TypeVar(CopyableT, bound= Copyable)

Parameters:

self (CopyableT) –

classmethod from_coordinates(coordinates)

Return type:

typing.TypeVar(AbstractVectorT, bound= AbstractVector)

Parameters:

coordinates (Dict[str, int | float | ndarray | Quantity | AbstractArray | AbstractArray | VectorInterface]) –

index(value, axis=None)

Return type:

typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]

Parameters:

• self (ArrayInterfaceT) –

• value (ArrayInterfaceT) –

• axis (str | Sequence[str] | None) –

index_below_brute(value, axis=None)

Return type:

typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]

Parameters:

• self (ArrayInterfaceT) –

• value (ArrayInterfaceT) –

• axis (str | Sequence[str] | None) –

index_nearest_brute(value, axis=None, where=None)

Return type:

typing.Dict[str, typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)]

Parameters:

• self (ArrayInterfaceT) –

• value (ArrayInterfaceT) –

• axis (str | Sequence[str] | None) –

• where (ArrayInterfaceT | None) –

index_secant(value, axis=None, damping=1)

Return type:

typing.Dict[str, typing.TypeVar(ArrayT, bound= Array)]

Parameters:

• self (ArrayInterfaceT) –

• value (ArrayInterfaceT) –

• axis (str | Sequence[str] | None) –

• damping (float) –

interp_linear(item)

Return type:

typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)

Parameters:

• self (ArrayInterfaceT) –

• item (Dict[str, AbstractArrayT]) –

classmethod linear_space(start, stop, num, endpoint=True)

Return type:

typing.TypeVar(AbstractVectorT, bound= AbstractVector)

Parameters:

• start (AbstractVectorT) –

• stop (AbstractVectorT) –

• num (AbstractVectorT) –

• endpoint (bool) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• initial (int | float | ndarray | Quantity | None) –

• where (NDArrayMethodsMixinT) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• initial (int | float | ndarray | Quantity | None) –

• where (NDArrayMethodsMixinT) –

ndindex(axis_ignored=None)

Return type:

typing.Iterator[typing.Dict[str, int]]

Parameters:

• self (Type[ArrayInterfaceT]) –

• axis_ignored (str | Sequence[str] | None) –

outer(other)

Return type:

typing.TypeVar(AbstractMatrixT, bound= AbstractMatrix)

Parameters:

• self (AbstractVectorT) –

• other (AbstractVectorT) –

plot(ax, axis_plot, where=None, color=None, colormap=None, component_x='x', component_y='y', component_z='z', **kwargs)

Return type:

typing.Tuple[typing.List[matplotlib.lines.Line2D], typing.Optional[matplotlib.cm.ScalarMappable]]

Parameters:

• self (Cartesian3DT) –

• ax (Axes) –

• axis_plot (str) –

• where (int | float | ndarray | Quantity | AbstractArray | AbstractArray | None) –

• color (int | float | ndarray | Quantity | AbstractArray | None) –

• colormap (ScalarMappable | None) –

• component_x (str) –

• component_y (str) –

• component_z (str) –

• kwargs (Any) –

plot_filled(ax, axis_plot, component_x='x', component_y='y', component_z='z', **kwargs)

Return type:

typing.List[mpl_toolkits.mplot3d.art3d.Poly3DCollection]

Parameters:

• self (Cartesian3DT) –

• ax (Axes) –

• axis_plot (str) –

• component_x (str) –

• component_y (str) –

• component_z (str) –

• kwargs (Any) –

abstract classmethod prototype()

Return type:

typing.Type[typing.TypeVar(AbstractVectorT, bound= AbstractVector)]

ptp(axis=None)

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

reshape(shape)

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• shape (Dict[str, int]) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

scatter(ax, axis_plot, where=None, color=None, colormap=None, **kwargs)

Return type:

typing.Tuple[typing.List[matplotlib.collections.PathCollection], typing.Optional[matplotlib.cm.ScalarMappable]]

Parameters:

• self (AbstractCartesian2DT) –

• ax (Axes) –

• axis_plot (str) –

• where (int | float | ndarray | Quantity | AbstractArray | AbstractArray | None) –

• color (int | float | ndarray | Quantity | AbstractArray | None) –

• colormap (ScalarMappable | None) –

• kwargs (Any) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

classmethod stratified_random_space(start, stop, num, axis, endpoint=True, shape_extra=None)

Return type:

typing.TypeVar(AbstractVectorT, bound= AbstractVector)

Parameters:

• start (AbstractVectorT) –

• stop (AbstractVectorT) –

• num (AbstractVectorT) –

• axis (AbstractVectorT) –

• endpoint (bool) –

• shape_extra (Dict[str, int] | None) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• axis (str | Sequence[str] | None) –

• where (NDArrayMethodsMixinT) –

abstract to(unit)

Return type:

typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)

Parameters:

• self (ArrayInterfaceT) –

• unit (UnitBase) –

to_3d(z=None)

Return type:

typing.TypeVar(Cartesian3DT, bound= Cartesian3D)

Parameters:

• self (AbstractCartesian2DT) –

• z (int | float | ndarray | Quantity | AbstractArray | AbstractArray | None) –

to_matrix()

Return type:

typing.TypeVar(AbstractMatrixT, bound= AbstractMatrix)

Parameters:

self (AbstractVectorT) –

classmethod x_hat()

Return type:

typing.TypeVar(AbstractCartesian1DT, bound= AbstractCartesian1D)

classmethod y_hat()

Return type:

typing.TypeVar(Cartesian1DT, bound= Cartesian1D)

classmethod z_hat()

Return type:

typing.TypeVar(Cartesian3DT, bound= Cartesian3D)

property array: ndarray

property array_labeled: ArrayInterface

property broadcasted: ArrayInterfaceT

property centers: ArrayInterfaceT

property component_sum: int | float | ndarray | Quantity | AbstractArray | AbstractArray

property components: List[str]

abstract property coordinates: Dict[str, int | float | ndarray | Quantity | AbstractArray | AbstractArray | VectorInterface]

property cylindrical: CylindricalT

property dtype

property indices: Dict[str, ArrayT]

property length: int | float | ndarray | Quantity | AbstractArray | AbstractArray

property ndim: int

property normalized: VectorInterfaceT

property polar: PolarT

property shape: Dict[str, int]

property spherical: SphericalT

property tuple: Tuple[int | float | ndarray | Quantity | AbstractArray | AbstractArray | VectorInterface, ...]

type_coordinates = (<class 'str'>, <class 'bool'>, <class 'int'>, <class 'float'>, <class 'complex'>, <class 'numpy.generic'>, <class 'numpy.ndarray'>, <class 'kgpy.labeled.AbstractArray'>, <class 'kgpy.uncertainty.AbstractArray'>)

property type_matrix: Type[Cartesian3D]

abstract property unit: float | Unit

abstract property x: int | float | ndarray | Quantity | AbstractArray | AbstractArray

property xy: Cartesian2DT

abstract property y: int | float | ndarray | Quantity | AbstractArray | AbstractArray

abstract property z: int | float | ndarray | Quantity | AbstractArray | AbstractArray

property zx: Cartesian2DT