Linear Algebra Extension ¶
Array API specification for linear algebra functions.
A conforming implementation of the array API standard must provide and support the following functions adhering to the following conventions.

Positional parameters must be positionalonly parameters. Positionalonly parameters have no externallyusable name. When a function accepting positionalonly parameters is called, positional arguments are mapped to these parameters based solely on their order.

Optional parameters must be keywordonly arguments.

Broadcasting semantics must follow the semantics defined in Broadcasting .

Unless stated otherwise, functions must support the data types defined in Data Types .

Unless stated otherwise, functions must adhere to the type promotion rules defined in Type Promotion Rules .

Unless stated otherwise, floatingpoint operations must adhere to IEEE 7542019.
Design Principles ¶
A principal goal of this specification is to standardize commonly implemented interfaces among array libraries. While this specification endeavors to avoid straying too far from common practice, this specification does, with due restraint, seek to address design decisions arising more from historical accident than first principles. This is especially true for linear algebra APIs, which have arisen and evolved organically over time and have often been tied to particular underlying implementations (e.g., to BLAS and LAPACK).
Accordingly, the standardization process affords the opportunity to reduce interface complexity among linear algebra APIs by inferring and subsequently codifying common design themes, thus allowing more consistent APIs. What follows is the set of design principles governing the APIs which follow:

Batching : if an operation is explicitly defined in terms of matrices (i.e., twodimensional arrays), then the associated interface should support “batching” (i.e., the ability to perform the operation over a “stack” of matrices). Example operations include:

inv
: computing the multiplicative inverse of a square matrix. 
cholesky
: performing Cholesky decomposition. 
matmul
: performing matrix multiplication.


Data types : if an operation requires decimal operations and Type Promotion Rules semantics are undefined (e.g., as is the case for mixedkind promotions), then the associated interface should be specified as being restricted to floatingpoint data types. While the specification uses the term “SHOULD” rather than “MUST”, a conforming implementation of the array API standard should only ignore the restriction provided overly compelling reasons for doing so. Example operations which should be limited to floatingpoint data types include:

inv
: computing the multiplicative inverse. 
slogdet
: computing the natural logarithm of the absolute value of the determinant. 
norm
: computing the matrix or vector norm.
Certain operations are solely comprised of multiplications and additions. Accordingly, associated interfaces need not be restricted to floatingpoint data types. However, careful consideration should be given to overflow, and use of floatingpoint data types may be more prudent in practice. Example operations include:

matmul
: performing matrix multiplication. 
trace
: computing the sum along the diagonal. 
cross
: computing the vector cross product.
Lastly, certain operations may be performed independent of data type, and, thus, the associated interfaces should support all data types specified in this standard. Example operations include:

matrix_transpose
: computing the transpose. 
diagonal
: returning the diagonal.


Return values : if an interface has more than one return value, the interface should return a namedtuple consisting of each value.
In general, interfaces should avoid polymorphic return values (e.g., returning an array or a namedtuple, dependent on, e.g., an optional keyword argument). Dedicated interfaces for each return value type are preferred, as dedicated interfaces are easier to reason about at both the implementation level and user level. Example interfaces which could be combined into a single overloaded interface, but are not, include:

eig
: computing both eigenvalues and eignvectors. 
eigvals
: computing only eigenvalues.


Implementation agnosticism : a standardized interface should eschew parameterization (including keyword arguments) biased toward particular implementations.
Historically, at a time when all array computing happened on CPUs, BLAS and LAPACK underpinned most numerical computing libraries and environments. Naturally, language and library abstractions catered to the parameterization of those libraries, often exposing lowlevel implementation details verbatim in their higherlevel interfaces, even if such choices would be considered poor or illadvised by today’s standards (e.g., NumPy’s use of
UPLO
ineigh
). However, the present day is considerably different. While still important, BLAS and LAPACK no longer hold a monopoly over linear algebra operations, especially given the proliferation of devices and hardware on which such operations must be performed. Accordingly, interfaces must be conservative in the parameterization they support in order to best ensure universality. Such conservatism applies even to performance optimization parameters afforded by certain hardware. 
Orthogonality : an interface should have clearly defined and delineated functionality which, ideally, has no overlap with the functionality of other interfaces in the specification. Providing multiple interfaces which can all perform the same operation creates unnecessary confusion regarding interface applicability (i.e., which interface is best at which time) and decreases readability of both library and user code. Where overlap is possible, the specification must be parsimonious in the number of interfaces, ensuring that each interface provides a unique and compelling abstraction. Examples of related interfaces which provide distinct levels of abstraction (and generality) include:

