Module: array

Array-specific nodes.

These nodes operate on raw arrays, and are only needed in special circumstances, for instance when building data structures from scratch or to implement mathematical algorithms from scratch. Arrays occur as array fields in Axis objects, (e.g., time.times, frequency.frequencies, etc), and as the data field in Block objects. The nodes in this module are not needed for most data analysis tasks. The nodes in this category should cover most linear algebra needs.

ArrayNonzeros

Get the indices or optionally n-dimensional index coordinates of the non-zero entries in an array.

By default, this returns a single vector of indices in the flattened array as the first (coord0) output. If flat is disabled, and if the array is n-dimensional (i.e. is a tensor), then for each non-zero entry in the tensor, its n index coordinates are appended to the n coordN output arrays. Thus each coord array is a vector with the same number of elements, which is the total number of non-zeros. Any coordN arrays for N > than the array dimension are None. The nonzeros are generally emitted (scanned out) in row-major a.k.a. C memory order (both in flat and non-flat mode). This only makes a difference if the array is multi-dimensional. In this case, the C / row-major order order means that array elements are scanned in such a way that the last dimension is the fastest varying (i.e., adjacent entries along the last dimension are adjacent in the scan order and a whole row of the last dimension is scanned before the next row is scanned). Thus the next set of entries in the scan order corresponds to the next index in the second-to-last dimension.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Array to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • coord1
    Coordinate 1 of non-zero entries.

    • verbose name: Coord1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord2
    Coordinate 2 of non-zero entries.

    • verbose name: Coord2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord3
    Coordinate 3 of non-zero entries.

    • verbose name: Coord3
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord4
    Coordinate 4 of non-zero entries.

    • verbose name: Coord4
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord5
    Coordinate 5 of non-zero entries.

    • verbose name: Coord5
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord6
    Coordinate 6 of non-zero entries.

    • verbose name: Coord6
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord7
    Coordinate 7 of non-zero entries.

    • verbose name: Coord7
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord8
    Coordinate 8 of non-zero entries.

    • verbose name: Coord8
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • coord9
    Coordinate 9 of non-zero entries.

    • verbose name: Coord9
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • flat
    If set, coord0 holds the indices of the non-zero entries in the flattened array. If False, for each non-zero in the original n-dimensional array, its n coordinate indices are emitted into the corresponding coordN ports.

    • verbose name: Flat
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)
  • coord0
    Coordinate 0 of non-zero entries - UNUSED.

    • verbose name: Coord0
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

ArrayReshape

Change the shape of an array without changing the number of elements.

This is equivalent to first flattening the array and then arranging the elements in the desired new shape. The node can also be applied to transform between lists of lists with regular structure.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Array to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • shape
    Desired shape of the array. One of the dimensions may be set to -1, in which case it will be inferred from the other dimensions and the total number of elements.

    • verbose name: Shape
    • default value: [-1]
    • port type: ListPort
    • value type: list (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

DiagonalMatrix

Create a diagonal matrix from a vector, or stack of vectors.

The last dimension is the vector dimension and becomes the two identical matrix dimensions in the output.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • diags
    Diagonal vector (stack).

    • verbose name: Diags
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

GeometricProgression

Create an array that contains a sequence of numbers that follow a geometric progression, i.e

., are evenly spaced on a log scale between a start and end value. This corresponds to the logspace function in Python and MATLAB(tm) if endpoints are specified as exponents, and otherwise to the geomspace function. One may optionally specify a template array to determine the num value if desired; in this case the shape of the created array will conform to that of the template array, which must be a vector. The node supports alternative compute backends, which can be used to speed up processing.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • start
    Start of the range.

    • verbose name: Start
    • default value: 0
    • port type: FloatPort
    • value type: float (can be None)
  • stop
    End of the range, must be provided.

    • verbose name: Stop
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)
  • endpoints_are
    Whether the endpoints are specified as exponents to the given base (exponents mode), or as the actual start-stop values (simple mode).

    • verbose name: Endpoints Are
    • default value: simple
    • port type: EnumPort
    • value type: str (can be None)
  • num
    Number of steps to use. If an array or list has been wired into the 'like' input of the node, then this value may be omitted and will then match the size of that array.

    • verbose name: Number Of Steps
    • default value: None
    • port type: IntPort
    • value type: int (can be None)
  • inclusive
    Whether the stop value is inclusive or exclusive.

    • verbose name: Inclusive
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)
  • base
    Base of the exponential progression. When using simple mode, this is inferred from the endpoints and the number of steps. Alternatively, when using exponents mode, a default of 10 is assumed, and the provided endpoints will be exponentiated with this base (i.e., the sequence runs from 10start to 10stop). In either case the resulting sequence of numbers will be spaced evenly when transformed to a log scale (i.e., when taking their logarithm).

    • verbose name: Base
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

