NormalRandomSpace

class kgpy.labeled.NormalRandomSpace(center=0, width=0, num=None, endpoint=True, axis=None, seed=None)

Bases: _RandomSpaceMixin, _SymmetricMixin[CenterT, WidthT]

Parameters:

• center (CenterT) –

• width (WidthT) –

• num (int) –

• endpoint (bool) –

• axis (str) –

• seed (int | None) –

__init__(center=0, width=0, num=None, endpoint=True, axis=None, seed=None)

Parameters:

• center (CenterT) –

• width (WidthT) –

• num (int | None) –

• endpoint (bool) –

• axis (str | None) –

• seed (int | None) –

Return type:

None

Attributes

array
array_labeled
axes
axis
broadcasted
center
centers
dtype
endpoint
indices
length
ndim
normalized
num
seed
shape
type_array
type_array_auxiliary
unit
width

Methods

__init__([center, width, num, endpoint, ...])
add_axes(axes)	rtype: typing.TypeVar(AbstractArrayT, bound= AbstractArray)
aligned(shape)	rtype: typing.TypeVar(ArrayT, bound= Array)
all([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
any([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
array_aligned(shape)	rtype: typing.TypeVar(ArrT, bound= typing.Union[int, float, numpy.ndarray, astropy.units.quantity.Quantity])
astype(dtype[, order, casting, subok, copy])	rtype: typing.TypeVar(ArrayT, bound= Array)
broadcast_shapes(*arrs)	rtype: typing.Dict[str, int]
broadcast_to(shape)	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
change_axis_index(axis, index)
colorize_axis(axis[, percentile_max, ...])	rtype: kgpy.labeled.Array
combine_axes(axes[, axis_new])	rtype: kgpy.labeled.Array
copy()	rtype: typing.TypeVar(CopyableT, bound= Copyable)
copy_shallow()	rtype: typing.TypeVar(CopyableT, bound= Copyable)
filter_mean(shape_kernel)
filter_mean_trimmed(shape_kernel[, proportion])
filter_median(shape_kernel[, mode])
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_nearest_secant(value[, axis])	rtype: typing.Dict[str, typing.TypeVar(AbstractArrayT, bound= AbstractArray)]
index_secant(value[, axis, damping])	rtype: typing.Dict[str, typing.TypeVar(ArrayT, bound= Array)]
interp_linear(item)	rtype: typing.TypeVar(ArrayInterfaceT, bound= ArrayInterface)
matrix_determinant(axis_rows, axis_columns)	rtype: kgpy.labeled.Array
matrix_inverse(axis_rows, axis_columns)	rtype: kgpy.labeled.Array
matrix_multiply(other, axis_rows, axis_columns)	rtype: kgpy.labeled.Array
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]]
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)
shape_broadcasted(*arrs)	rtype: typing.Dict[str, int]
std([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
sum([axis, where])	rtype: typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)
to(unit)	rtype: typing.TypeVar(ArrayT, bound= Array)

Inheritance Diagram

digraph inheritance5f78a1a68a { bgcolor=transparent; rankdir=TB; size="8.0, 12.0"; "kgpy.labeled.NormalRandomSpace" [URL="kgpy.labeled.NormalRandomSpace.html#kgpy.labeled.NormalRandomSpace",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="NormalRandomSpace(center: 'CenterT' = 0, width: 'WidthT' = 0, num: 'int' = None, endpoint: 'bool' = True, axis: 'str' = None, seed: 'typ.Optional[int]' = None)"]; }

type_array_primary

alias of ndarray

add_axes(axes)

Return type:

typing.TypeVar(AbstractArrayT, bound= AbstractArray)

Parameters:

• self (AbstractArrayT) –

• axes (List) –

aligned(shape)

Return type:

typing.TypeVar(ArrayT, bound= Array)

Parameters:

• self (AbstractArrayT) –

• 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) –

array_aligned(shape)

Return type:

typing.TypeVar(ArrT, bound= typing.Union[int, float, numpy.ndarray, astropy.units.quantity.Quantity])

Parameters:

• self (AbstractArrayT) –

• shape (Dict[str, int]) –

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

Return type:

typing.TypeVar(ArrayT, bound= Array)

Parameters:

• self (ArrayInterfaceT) –

• 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) –