vecdot
: computing the dot product of two vectors. 
matmul
: performing matrix multiplication (including between two vectors and thus the dot product). 
tensordot
: computing tensor contractions (generalized sumproducts). 
einsum
: expressing operations in terms of Einstein summation convention, including dot products and tensor contractions.
The above can be contrasted with, e.g., NumPy, which provides the following interfaces for computing the dot product or related operations:

dot
: dot product, matrix multiplication, and tensor contraction. 
inner
: dot product. 
vdot
: dot product with flattening and complex conjugation. 
multi_dot
: chained dot product. 
tensordot
: tensor contraction. 
matmul
: matrix multiplication (dot product for two vectors). 
einsum
: Einstein summation convention.
where
dot
is overloaded based on input array dimensionality andvdot
andinner
exhibit a high degree of overlap with other interfaces. By consolidating interfaces and more clearly delineating behavior, this specification aims to ensure that each interface has a unique purpose and defined use case. 
Objects in API ¶
linalg.cholesky(x, /, *, upper=False) ¶
Returns the lower (upper) Cholesky decomposition x = LLᵀ (x = UᵀU) of a symmetric positivedefinite matrix (or a stack of matrices)
x
, where
L
is a lowertriangular matrix or a stack of matrices (
U
is an uppertriangular matrix or a stack of matrices).
Note
Whether an array library explicitly checks whether an input array is a symmetric positivedefinite matrix (or a stack of matrices) is implementationdefined.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square symmetric positivedefinite matrices. Should have a floatingpoint data type.


upper : bool

If
True
, the result must be the uppertriangular Cholesky factorU
. IfFalse
, the result must be the lowertriangular Cholesky factorL
. Default:False
.

Returns ¶

out : <array>

an array containing the Cholesky factors for each square matrix. If
upper
isFalse
, the returned array must contain lowertriangular matrices; otherwise, the returned array must contain uppertriangular matrices. The returned array must have a floatingpoint data type determined by Type Promotion Rules and must have the same shape asx
.

linalg.cross(x1, x2, /, *, axis=1) ¶
Returns the cross product of 3element vectors. If
x1
and
x2
are multidimensional arrays (i.e., both have a rank greater than
1
), then the crossproduct of each pair of corresponding 3element vectors is independently computed.
Parameters ¶

x1 : <array>

first input array. Should have a numeric data type.


x2 : <array>

second input array. Must have the same shape as
x1
. Should have a numeric data type.


axis : int

the axis (dimension) of
x1
andx2
containing the vectors for which to compute the cross product. If set to1
, the function computes the cross product for vectors defined by the last axis (dimension). Default:1
.

Returns ¶

out : <array>

an array containing the cross products. The returned array must have a data type determined by Type Promotion Rules .