IdentityMatrix

Create a two-dimensional array that is an identity matrix, optionally with a shifted diagonal.

The node supports alternative compute backends, which can be used to speed up processing.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • rows
    Number of rows.

    • verbose name: Rows
    • default value: None
    • port type: IntPort
    • value type: int
  • columns
    Optionally the number of columns, if different from rows.

    • verbose name: Columns
    • default value: None
    • port type: IntPort
    • value type: int (can be None)
  • offset
    Optional offset of the diagonal from the main diagonal. A positive value places the diagonal above the main diagonal, and a negative value places it below the main diagonal.

    • verbose name: Offset
    • default value: 0
    • port type: IntPort
    • value type: int (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

IntegerProgression

Create a raw array that contains an arithmetic progression of numbers with integer step size.

This gives the same numbers as the RangeIterator node (corresponds to the "arange" function for Python arrays). One may optionally specify a template array to determine the stop value if desired; in this case the shape of the created array will conform to that of the template array, which must be a vector. The node supports alternative compute backends, which can be used to speed up processing.

Version 1.1.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • start
    Start value of the range.

    • verbose name: Start
    • default value: 0
    • port type: IntPort
    • value type: int (can be None)
  • stop
    End value of the range, must be provided. Not included in the range unless the inclusive option is set to True. If an array or list has been wired into the 'like' input of the node, then the stop value may be omitted and will be inferred from the length of that array.

    • verbose name: Stop
    • default value: None
    • port type: IntPort
    • value type: int (can be None)
  • step
    Step size of the range.

    • verbose name: Step
    • default value: 1
    • port type: IntPort
    • value type: int (can be None)
  • inclusive
    Whether the stop value is inclusive or exclusive. If the start and step values are chosen such that the range cannot include the stop value (i.e., will miss it), then an error is raised if this is enabled.

    • verbose name: Inclusive
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

LinearProgression

Create a raw array that contains an arithmetic progression of numbers with real-valued step size and starts/ends.

This corresponds to the linspace function in Python and MATLAB(tm). One may optionally specify a template array to determine the num value if desired; in this case the shape of the created array will conform to that of the template array, which must be a vector. The node supports alternative compute backends, which can be used to speed up processing.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • start
    Start value of the range.

    • verbose name: Start
    • default value: 0
    • port type: FloatPort
    • value type: float (can be None)
  • stop
    End value of the range, must be provided. In contrast to CreateIntegerRange, this is included in the range unless the inclusive option is set to False.

    • verbose name: Stop
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)
  • num
    Number of steps to use. If an array or list has been wired into the 'like' input of the node, then this value may be omitted and will then match the size of that array.

    • verbose name: Number Of Steps
    • default value: None
    • port type: IntPort
    • value type: int (can be None)
  • inclusive
    Whether the stop value is included in the range or excluded.

    • verbose name: Inclusive
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixBlockDiagonal

Create a block-diagonal matrix from a collection of input matrices.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • data1
    Input matrix 1.

    • verbose name: Data1
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data2
    Input matrix 2.

    • verbose name: Data2
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data3
    Input matrix 3.

    • verbose name: Data3
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data4
    Input matrix 4.

    • verbose name: Data4
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data5
    Input matrix 5.

    • verbose name: Data5
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data6
    Input matrix 6.

    • verbose name: Data6
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data7
    Input matrix 7.

    • verbose name: Data7
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data8
    Input matrix 8.

    • verbose name: Data8
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data9
    Input matrix 9.

    • verbose name: Data9
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • data10
    Input matrix 10.

    • verbose name: Data10
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: IN
  • dataN
    Additional input matrices.

    • verbose name: Datan
    • default value: None
    • port type: DataPort
    • value type: list (can be None)
    • data direction: IN
  • outdata
    Result.

    • verbose name: Outdata
    • default value: None
    • port type: DataPort
    • value type: AnyNumeric (can be None)
    • data direction: OUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixCholesky

Calculate the lower Cholesky decomposition of a complex Hermitian or real symmetrix positive- definite matrix, or a stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixDeterminant

Calculate the determinant of the given square matrix, or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • sign
    Sign of the determinant.

    • verbose name: Sign
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • mode
    Mode for the determinant calculation. 'det' returns the determinant itself, and 'slogdet' returns the sign and the logarithm of the determinant, which is numerically more robust.

    • verbose name: Mode
    • default value: det
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixDiagonal

Obtain the diagonal vector of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • offset
    Offset relative to main diagonal. If positive, then a diagonal above the main diagonal is used, and if negative, a diagonal below the main diagonal is used.

    • verbose name: Off-Diagonal Offset
    • default value: 0
    • port type: IntPort
    • value type: int (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixEigh

Calculate an eigenvalue decomposition of a complex Hermitian or real symmetric positive-definite matrix or stack thereof (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • D
    Vector (stack) of eigenvalues.

    • verbose name: D
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • V
    Matrix (stack) of eigenvectors.

    • verbose name: V
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • only_eigvals
    If True, only the eigenvalues are returned. If False, both eigenvalues and eigenvectors are returned.

    • verbose name: Only Eigenvalues
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixExponential

Calculate the exponential of a matrix or stack thereof (where the last two dimensions are the matrix dimensions).

Note that this is not the elementwise exponential.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • upper_triangular
    If True, the input matrix is assumed to be upper triangular, which can speed up the computation.

    • verbose name: Upper Triangular
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • max_squarings
    Maximum number of squarings to use in the scaling and squaring method. If the actual number of squarings is larger, NaN is returned. Not used by all backends.

    • verbose name: Squaring Limit
    • default value: 16
    • port type: IntPort
    • value type: int (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixHessenberg

Calculate the Hessenberg form of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • H
    Matrix (stack) in Hessenberg form.

    • verbose name: H
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • Q
    Optionally the unitary/orthogonal similarity transform matrix (stack).

    • verbose name: Q
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • calc_q
    If True, the Q matrix is also computed.

    • verbose name: Output Q Matrix
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixInverse

Calculate the multiplicative inverse of the given matrix, or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixKron

Take the Kronecker product of two matrices or stacks of matrices (where the last two dimensions are the matrix dimensions).

This operation tiles the second matrix across the cells of the first, and then scales each tile by the corresponding element of the first matrix.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array1
    Matrix (stack) 1 to process.

    • verbose name: Array1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • array2
    Matrix (stack) 2 to process.

    • verbose name: Array2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • result
    Resulting matrix (stack).

    • verbose name: Result
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixLU

Calculate the LU decomposition of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • P
    Optional permutation matrix/vector (stack).

    • verbose name: P
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • L
    Lower triangular matrix (stack).

    • verbose name: L
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • U
    Upper triangular matrix (stack).

    • verbose name: U
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • permute_l
    If True, permute the rows of L to match the permutation matrix P. In that case, P is not returned.

    • verbose name: Output Permuted L Matrix
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • p_indices
    If True, return the indices of the permutation matrix P, rather than the matrix itself. This argument is only available in NeuroPype 2024 or later.

    • verbose name: Output P As Indices
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixLeastSquares

Compute the least-squares solution to a linear matrix equation A * X = B or stacks thereof (where the last two dimensions are the matrix dimensions).

For the second operand, the final dimension may also be omitted and is then assumed to be 1.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array1
    Matrix (stack) A to process.

    • verbose name: Array1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • array2
    Matrix (stack) B to process.

    • verbose name: Array2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • result
    Resulting matrix (stack) X.

    • verbose name: Result
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • reltol
    Relative tolerance for small singular values. This corresponds to the rcond parameter in numpy.linalg.lstsq.

    • verbose name: Relative Tolerance
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixMultiply

Multiply two matrices or stacks of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array1
    Matrix (stack) 1 to process.

    • verbose name: Array1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • array2
    Matrix (stack) 2 to process.

    • verbose name: Array2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • result
    Resulting matrix (stack).

    • verbose name: Result
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixPinv

Calculate the Moore-Penrose pseudo-inverse of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • reltol
    Relative tolerance for small singular values.

    • verbose name: Relative Tolerance
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixQR

Calculate the QR decompoisition of a matrix or stack thereof (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • Q
    The orthogonal matrix (stack).

    • verbose name: Q
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • R
    The upper triangular matrix (stack).

    • verbose name: R
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • mode
    Whether to calculate a reduced or complete QR decomposition.

    • verbose name: Mode
    • default value: reduced
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixRank

Calculate the rank of a given matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

Note that, for badly conditioned matrices, the result may depend on the precision of the calculation.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixSVD

Calculate the singular value decomposition (SVD) of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • U
    Matrix (stack) of left singular vectors.

    • verbose name: U
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • S
    Vector (stack) of singular values.

    • verbose name: S
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • V
    Matrix (stack) of right singular vectors.

    • verbose name: V
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • full_matrices
    Calculate full-sized matrices U and V, rather than truncated versions.

    • verbose name: Full Matrices
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)
  • compute_uv
    If True, compute U and V. If False, only compute S. The U and V outputs will be set to None.

    • verbose name: Compute U And V
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixSchur

Calculate the Schur decomposition of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • T
    Matrix (stack) in Schur form.

    • verbose name: T
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • Z
    Unitary Schur transform matrix (stack).

    • verbose name: Z
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • output
    Whether to compute the real or complex-valued Schur decomposition (for real matrices).

    • verbose name: Output
    • default value: real
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixSolve

Solve a linear matrix equation A * X = B or system of linear equations, or stacks thereof (where the last two dimensions are the matrix dimensions).

For the second operand, the final dimension may also be omitted and is then assumed to be 1.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array1
    Matrix (stack) A to process.

    • verbose name: Array1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • array2
    Matrix (stack) B to process.

    • verbose name: Array2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • result
    Resulting matrix (stack) X.

    • verbose name: Result
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixSquareRoot

Calculate the square root of a matrix or stack thereof (where the last two dimensions are the matrix dimensions).

Note that this is not the elementwise square root.

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • blocksize
    Block size for the recursive blocking method. Not used by all backends.

    • verbose name: Blocksize
    • default value: None
    • port type: IntPort
    • value type: int (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixTrace

Calculate the trace (sum of diagonal elements) of a matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • offset
    Offset relative to main diagonal. If positive, then a diagonal above the main diagonal is used, and if negative, a diagonal below the main diagonal is used.

    • verbose name: Off-Diagonal Offset
    • default value: 0
    • port type: IntPort
    • value type: int (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MatrixTranspose

Transpose the given matrix or stack of matrices (where the last two dimensions are the matrix dimensions).

More Info...

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • array
    Matrix (stack) to process.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: INOUT
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

OneFilledArray

Create a raw numeric array filled with ones, optionally matching a template array in shape and optionally data type.

The node supports alternative compute backends, which can be used to speed up processing.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • shape
    Shape of the array. Can be omitted if a template array is provided.

    • verbose name: Shape
    • default value: []
    • port type: ListPort
    • value type: list (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

ZeroFilledArray

Create a raw numeric array filled with zeros, optionally matching a template array in shape and optionally data type.

The node supports alternative compute backends, which can be used to speed up processing.

Version 1.0.0

Ports/Properties

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)
  • array
    Output array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: OUT
  • like
    Optional template array.

    • verbose name: Like
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN
  • shape
    Shape of the array. Can be omitted if a template array is provided.

    • verbose name: Shape
    • default value: []
    • port type: ListPort
    • value type: list (can be None)
  • backend
    Optional compute backend to use. Keep is the current default, which resolves to that of the template array if one is provided and otherwise numpy unless overridden. Numpy is the standard CPU backend that underpins most of NeuroPype's operations. The others require one or more GPUs to be present on the system, except for torch-cpu. For best performance, keep all arrays that interact with each other (via processing nodes) on the same backend.

    • verbose name: Backend
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • precision
    Numeric precision to use. Keep resolves to the precision of the template array if one is provided, and otherwise to the current default (usually 64-bit). Can be reduced to save memory (e.g. if running on GPU).

    • verbose name: Precision
    • default value: keep
    • port type: EnumPort
    • value type: str (can be None)
  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)