/**
|
* @license
|
* Copyright 2018 Google LLC. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
* =============================================================================
|
*/
|
import { Tensor, Tensor1D, Tensor2D } from '../tensor';
|
import { TensorLike } from '../types';
|
/**
|
* Copy a tensor setting everything outside a central band in each innermost
|
* matrix to zero.
|
*
|
* The band part is computed as follows: Assume input has `k` dimensions
|
* `[I, J, K, ..., M, N]`, then the output is a tensor with the same shape where
|
* `band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
|
* The indicator function
|
* `in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower))`
|
* `&& (num_upper < 0 || (n-m) <= num_upper)`
|
*
|
* ```js
|
* const x = tf.tensor2d([[ 0, 1, 2, 3],
|
* [-1, 0, 1, 2],
|
* [-2, -1, 0, 1],
|
* [-3, -2, -1, 0]]);
|
* let y = tf.linalg.bandPart(x, 1, -1);
|
* y.print(); // [[ 0, 1, 2, 3],
|
* // [-1, 0, 1, 2],
|
* // [ 0, -1, 0, 1],
|
* // [ 0, 0 , -1, 0]]
|
* let z = tf.linalg.bandPart(x, 2, 1);
|
* z.print(); // [[ 0, 1, 0, 0],
|
* // [-1, 0, 1, 0],
|
* // [-2, -1, 0, 1],
|
* // [ 0, -2, -1, 0]]
|
* ```
|
*
|
* @param x Rank `k` tensor
|
* @param numLower Number of subdiagonals to keep.
|
* If negative, keep entire lower triangle.
|
* @param numUpper Number of subdiagonals to keep.
|
* If negative, keep entire upper triangle.
|
* @returns Rank `k` tensor of the same shape as input.
|
* The extracted banded tensor.
|
*/
|
/**
|
* @doc {heading:'Operations',
|
* subheading:'Linear Algebra',
|
* namespace:'linalg'}
|
*/
|
declare function bandPart_<T extends Tensor>(a: T | TensorLike, numLower: number, numUpper: number): T;
|
/**
|
* Gram-Schmidt orthogonalization.
|
*
|
* ```js
|
* const x = tf.tensor2d([[1, 2], [3, 4]]);
|
* let y = tf.linalg.gramSchmidt(x);
|
* y.print();
|
* console.log('Othogonalized:');
|
* y.dot(y.transpose()).print(); // should be nearly the identity matrix.
|
* console.log('First row direction maintained:');
|
* const data = await y.array();
|
* console.log(data[0][1] / data[0][0]); // should be nearly 2.
|
* ```
|
*
|
* @param xs The vectors to be orthogonalized, in one of the two following
|
* formats:
|
* - An Array of `tf.Tensor1D`.
|
* - A `tf.Tensor2D`, i.e., a matrix, in which case the vectors are the rows
|
* of `xs`.
|
* In each case, all the vectors must have the same length and the length
|
* must be greater than or equal to the number of vectors.
|
* @returns The orthogonalized and normalized vectors or matrix.
|
* Orthogonalization means that the vectors or the rows of the matrix
|
* are orthogonal (zero inner products). Normalization means that each
|
* vector or each row of the matrix has an L2 norm that equals `1`.
|
*/
|
/**
|
* @doc {heading:'Operations',
|
* subheading:'Linear Algebra',
|
* namespace:'linalg'}
|
*/
|
declare function gramSchmidt_(xs: Tensor1D[] | Tensor2D): Tensor1D[] | Tensor2D;
|
/**
|
* Compute QR decomposition of m-by-n matrix using Householder transformation.
|
*
|
* Implementation based on
|
* [http://www.cs.cornell.edu/~bindel/class/cs6210-f09/lec18.pdf]
|
* (http://www.cs.cornell.edu/~bindel/class/cs6210-f09/lec18.pdf)
|
*
|
* ```js
|
* const a = tf.tensor2d([[1, 2], [3, 4]]);
|
* let [q, r] = tf.linalg.qr(a);
|
* console.log('Q');
|
* q.print();
|
* console.log('R');
|
* r.print();
|
* console.log('Orthogonalized');
|
* q.dot(q.transpose()).print() // should be nearly the identity matrix.
|
* console.log('Reconstructed');
|
* q.dot(r).print(); // should be nearly [[1, 2], [3, 4]];
|
* ```
|
*
|
* @param x The `tf.Tensor` to be QR-decomposed. Must have rank >= 2. Suppose
|
* it has the shape `[..., M, N]`.
|
* @param fullMatrices An optional boolean parameter. Defaults to `false`.
|
* If `true`, compute full-sized `Q`. If `false` (the default),
|
* compute only the leading N columns of `Q` and `R`.
|
* @returns An `Array` of two `tf.Tensor`s: `[Q, R]`. `Q` is a unitary matrix,
|
* i.e., its columns all have unit norm and are mutually orthogonal.
|
* If `M >= N`,
|
* If `fullMatrices` is `false` (default),
|
* - `Q` has a shape of `[..., M, N]`,
|
* - `R` has a shape of `[..., N, N]`.
|
* If `fullMatrices` is `true` (default),
|
* - `Q` has a shape of `[..., M, M]`,
|
* - `R` has a shape of `[..., M, N]`.
|
* If `M < N`,
|
* - `Q` has a shape of `[..., M, M]`,
|
* - `R` has a shape of `[..., M, N]`.
|
* @throws If the rank of `x` is less than 2.
|
*/
|
/**
|
* @doc {heading:'Operations',
|
* subheading:'Linear Algebra',
|
* namespace:'linalg'}
|
*/
|
declare function qr_(x: Tensor, fullMatrices?: boolean): [Tensor, Tensor];
|
export declare const bandPart: typeof bandPart_;
|
export declare const gramSchmidt: typeof gramSchmidt_;
|
export declare const qr: typeof qr_;
|
export {};
|