linalg.det(x, /) ¶
Returns the determinant of a square matrix (or a stack of square matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Should have a floatingpoint data type.

Returns ¶

out : <array>

if
x
is a twodimensional array, a zerodimensional array containing the determinant; otherwise, a nonzero dimensional array containing the determinant for each square matrix. The returned array must have the same data type asx
.

linalg.diagonal(x, /, *, offset=0) ¶
Returns the specified diagonals of a matrix (or a stack of matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices.


offset : int

offset specifying the offdiagonal relative to the main diagonal.

offset = 0
: the main diagonal. 
offset > 0
: offdiagonal above the main diagonal. 
offset < 0
: offdiagonal below the main diagonal.
Default:
0
. 

Returns ¶

out : <array>

an array containing the diagonals and whose shape is determined by removing the last two dimensions and appending a dimension equal to the size of the resulting diagonals. The returned array must have the same data type as
x
.

linalg.eigh(x, /) ¶
Note
The function
eig
will be added in a future version of the specification, as it requires complex number support.
Returns an eigendecomposition x = QLQᵀ of a symmetric matrix (or a stack of symmetric matrices)
x
, where
Q
is an orthogonal matrix (or a stack of matrices) and
L
is a vector (or a stack of vectors).
Note
Whether an array library explicitly checks whether an input array is a symmetric matrix (or a stack of symmetric matrices) is implementationdefined.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Must have a floatingpoint data type.

Returns ¶

out : Tuple[ <array> ]

a namedtuple (
eigenvalues
,eigenvectors
) whose
first element must have the field name
eigenvalues
(corresponding toL
above) and must be an array consisting of computed eigenvalues. The array containing the eigenvalues must have shape(..., M)
. 
second element have have the field name
eigenvectors
(corresponding toQ
above) and must be an array where the columns of the inner most matrices contain the computed eigenvectors. These matrices must be orthogonal. The array containing the eigenvectors must have shape(..., M, M)
.
Each returned array must have the same floatingpoint data type as
x
. 

Note
Eigenvalue sort order is left unspecified and is thus implementationdependent.
linalg.eigvalsh(x, /) ¶
Note
The function
eigvals
will be added in a future version of the specification, as it requires complex number support.
Returns the eigenvalues of a symmetric matrix (or a stack of symmetric matrices)
x
.
Note
Whether an array library explicitly checks whether an input array is a symmetric matrix (or a stack of symmetric matrices) is implementationdefined.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Must have a floatingpoint data type.

Returns ¶

out : <array>

an array containing the computed eigenvalues. The returned array must have shape
(..., M)
and have the same data type asx
.

Note
Eigenvalue sort order is left unspecified and is thus implementationdependent.
linalg.inv(x, /) ¶
Returns the multiplicative inverse of a square matrix (or a stack of square matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Should have a floatingpoint data type.

Returns ¶

out : <array>

an array containing the multiplicative inverses. The returned array must have a floatingpoint data type determined by Type Promotion Rules and must have the same shape as
x
.

linalg.matmul(x1, x2, /) ¶
Alias for matmul(x1, x2, /) .
linalg.matrix_norm(x, /, *, keepdims=False, ord=’fro’) ¶
Computes the matrix norm of a matrix (or a stack of matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices. Should have a floatingpoint data type.


keepdims : bool

If
True
, the last two axes (dimensions) must be included in the result as singleton dimensions, and, accordingly, the result must be compatible with the input array (see Broadcasting ). Otherwise, ifFalse
, the last two axes (dimensions) must not be included in the result. Default:False
.


ord : Optional[ Union[ int, float, Literal[ inf, inf, ‘fro’, ‘nuc’ ] ] ]

order of the norm. The following mathematical norms must be supported:
ord
description
‘fro’
Frobenius norm
‘nuc’
nuclear norm
1
max(sum(abs(x), axis=0))
2
largest singular value
inf
max(sum(abs(x), axis=1))
The following nonmathematical “norms” must be supported:
ord
description
1
min(sum(abs(x), axis=0))
2
smallest singular value
inf
min(sum(abs(x), axis=1))
If
ord=1
, the norm corresponds to the induced matrix norm wherep=1
(i.e., the maximum absolute value column sum).If
ord=2
, the norm corresponds to the induced matrix norm wherep=inf
(i.e., the maximum absolute value row sum).If
ord=inf
, the norm corresponds to the induced matrix norm wherep=2
(i.e., the largest singular value).Default:
'fro'
.

Returns ¶

out : <array>

an array containing the norms for each
MxN
matrix. Ifkeepdims
isFalse
, the returned array must have a rank which is two less than the rank ofx
. The returned array must have a floatingpoint data type determined by Type Promotion Rules .

linalg.matrix_power(x, n, /) ¶
Raises a square matrix (or a stack of square matrices)
x
to an integer power
n
.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Should have a floatingpoint data type.


n : int

integer exponent.

Returns ¶

out : <array>

if
n
is equal to zero, an array containing the identity matrix for each square matrix. Ifn
is less than zero, an array containing the inverse of each square matrix raised to the absolute value ofn
, provided that each square matrix is invertible. Ifn
is greater than zero, an array containing the result of raising each square matrix to the powern
. The returned array must have the same shape asx
and a floatingpoint data type determined by Type Promotion Rules .

linalg.matrix_rank(x, /, *, rtol=None) ¶
Returns the rank (i.e., number of nonzero singular values) of a matrix (or a stack of matrices).
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices. Should have a floatingpoint data type.


rtol : Optional[ Union[ float, <array> ] ]

relative tolerance for small singular values. Singular values approximately less than or equal to
rtol * largest_singular_value
are set to zero. If afloat
, the value is equivalent to a zerodimensional array having a floatingpoint data type determined by Type Promotion Rules (as applied tox
) and must be broadcast against each matrix. If anarray
, must have a floatingpoint data type and must be compatible withshape(x)[:2]
(see Broadcasting ). IfNone
, the default value ismax(M, N) * eps
, whereeps
must be the machine epsilon associated with the floatingpoint data type determined by Type Promotion Rules (as applied tox
). Default:None
.

Returns ¶

out : <array>

an array containing the ranks. The returned array must have a floatingpoint data type determined by Type Promotion Rules and must have shape
(...)
(i.e., must have a shape equal toshape(x)[:2]
).

linalg.matrix_transpose(x, /) ¶
Alias for matrix_transpose(x, /) .
linalg.outer(x1, x2, /) ¶
Returns the outer product of two vectors
x1
and
x2
.
Parameters ¶

x1 : <array>

first onedimensional input array of size
N
. Should have a numeric data type.


x2 : <array>

second onedimensional input array of size
M
. Should have a numeric data type.

Returns ¶

out : <array>

a twodimensional array containing the outer product and whose shape is
(N, M)
. The returned array must have a data type determined by Type Promotion Rules .

linalg.pinv(x, /, *, rtol=None) ¶
Returns the (MoorePenrose) pseudoinverse of a matrix (or a stack of matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices. Should have a floatingpoint data type.


rtol : Optional[ Union[ float, <array> ] ]

relative tolerance for small singular values. Singular values approximately less than or equal to
rtol * largest_singular_value
are set to zero. If afloat
, the value is equivalent to a zerodimensional array having a floatingpoint data type determined by Type Promotion Rules (as applied tox
) and must be broadcast against each matrix. If anarray
, must have a floatingpoint data type and must be compatible withshape(x)[:2]
(see Broadcasting ). IfNone
, the default value ismax(M, N) * eps
, whereeps
must be the machine epsilon associated with the floatingpoint data type determined by Type Promotion Rules (as applied tox
). Default:None
.

Returns ¶

out : <array>

an array containing the pseudoinverses. The returned array must have a floatingpoint data type determined by Type Promotion Rules and must have shape
(..., N, M)
(i.e., must have the same shape asx
, except the innermost two dimensions must be transposed).

linalg.qr(x, /, *, mode=’reduced’) ¶
Returns the qr decomposition x = QR of a full column rank matrix (or a stack of matrices), where
Q
is an orthonormal matrix (or a stack of matrices) and
R
is an uppertriangular matrix (or a stack of matrices).
Note
Whether an array library explicitly checks whether an input array is a full column rank matrix (or a stack of full column rank matrices) is implementationdefined.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices of rankN
. Should have a floatingpoint data type.


mode : Literal[ ‘reduced’, ‘complete’ ]

decomposition mode. Should be one of the following modes:

'reduced'
: compute only the leadingK
columns ofq
, such thatq
andr
have dimensions(..., M, K)
and(..., K, N)
, respectively, and whereK = min(M, N)
. 
'complete'
: computeq
andr
with dimensions(..., M, M)
and(..., M, N)
, respectively.
Default:
'reduced'
. 

Returns ¶

out : Tuple[ <array>, <array> ]

a namedtuple
(Q, R)
whose
first element must have the field name
Q
and must be an array whose shape depends on the value ofmode
and contain matrices with orthonormal columns. Ifmode
is'complete'
, the array must have shape(..., M, M)
. Ifmode
is'reduced'
, the array must have shape(..., M, K)
, whereK = min(M, N)
. The firstx.ndim2
dimensions must have the same size as those of the input arrayx
. 
second element must have the field name
R
and must be an array whose shape depends on the value ofmode
and contain uppertriangular matrices. Ifmode
is'complete'
, the array must have shape(..., M, N)
. Ifmode
is'reduced'
, the array must have shape(..., K, N)
, whereK = min(M, N)
. The firstx.ndim2
dimensions must have the same size as those of the inputx
.
Each returned array must have a floatingpoint data type determined by Type Promotion Rules .


linalg.slogdet(x, /) ¶
Returns the sign and the natural logarithm of the absolute value of the determinant of a square matrix (or a stack of square matrices)
x
.
Note
The purpose of this function is to calculate the determinant more accurately when the determinant is either very small or very large, as calling
det
may overflow or underflow.
Parameters ¶

x : <array>

input array having shape
(..., M, M)
and whose innermost two dimensions form square matrices. Should have a floatingpoint data type.

Returns ¶

out : Tuple[ <array>, <array> ]

a namedtuple (
sign
,logabsdet
) whose
first element must have the field name
sign
and must be an array containing a number representing the sign of the determinant for each square matrix. 
second element must have the field name
logabsdet
and must be an array containing the determinant for each square matrix.
For a real matrix, the sign of the determinant must be either
1
,0
, or1
.Each returned array must have shape
shape(x)[:2]
and a floatingpoint data type determined by Type Promotion Rules .Note
If a determinant is zero, then the corresponding
sign
should be0
andlogabsdet
should beinfinity
; however, depending on the underlying algorithm, the returned result may differ. In all cases, the determinant should be equal tosign * exp(logsabsdet)
(although, again, the result may be subject to numerical precision errors). 

linalg.solve(x1, x2, /) ¶
Returns the solution to the system of linear equations represented by the welldetermined (i.e., full rank) linear matrix equation
AX
=
B
.
Note
Whether an array library explicitly checks whether an input array is full rank is implementationdefined.
Parameters ¶

x1 : <array>

coefficient array
A
having shape(..., M, M)
and whose innermost two dimensions form square matrices. Must be of full rank (i.e., all rows or, equivalently, columns must be linearly independent). Should have a floatingpoint data type.


x2 : <array>

ordinate (or “dependent variable”) array
B
. Ifx2
has shape(M,)
,x2
is equivalent to an array having shape(..., M, 1)
. Ifx2
has shape(..., M, K)
, each columnk
defines a set of ordinate values for which to compute a solution, andshape(x2)[:1]
must be compatible withshape(x1)[:1]
(see Broadcasting ). Should have a floatingpoint data type.

Returns ¶

out : <array>

an array containing the solution to the system
AX = B
for each square matrix. The returned array must have the same shape asx2
(i.e., the array corresponding toB
) and must have a floatingpoint data type determined by Type Promotion Rules .

linalg.svd(x, /, *, full_matrices=True) ¶
Returns a singular value decomposition A = USVh of a matrix (or a stack of matrices)
x
, where
U
is a matrix (or a stack of matrices) with orthonormal columns,
S
is a vector of nonnegative numbers (or stack of vectors), and
Vh
is a matrix (or a stack of matrices) with orthonormal rows.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions form matrices on which to perform singular value decomposition. Should have a floatingpoint data type.


full_matrices : bool

If
True
, compute fullsizedU
andVh
, such thatU
has shape(..., M, M)
andVh
has shape(..., N, N)
. IfFalse
, compute on the leadingK
singular vectors, such thatU
has shape(..., M, K)
andVh
has shape(..., K, N)
and whereK = min(M, N)
. Default:True
.

Returns ¶

out : Union[ <array>, Tuple[ <array>, … ] ]

a namedtuple
(U, S, Vh)
whose
first element must have the field name
U
and must be an array whose shape depends on the value offull_matrices
and contain matrices with orthonormal columns (i.e., the columns are left singular vectors). Iffull_matrices
isTrue
, the array must have shape(..., M, M)
. Iffull_matrices
isFalse
, the array must have shape(..., M, K)
, whereK = min(M, N)
. The firstx.ndim2
dimensions must have the same shape as those of the inputx
. 
second element must have the field name
S
and must be an array with shape(..., K)
that contains the vector(s) of singular values of lengthK
, whereK = min(M, N)
. For each vector, the singular values must be sorted in descending order by magnitude, such thats[..., 0]
is the largest value,s[..., 1]
is the second largest value, et cetera. The firstx.ndim2
dimensions must have the same shape as those of the inputx
. 
third element must have the field name
Vh
and must be an array whose shape depends on the value offull_matrices
and contain orthonormal rows (i.e., the rows are the right singular vectors and the array is the adjoint). Iffull_matrices
isTrue
, the array must have shape(..., N, N)
. Iffull_matrices
isFalse
, the array must have shape(..., K, N)
whereK = min(M, N)
. The firstx.ndim2
dimensions must have the same shape as those of the inputx
.
Each returned array must have the same floatingpoint data type as
x
. 

linalg.svdvals(x, /) ¶
Returns the singular values of a matrix (or a stack of matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions form matrices on which to perform singular value decomposition. Should have a floatingpoint data type.

Returns ¶

out : <array>

an array with shape
(..., K)
that contains the vector(s) of singular values of lengthK
, whereK = min(M, N)
. For each vector, the singular values must be sorted in descending order by magnitude, such thats[..., 0]
is the largest value,s[..., 1]
is the second largest value, et cetera. The firstx.ndim2
dimensions must have the same shape as those of the inputx
. The returned array must have the same floatingpoint data type asx
.

linalg.tensordot(x1, x2, /, *, axes=2) ¶
Alias for tensordot(x1, x2, /, *, axes=2) .
linalg.trace(x, /, *, offset=0) ¶
Returns the sum along the specified diagonals of a matrix (or a stack of matrices)
x
.
Parameters ¶

x : <array>

input array having shape
(..., M, N)
and whose innermost two dimensions formMxN
matrices. Should have a numeric data type.


offset : int

offset specifying the offdiagonal relative to the main diagonal.

offset = 0
: the main diagonal. 
offset > 0
: offdiagonal above the main diagonal. 
offset < 0
: offdiagonal below the main diagonal.
Default:
0
. 

Returns ¶

out : <array>

an array containing the traces and whose shape is determined by removing the last two dimensions and storing the traces in the last array dimension. For example, if
x
has rankk
and shape(I, J, K, ..., L, M, N)
, then an output array has rankk2
and shape(I, J, K, ..., L)
whereout[i, j, k, ..., l] = trace(a[i, j, k, ..., l, :, :])
The returned array must have the same data type as
x
.

linalg.vecdot(x1, x2, /, *, axis=1) ¶
Alias for vecdot(x1, x2, /, *, axis=1) .
linalg.vector_norm(x, /, *, axis=None, keepdims=False, ord=2) ¶
Computes the vector norm of a vector (or batch of vectors)
x
.
Parameters ¶

x : <array>

input array. Should have a floatingpoint data type.


axis : Optional[ Union[ int, Tuple[ int, … ] ] ]

If an integer,
axis
specifies the axis (dimension) along which to compute vector norms. If an ntuple,axis
specifies the axes (dimensions) along which to compute batched vector norms. IfNone
, the vector norm must be computed over all array values (i.e., equivalent to computing the vector norm of a flattened array). Negative indices must be supported. Default:None
.


keepdims : bool

If
True
, the axes (dimensions) specified byaxis
must be included in the result as singleton dimensions, and, accordingly, the result must be compatible with the input array (see Broadcasting ). Otherwise, ifFalse
, the axes (dimensions) specified byaxis
must not be included in the result. Default:False
.


ord : Union[ int, float, Literal[ inf, inf ] ]

order of the norm. The following mathematical norms must be supported:
ord
description
1
L1norm (Manhattan)
2
L2norm (Euclidean)
inf
infinity norm
(int,float >= 1)
pnorm
The following nonmathematical “norms” must be supported:
ord
description
0
sum(a != 0)
1
1./sum(1./abs(a))
2
1./sqrt(sum(1./abs(a)**2))
inf
min(abs(a))
(int,float < 1)
sum(abs(a)**ord)**(1./ord)
Default:
2
.

Returns ¶

out : <array>

an array containing the vector norms. If
axis
isNone
, the returned array must be a zerodimensional array containing a vector norm. Ifaxis
is a scalar value (int
orfloat
), the returned array must have a rank which is one less than the rank ofx
. Ifaxis
is an
tuple, the returned array must have a rank which isn
less than the rank ofx
. The returned array must have a floatingpoint data type determined by Type Promotion Rules .
