Warning: This API is deprecated and will be removed in a future
version of TensorFlow after
the replacement is stable.
Lu
Stay organized with collections
Save and categorize content based on your preferences.
Computes the LU decomposition of one or more square matrices.
The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
form square matrices.
The input has to be invertible.
The output consists of two tensors LU and P containing the LU decomposition
of all input submatrices `[..., :, :]`. LU encodes the lower triangular and
upper triangular factors.
For each input submatrix of shape `[M, M]`, L is a lower triangular matrix of
shape `[M, M]` with unit diagonal whose entries correspond to the strictly lower
triangular part of LU. U is a upper triangular matrix of shape `[M, M]` whose
entries correspond to the upper triangular part, including the diagonal, of LU.
P represents a permutation matrix encoded as a list of indices each between `0`
and `M-1`, inclusive. If P_mat denotes the permutation matrix corresponding to
P, then the L, U and P satisfies P_mat * input = L * U.
Public Methods
static
<T, U extends Number>
Lu<T, U>
|
create( Scope scope, Operand<T> input, Class<U> outputIdxType)
Factory method to create a class wrapping a new Lu operation.
|
static
<T>
Lu<T, Integer>
|
create( Scope scope, Operand<T> input)
Factory method to create a class wrapping a new Lu operation using default output types.
|
Output<T>
|
lu()
A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the
lower triangular factor `L` with unit diagonal, and whose upper triangular part
denotes the upper triangular factor `U`.
|
Output<U>
|
p()
Permutation of the rows encoded as a list of indices in `0..M-1`.
|
Inherited Methods
From class
java.lang.Object
boolean
|
equals(Object arg0)
|
final
Class<?>
|
getClass()
|
int
|
hashCode()
|
final
void
|
notify()
|
final
void
|
notifyAll()
|
String
|
toString()
|
final
void
|
wait(long arg0, int arg1)
|
final
void
|
wait(long arg0)
|
final
void
|
wait()
|
Public Methods
Factory method to create a class wrapping a new Lu operation.
Parameters
scope |
current scope |
input |
A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
size `[M, M]`. |
Factory method to create a class wrapping a new Lu operation using default output types.
Parameters
scope |
current scope |
input |
A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
size `[M, M]`. |
public
Output<T>
lu
()
A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the
lower triangular factor `L` with unit diagonal, and whose upper triangular part
denotes the upper triangular factor `U`.
public
Output<U>
p
()
Permutation of the rows encoded as a list of indices in `0..M-1`. Shape is
`[..., M]`.
Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.
Last updated 2022-02-12 UTC.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2022-02-12 UTC."],[],[],null,["# Lu\n\npublic final class **Lu** \nComputes the LU decomposition of one or more square matrices.\n\n\nThe input is a tensor of shape \\`\\[..., M, M\\]\\` whose inner-most 2 dimensions\nform square matrices.\n\n\nThe input has to be invertible.\n\n\nThe output consists of two tensors LU and P containing the LU decomposition\nof all input submatrices \\`\\[..., :, :\\]\\`. LU encodes the lower triangular and\nupper triangular factors.\n\n\nFor each input submatrix of shape \\`\\[M, M\\]\\`, L is a lower triangular matrix of\nshape \\`\\[M, M\\]\\` with unit diagonal whose entries correspond to the strictly lower\ntriangular part of LU. U is a upper triangular matrix of shape \\`\\[M, M\\]\\` whose\nentries correspond to the upper triangular part, including the diagonal, of LU.\n\n\nP represents a permutation matrix encoded as a list of indices each between \\`0\\`\nand \\`M-1\\`, inclusive. If P_mat denotes the permutation matrix corresponding to\nP, then the L, U and P satisfies P_mat \\* input = L \\* U.\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n### Public Methods\n\n|---------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| static \\\u003cT, U extends Number\\\u003e [Lu](/api_docs/java/org/tensorflow/op/core/Lu)\\\u003cT, U\\\u003e | [create](/api_docs/java/org/tensorflow/op/core/Lu#create(org.tensorflow.op.Scope,%20org.tensorflow.Operand\u003cT\u003e,%20java.lang.Class\u003cU\u003e))([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input, Class\\\u003cU\\\u003e outputIdxType) Factory method to create a class wrapping a new Lu operation. |\n| static \\\u003cT\\\u003e [Lu](/api_docs/java/org/tensorflow/op/core/Lu)\\\u003cT, Integer\\\u003e | [create](/api_docs/java/org/tensorflow/op/core/Lu#create(org.tensorflow.op.Scope,%20org.tensorflow.Operand\u003cT\u003e))([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input) Factory method to create a class wrapping a new Lu operation using default output types. |\n| [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e | [lu](/api_docs/java/org/tensorflow/op/core/Lu#lu())() A tensor of shape \\`\\[..., M, M\\]\\` whose strictly lower triangular part denotes the lower triangular factor \\`L\\` with unit diagonal, and whose upper triangular part denotes the upper triangular factor \\`U\\`. |\n| [Output](/api_docs/java/org/tensorflow/Output)\\\u003cU\\\u003e | [p](/api_docs/java/org/tensorflow/op/core/Lu#p())() Permutation of the rows encoded as a list of indices in \\`0..M-1\\`. |\n\n### Inherited Methods\n\nFrom class [org.tensorflow.op.PrimitiveOp](/api_docs/java/org/tensorflow/op/PrimitiveOp) \n\n|------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|\n| final boolean | [equals](/api_docs/java/org/tensorflow/op/PrimitiveOp#equals(java.lang.Object))(Object obj) |\n| final int | [hashCode](/api_docs/java/org/tensorflow/op/PrimitiveOp#hashCode())() |\n| [Operation](/api_docs/java/org/tensorflow/Operation) | [op](/api_docs/java/org/tensorflow/op/PrimitiveOp#op())() Returns the underlying [Operation](/api_docs/java/org/tensorflow/Operation) |\n| final String | [toString](/api_docs/java/org/tensorflow/op/PrimitiveOp#toString())() |\n\nFrom class java.lang.Object \n\n|------------------|---------------------------|\n| boolean | equals(Object arg0) |\n| final Class\\\u003c?\\\u003e | getClass() |\n| int | hashCode() |\n| final void | notify() |\n| final void | notifyAll() |\n| String | toString() |\n| final void | wait(long arg0, int arg1) |\n| final void | wait(long arg0) |\n| final void | wait() |\n\nPublic Methods\n--------------\n\n#### public static [Lu](/api_docs/java/org/tensorflow/op/core/Lu)\\\u003cT, U\\\u003e\n**create**\n([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input, Class\\\u003cU\\\u003e outputIdxType)\n\nFactory method to create a class wrapping a new Lu operation. \n\n##### Parameters\n\n| scope | current scope |\n| input | A tensor of shape \\`\\[..., M, M\\]\\` whose inner-most 2 dimensions form matrices of size \\`\\[M, M\\]\\`. |\n|-------|-------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- a new instance of Lu \n\n#### public static [Lu](/api_docs/java/org/tensorflow/op/core/Lu)\\\u003cT, Integer\\\u003e\n**create**\n([Scope](/api_docs/java/org/tensorflow/op/Scope) scope, [Operand](/api_docs/java/org/tensorflow/Operand)\\\u003cT\\\u003e input)\n\nFactory method to create a class wrapping a new Lu operation using default output types. \n\n##### Parameters\n\n| scope | current scope |\n| input | A tensor of shape \\`\\[..., M, M\\]\\` whose inner-most 2 dimensions form matrices of size \\`\\[M, M\\]\\`. |\n|-------|-------------------------------------------------------------------------------------------------------|\n\n##### Returns\n\n- a new instance of Lu \n\n#### public [Output](/api_docs/java/org/tensorflow/Output)\\\u003cT\\\u003e\n**lu**\n()\n\nA tensor of shape \\`\\[..., M, M\\]\\` whose strictly lower triangular part denotes the\nlower triangular factor \\`L\\` with unit diagonal, and whose upper triangular part\ndenotes the upper triangular factor \\`U\\`. \n\n#### public [Output](/api_docs/java/org/tensorflow/Output)\\\u003cU\\\u003e\n**p**\n()\n\nPermutation of the rows encoded as a list of indices in \\`0..M-1\\`. Shape is\n\\`\\[..., M\\]\\`."]]