classmethod broadcast_shapes(*arrs)

Return type:

typing.Dict[str, int]

Parameters:

arrs (AbstractArrayT) –

broadcast_to(shape)

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

• shape (Dict[str, int]) –

change_axis_index(axis, index)

Parameters:

• axis (str) –

• index (int) –

colorize_axis(axis, percentile_max=<Quantity 99. %>, percentile_min=<Quantity 1. %>)

Return type:

kgpy.labeled.Array

Parameters:

• self (AbstractArray) –

• axis (str) –

• percentile_max (Quantity) –

• percentile_min (Quantity) –

combine_axes(axes, axis_new=None)

Return type:

kgpy.labeled.Array

Parameters:

• self (AbstractArrayT) –

• 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) –

filter_mean(shape_kernel)

Parameters:

• self (AbstractArrayT) –

• shape_kernel (dict[str, int]) –

filter_mean_trimmed(shape_kernel, proportion=0.25)

Parameters:

• self (AbstractArrayT) –

• shape_kernel (dict[str, int]) –

• proportion (float) –

filter_median(shape_kernel, mode='reflect')

Parameters:

• self (AbstractArrayT) –

• shape_kernel (Dict[str, int]) –

• mode (str) –

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_nearest_secant(value, axis=None)

Return type:

typing.Dict[str, typing.TypeVar(AbstractArrayT, bound= AbstractArray)]

Parameters:

• self (AbstractArrayT) –

• value (AbstractArrayT) –

• axis (str | Sequence[str] | 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]) –

matrix_determinant(axis_rows, axis_columns)

Return type:

kgpy.labeled.Array

Parameters:

• self (AbstractArrayT) –

• axis_rows (str) –

• axis_columns (str) –

matrix_inverse(axis_rows, axis_columns)

Return type:

kgpy.labeled.Array

Parameters:

• self (AbstractArrayT) –

• axis_rows (str) –

• axis_columns (str) –

matrix_multiply(other, axis_rows, axis_columns)

Return type:

kgpy.labeled.Array

Parameters:

• self (AbstractArrayT) –

• other (OtherAbstractArrayT) –

• axis_rows (str) –

• axis_columns (str) –

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) –

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) –

shape_broadcasted(*arrs)

Return type:

typing.Dict[str, int]

Parameters:

• self (AbstractArrayT) –

• arrs (AbstractArrayT) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

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

• where (NDArrayMethodsMixinT) –

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

Return type:

typing.TypeVar(NDArrayMethodsMixinT, bound= NDArrayMethodsMixin)

Parameters:

• self (NDArrayMethodsMixinT) –

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

• where (NDArrayMethodsMixinT) –

to(unit)

Return type:

typing.TypeVar(ArrayT, bound= Array)

Parameters:

• self (AbstractArrayT) –

• unit (Unit) –

property array: int | float | ndarray | Quantity

property array_labeled: AbstractArrayT

property axes: List[str]

axis: str = None

property broadcasted: ArrayInterfaceT

center: typing.TypeVar(CenterT, bound= ArrayLike) = 0

property centers: ArrayInterfaceT

property dtype

endpoint: bool = True

property indices: Dict[str, ArrayT]

property length: AbstractArrayT

property ndim: int

property normalized: _SymmetricMixinT

num: int = None

seed: typing.Optional[int] = None

property shape: Dict[str, int]

type_array: typing.ClassVar[typing.Tuple[typing.Type, ...]] = (<class 'str'>, <class 'bool'>, <class 'int'>, <class 'float'>, <class 'complex'>, <class 'numpy.generic'>, <class 'numpy.ndarray'>)

type_array_auxiliary: typing.ClassVar[typing.Tuple[typing.Type, ...]] = (<class 'str'>, <class 'bool'>, <class 'int'>, <class 'float'>, <class 'complex'>, <class 'numpy.generic'>)

property unit: Unit | None

width: typing.TypeVar(WidthT, bound= ArrayLike) = 0