package nuod:linalg
Source

⌘K
Ctrl+K
or
/

    Types

    MatrixNorm ¶
    Source

    MatrixNorm :: enum untyped integer {
	Frobenius, 
	Nuclear, 
	Spectral, 
	Infty, 
	NegInfty, 
	First, 
	NegFirst, 
}
    Related Procedures With Parameters

    SVD_Mode ¶
    Source

    SVD_Mode :: enum untyped integer {
	Full, 
	Reduced, 
	Skip_UV, 
}

    VectorNorm ¶
    Source

    VectorNorm :: enum untyped integer {
	L0, 
	Zero, 
	// manhattan
	L1, 
	Manhattan, 
	Absolute, 
	// euclidean
	L2, 
	Euclidean, 
	// max norm
	Linfty, 
	Chebyshev, 
	Uniform, 
	Max, 
}
    Related Procedures With Parameters

    Constants

    This section is empty.

    Variables

    This section is empty.

    Procedures

    det_matrix ¶
    Source

    det_matrix :: proc(a: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (de: $T, ok: bool) #optional_ok {…}
     

    Compute the determinant of a matrix.

    Inputs:
    a: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    de: the determinant value. ok: an optional boolean for error handling.

    Related Procedure Groups

    det_tensor ¶
    Source

    det_tensor :: proc($Nd := , a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (de: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Compute the determinant of a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: a stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    de: the determinant values. ok: an optional boolean for error handling.

    Related Procedure Groups

    dim_vector_chebyshev_norm ¶
    Source

    dim_vector_chebyshev_norm :: proc($Nd := , mdarray: mdarray.MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (norm_result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the chebyshev norm of an array along a certain axis.

    Inputs:
    Nd: number of dimensions of the array. mdarray: a multidimensional array. axis: the axis dimension along which the norm is computed. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the normed array, reduced in dimensions by one. ok: an optional boolean for error handling.

    dim_vector_euclidean_norm ¶
    Source

    dim_vector_euclidean_norm :: proc($Nd := , mdarray: mdarray.MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (norm_result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the euclidean norm of an array along a certain axis.

    Inputs:
    Nd: number of dimensions of the array. mdarray: a multidimensional array. axis: the axis dimension along which the norm is computed. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the normed array, reduced in dimensions by one. ok: an optional boolean for error handling.

    dim_vector_l0_norm ¶
    Source

    dim_vector_l0_norm :: proc($Nd := , mdarray: mdarray.MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (norm_result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the L0 norm of an array along a certain axis.

    Inputs:
    Nd: number of dimensions of the array. mdarray: a multidimensional array. axis: the axis dimension along which the norm is computed. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the normed array, reduced in dimensions by one. ok: an optional boolean for error handling.

    dim_vector_manhattan_norm ¶
    Source

    dim_vector_manhattan_norm :: proc($Nd := , mdarray: mdarray.MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (norm_result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the manhattan norm of an array along a certain axis.

    Inputs:
    Nd: number of dimensions of the array. mdarray: a multidimensional array. axis: the axis dimension along which the norm is computed. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the normed array, reduced in dimensions by one. ok: an optional boolean for error handling.

    dim_vector_norm ¶
    Source

    dim_vector_norm :: proc(
	$Nd := , 
	mdarray:   mdarray.MdArray($T, $Nd), 
	axis:      untyped integer, 
	norm_type: VectorNorm = .Euclidean, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (norm_result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the norm of an array along a certain axis based on the selected norm type.

    Inputs:
    Nd: number of dimensions of the array. mdarray: a multidimensional array. axis: the axis dimension along which the norm is computed. norm_type: the type of norm to compute. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the normed array, reduced in dimensions by one. ok: an optional boolean for error handling.

    Related Procedure Groups

    eig_f32 ¶
    Source

    eig_f32 :: proc($Nd := , a: mdarray.MdArray($T=f32, $Nd), allocator := context.allocator, location := #caller_location) -> (eig_vals: mdarray.MdArray($T=complex64, $Nd), eig_vecs: mdarray.MdArray($T=complex64, $Nd), ok: bool) {…}
     

    Compute the eigen values and right eigen vectors of an f32 matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: an f32 matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    eig_vals: the eigen values. eig_vecs: the right eigen vectors. ok: an optional boolean for error handling.

    Related Procedure Groups

    eig_f64 ¶
    Source

    eig_f64 :: proc($Nd := , a: mdarray.MdArray($T=f64, $Nd), allocator := context.allocator, location := #caller_location) -> (eig_vals: mdarray.MdArray($T=complex128, $Nd), eig_vecs: mdarray.MdArray($T=complex128, $Nd), ok: bool) {…}
     

    Compute the eigen values and right eigen vectors of an f64 matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: an f64 matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    eig_vals: the eigen values. eig_vecs: the right eigen vectors. ok: an optional boolean for error handling.

    Related Procedure Groups

    eigvals_f32 ¶
    Source

    eigvals_f32 :: proc($Nd := , a: mdarray.MdArray($T=f32, $Nd), allocator := context.allocator, location := #caller_location) -> (eig_vals: mdarray.MdArray($T=complex64, $Nd), ok: bool) {…}
     

    Compute the eigen values of an f32 matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: an f32 matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    eig_vals: the eigen values. ok: an optional boolean for error handling.

    Related Procedure Groups

    eigvals_f64 ¶
    Source

    eigvals_f64 :: proc($Nd := , a: mdarray.MdArray($T=f64, $Nd), allocator := context.allocator, location := #caller_location) -> (eig_vals: mdarray.MdArray($T=complex128, $Nd), ok: bool) {…}
     

    Compute the eigen values of an f64 matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: an f64 matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    eig_vals: the eigen values. ok: an optional boolean for error handling.

    Related Procedure Groups

    first_matrix_norm ¶
    Source

    first_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the first norm of a matrix.

    Inputs:
    mdarray: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    frobenius_matrix_norm ¶
    Source

    frobenius_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the frobenius norm of a matrix.

    Inputs:
    mdarray: a matrix. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    full_svd ¶
    Source

    full_svd :: proc($Nd := , a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (s: mdarray.MdArray($T, $Nd), u: mdarray.MdArray($T, $Nd), vt: mdarray.MdArray($T, $Nd), ok: bool) {…}
     

    Compute the full SVD decomposition of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    s: the singular values of the matrix in vector form. u: the U unitary matrix. vt: the transpose of the V unitary matrix. ok: an optional boolean for error handling.

    full_vector_chebyshev_norm ¶
    Source

    full_vector_chebyshev_norm :: proc(mdarray: mdarray.MdArray($T, $Nd), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the chebyshev norm of vector. Treats multidimensional arrays as one vector.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the array. ok: an optional boolean for error handling.

    full_vector_euclidean_norm ¶
    Source

    full_vector_euclidean_norm :: proc(mdarray: mdarray.MdArray($T, $Nd), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the euclidean norm of vector. Treats multidimensional arrays as one vector.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the array. ok: an optional boolean for error handling.

    full_vector_l0_norm ¶
    Source

    full_vector_l0_norm :: proc(mdarray: mdarray.MdArray($T, $Nd), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the L0 norm of vector. Treats multidimensional arrays as one vector.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the array. ok: an optional boolean for error handling.

    full_vector_manhattan_norm ¶
    Source

    full_vector_manhattan_norm :: proc(mdarray: mdarray.MdArray($T, $Nd), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the manhattan norm of vector. Treats multidimensional arrays as one vector.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the array. ok: an optional boolean for error handling.

    full_vector_norm ¶
    Source

    full_vector_norm :: proc(mdarray: mdarray.MdArray($T, $Nd), norm_type: VectorNorm = .Euclidean, location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Find the norm of vector based on the selected norm type. Treats multidimensional arrays as one vector.

    Inputs:
    mdarray: a multidimensional array. norm_type: the type of norm. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the array. ok: an optional boolean for error handling.

    Related Procedure Groups

    infty_matrix_norm ¶
    Source

    infty_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the infinity norm of a matrix.

    Inputs:
    mdarray: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    inner_product ¶
    Source

    inner_product :: proc(a: mdarray.MdArray($T, $Nd=1), b: mdarray.MdArray($T, $Nd=1), location := #caller_location) -> (result: $T, ok: bool) #optional_ok {…}

    inv ¶
    Source

    inv :: proc(a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (inv_a: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Compute the inverse of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    inv_a: the inverse of a. ok: an optional boolean for error handling.

    kron_vector_product ¶
    Source

    kron_vector_product :: proc(a: mdarray.MdArray($T, $Nd=1), b: mdarray.MdArray($T, $Nd=1), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd=1), ok: bool) #optional_ok {…}

    lstsq ¶
    Source

    lstsq :: proc(a: mdarray.MdArray($T, $Nd=2), b: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (solution: mdarray.MdArray($T, $Nd), residual: mdarray.MdArray($T, $Nd=1), ok: bool) {…}
     

    Compute the solution for over and well determined systems of linear equations in matrix form (Ax = b). It utilizes the QR/QL factorization to minimize the least square error.

    Inputs:
    a: a matrix. b: a vector or a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    solution: the solution for the system of linear equations. residual: the residual values, computed only for over-determined systems. ok: an optional boolean for error handling.

    make_diagonal_stack ¶
    Source

    make_diagonal_stack :: proc($Nd := , mdarray: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Produce a diagonal matrix whose diagonal elements are populated based on the provided stacks of vectors.

    Inputs:
    Nd: number of dimensions of mdarray. mdarray: a stack of one-dimenaional arrays. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant diagonal stack of matrice. ok: an optional boolean for error handling.

    Related Procedure Groups

    make_diagonal_vector ¶
    Source

    make_diagonal_vector :: proc(mdarray: mdarray.MdArray($T, $Nd=1), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd=2), ok: bool) #optional_ok {…}
     

    Produce a diagonal matrix whose diagonal elements are populated based on a one-dimensional array.

    Inputs:
    mdarray: a one-dimenaional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant diagonal matrix. ok: an optional boolean for error handling.

    Related Procedure Groups

    matmul ¶
    Source

    matmul :: proc(a: mdarray.MdArray($T, $Nd), b: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}

    matrix_diagonal ¶
    Source

    matrix_diagonal :: proc(mdarray: mdarray.MdArray($T, $Nd=2), offset: untyped integer = 0, allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd=1), ok: bool) #optional_ok {…}
     

    Extract the diagonal elements of a matrix.

    Inputs:
    mdarray: a matrix of two dimensions. offset: the offset from the main diagonal (may be negative). allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: a vector containing a copy of the diagonal elements. ok: an optional boolean for error handling.

    matrix_norm ¶
    Source

    matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), norm_type: MatrixNorm = MatrixNorm.Frobenius, allocator := context.allocator, location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the norm of a matrix based on the selected matrix norm.

    Inputs:
    mdarray: a matrix. norm_type: the type of norm. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    matrix_trace ¶
    Source

    matrix_trace :: proc(mdarray: mdarray.MdArray($T, $Nd=2), offset: untyped integer = 0, location := #caller_location) -> (result: $T, ok: bool) #optional_ok {…}
     

    Extract the trace of a matrix.

    Inputs:
    mdarray: a matrix of two dimensions. offset: the offset from the main diagonal (may be negative). location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the trace value. ok: an optional boolean for error handling.

    matvec ¶
    Source

    matvec :: proc(a: mdarray.MdArray($T, $Nd), v: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}

    neg_first_matrix_norm ¶
    Source

    neg_first_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the negative first norm of a matrix.

    Inputs:
    mdarray: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    neg_infty_matrix_norm ¶
    Source

    neg_infty_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the negative infinity norm of a matrix.

    Inputs:
    mdarray: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    nuclear_matrix_norm ¶
    Source

    nuclear_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the nuclear norm of a matrix.

    WARNING: This is not implemented yet.

    Inputs:
    mdarray: a matrix. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    outer_product ¶
    Source

    outer_product :: proc(a: mdarray.MdArray($T, $Nd=1), b: mdarray.MdArray($T, $Nd=1), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd=2), ok: bool) #optional_ok {…}

    pinv ¶
    Source

    pinv :: proc(a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (pinv_a: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Compute the Moore–Penrose inverse of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    pinv_a: the Moore–Penrose inverse of a. ok: an optional boolean for error handling.

    qr ¶
    Source

    qr :: proc(a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (q: mdarray.MdArray($T, $Nd), r: mdarray.MdArray($T, $Nd), ok: bool) {…}
     

    Compute the QR decomposition of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    q: the Q orthogonal matrix. r: the R right upper triangular matrix. ok: an optional boolean for error handling.

    reduced_svd ¶
    Source

    reduced_svd :: proc($Nd := , a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (s: mdarray.MdArray($T, $Nd), u: mdarray.MdArray($T, $Nd), vt: mdarray.MdArray($T, $Nd), ok: bool) {…}
     

    Compute the reduced form of the SVD decomposition of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    s: the singular values of the matrix in vector form. u: the U unitary matrix. vt: the transpose of the V unitary matrix. ok: an optional boolean for error handling.

    slog_det_matrix ¶
    Source

    slog_det_matrix :: proc(a: mdarray.MdArray($T, $Nd=2), allocator := context.allocator, location := #caller_location) -> (sign: untyped integer, slog_de: $T, ok: bool) {…}
     

    Compute the sign and log determinant of a matrix.

    Inputs:
    a: a matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    sign: the sign of the determinant. slog_de: the log of the absolute determinant. ok: an optional boolean for error handling.

    slog_det_tensor ¶
    Source

    slog_det_tensor :: proc($Nd := , a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (sign: mdarray.MdArray($T=int, $Nd), slog_de: mdarray.MdArray($T, $Nd), ok: bool) {…}
     

    Compute the sign and log determinant of a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: a stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    sign: the sign of the determinants. slog_de: the log of the absolute determinants. ok: an optional boolean for error handling.

    solve ¶
    Source

    solve :: proc(a: mdarray.MdArray($T, $Nd), b: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (solution: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Compute the solution of system of linear equations in matrix form (Ax = b). A may be a square matrix or a stack of square matrices. b maybe a vector, multiple vectors, a stack of vectors, or a stack of multiple vectors.

    Inputs:
    a: a matrix or stack of matrices. b: a vector, multiple vectors, stack of vectors, or stack of multiple vectors. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    solution: the solution for the system of linear equations. ok: an optional boolean for error handling.

    spectral_matrix_norm ¶
    Source

    spectral_matrix_norm :: proc(mdarray: mdarray.MdArray($T, $Nd=2), location := #caller_location) -> (norm_result: $T, ok: bool) #optional_ok {…}
     

    Find the spectral norm of a matrix.

    WARNING: This is not implemented yet.

    Inputs:
    mdarray: a matrix. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the norm of the matrix. ok: an optional boolean for error handling.

    svd_vals ¶
    Source

    svd_vals :: proc($Nd := , a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (s: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Compute the singular values of the SVD decomposition of a matrix or a stack of matrices. A stack of any form may be passed.

    Inputs:
    Nd: the number of dimensions of the passed matrix. a: a matrix or stack of matrices. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    s: the singular values of the matrix in vector form. ok: an optional boolean for error handling.

    vecmat ¶
    Source

    vecmat :: proc(v: mdarray.MdArray($T, $Nd), a: mdarray.MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: mdarray.MdArray($T, $Nd), ok: bool) #optional_ok {…}

    Procedure Groups

    det ¶
    Source

    det :: proc{
	det_matrix,
	det_tensor,
}

    eig ¶
    Source

    eig :: proc{
	eig_f32,
	eig_f64,
}

    eigvals ¶
    Source

    eigvals :: proc{
	eigvals_f32,
	eigvals_f64,
}

    make_diagonal ¶
    Source

    make_diagonal :: proc{
	make_diagonal_vector,
	make_diagonal_stack,
}

    slog_det ¶
    Source

    slog_det :: proc{
	det_matrix,
	det_tensor,
}

    vector_norm ¶
    Source

    vector_norm :: proc{
	full_vector_norm,
	dim_vector_norm,
}

    Source Files

    Generation Information

    Generated with odin version dev-2025-11 (vendor "odin") Linux_amd64 @ 2025-11-15 02:28:15.931228212 +0000 UTC