/**
|
* @license
|
* Copyright 2018 Google Inc. 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 } from '../tensor';
|
import { TensorLike } from '../types';
|
/**
|
* Computes `-1 * x` element-wise.
|
*
|
* ```js
|
* const x = tf.tensor2d([1, 2, -2, 0], [2, 2]);
|
*
|
* x.neg().print(); // or tf.neg(x)
|
* ```
|
*
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function neg_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes ceiling of input `tf.Tensor` element-wise: `ceil(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([.6, 1.1, -3.3]);
|
*
|
* x.ceil().print(); // or tf.ceil(x)
|
* ```
|
* @param x The input Tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function ceil_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes floor of input `tf.Tensor` element-wise: `floor(x)`.
|
*
|
* ```js
|
* const x = tf.tensor1d([.6, 1.1, -3.3]);
|
*
|
* x.floor().print(); // or tf.floor(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function floor_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Returns an element-wise indication of the sign of a number.
|
*
|
* ```js
|
* const x = tf.tensor1d([.6, 1.1, -3.3, NaN, 0]);
|
*
|
* x.sign().print(); // or tf.sign(x)
|
* ```
|
* @param x The input Tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function sign_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* RReturns which elements of x are NaN.
|
*
|
* ```js
|
* const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
|
*
|
* x.isNaN().print(); // or tf.isNaN(x)
|
* ```
|
* @param x The input Tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function isNaN_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Returns which elements of x are Infinity or -Infinity.
|
*
|
* ```js
|
* const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
|
*
|
* x.isInf().print(); // or tf.isNaN(x)
|
* ```
|
* @param x The input Tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function isInf_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Returns which elements of x are finite.
|
*
|
* ```js
|
* const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
|
*
|
* x.isFinite().print(); // or tf.isNaN(x)
|
* ```
|
* @param x The input Tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function isFinite_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes round of input `tf.Tensor` element-wise: `round(x)`.
|
* It implements banker's rounding.
|
*
|
* ```js
|
* const x = tf.tensor1d([.6, 1.1, -3.3]);
|
*
|
* x.round().print(); // or tf.round(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function round_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes exponential of the input `tf.Tensor` element-wise. `e ^ x`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, -3]);
|
*
|
* x.exp().print(); // or tf.exp(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function exp_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes exponential of the input `tf.Tensor` minus one element-wise.
|
* `e ^ x - 1`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, -3]);
|
*
|
* x.expm1().print(); // or tf.expm1(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function expm1_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes natural logarithm of the input `tf.Tensor` element-wise: `ln(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, Math.E]);
|
*
|
* x.log().print(); // or tf.log(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function log_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes natural logarithm of the input `tf.Tensor` plus one
|
* element-wise: `ln(1 + x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, Math.E - 1]);
|
*
|
* x.log1p().print(); // or tf.log1p(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function log1p_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes square root of the input `tf.Tensor` element-wise: `y = sqrt(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, 4, -1]);
|
*
|
* x.sqrt().print(); // or tf.sqrt(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function sqrt_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes reciprocal of square root of the input `tf.Tensor` element-wise:
|
* `y = 1 / sqrt(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([1, 2, 4, -1]);
|
*
|
* x.rsqrt().print(); // or tf.rsqrt(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function rsqrt_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes reciprocal of x element-wise: `1 / x`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, 2]);
|
*
|
* x.reciprocal().print(); // or tf.reciprocal(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function reciprocal_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes absolute value element-wise: `abs(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([-1, 2, -3, 4]);
|
*
|
* x.abs().print(); // or tf.abs(x)
|
* ```
|
* @param x The input `tf.Tensor`.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function abs_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Clips values element-wise. `max(min(x, clipValueMax), clipValueMin)`
|
*
|
* ```js
|
* const x = tf.tensor1d([-1, 2, -3, 4]);
|
*
|
* x.clipByValue(-2, 3).print(); // or tf.clipByValue(x, -2, 3)
|
* ```
|
* @param x The input tensor.
|
* @param clipValueMin Lower-bound of range to be clipped to.
|
* @param clipValueMax Upper-bound of range to be clipped to.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function clipByValue_<T extends Tensor>(x: T | TensorLike, clipValueMin: number, clipValueMax: number): T;
|
/**
|
* Computes sigmoid element-wise, `1 / (1 + exp(-x))`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, -1, 2, -3]);
|
*
|
* x.sigmoid().print(); // or tf.sigmoid(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function sigmoid_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes log sigmoid of the input `tf.Tensor` element-wise:
|
* `logSigmoid(x)`. For numerical stability, we use `-tf.softplus(-x)`.
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.logSigmoid().print(); // or tf.logSigmoid(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function logSigmoid_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes softplus of the input `tf.Tensor` element-wise: `log(exp(x) + 1)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.softplus().print(); // or tf.softplus(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function softplus_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes sin of the input Tensor element-wise: `sin(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
|
*
|
* x.sin().print(); // or tf.sin(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function sin_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes cos of the input `tf.Tensor` element-wise: `cos(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
|
*
|
* x.cos().print(); // or tf.cos(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function cos_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes tan of the input `tf.Tensor` element-wise, `tan(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
|
*
|
* x.tan().print(); // or tf.tan(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function tan_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes asin of the input `tf.Tensor` element-wise: `asin(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.asin().print(); // or tf.asin(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function asin_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes acos of the input `tf.Tensor` element-wise: `acos(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.acos().print(); // or tf.acos(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function acos_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes atan of the input `tf.Tensor` element-wise: `atan(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.atan().print(); // or tf.atan(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function atan_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes hyperbolic sin of the input `tf.Tensor` element-wise: `sinh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.sinh().print(); // or tf.sinh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function sinh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes hyperbolic cos of the input `tf.Tensor` element-wise: `cosh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.cosh().print(); // or tf.cosh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function cosh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes hyperbolic tangent of the input `tf.Tensor` element-wise: `tanh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, 70]);
|
*
|
* x.tanh().print(); // or tf.tanh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function tanh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes inverse hyperbolic sin of the input `tf.Tensor` element-wise:
|
* `asinh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 1, -1, .7]);
|
*
|
* x.asinh().print(); // or tf.asinh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function asinh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes the inverse hyperbolic cos of the input `tf.Tensor` element-wise:
|
* `acosh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([10, 1, 3, 5.7]);
|
*
|
* x.acosh().print(); // or tf.acosh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function acosh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes inverse hyperbolic tan of the input `tf.Tensor` element-wise:
|
* `atanh(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, .1, -.1, .7]);
|
*
|
* x.atanh().print(); // or tf.atanh(x)
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function atanh_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes gause error function of the input `tf.Tensor` element-wise:
|
* `erf(x)`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, .1, -.1, .7]);
|
*
|
* x.erf().print(); // or tf.erf(x);
|
* ```
|
* @param x The input tensor.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function erf_<T extends Tensor>(x: T | TensorLike): T;
|
/**
|
* Computes step of the input `tf.Tensor` element-wise: `x > 0 ? 1 : alpha * x`
|
*
|
* ```js
|
* const x = tf.tensor1d([0, 2, -1, -3]);
|
*
|
* x.step(.5).print(); // or tf.step(x, .5)
|
* ```
|
* @param x The input tensor.
|
* @param alpha The gradient when input is negative.
|
*/
|
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
|
declare function step_<T extends Tensor>(x: T | TensorLike, alpha?: number): T;
|
export declare const abs: typeof abs_;
|
export declare const acos: typeof acos_;
|
export declare const acosh: typeof acosh_;
|
export declare const asin: typeof asin_;
|
export declare const asinh: typeof asinh_;
|
export declare const atan: typeof atan_;
|
export declare const atanh: typeof atanh_;
|
export declare const ceil: typeof ceil_;
|
export declare const clipByValue: typeof clipByValue_;
|
export declare const cos: typeof cos_;
|
export declare const cosh: typeof cosh_;
|
export declare const erf: typeof erf_;
|
export declare const exp: typeof exp_;
|
export declare const expm1: typeof expm1_;
|
export declare const floor: typeof floor_;
|
export declare const log: typeof log_;
|
export declare const log1p: typeof log1p_;
|
export declare const logSigmoid: typeof logSigmoid_;
|
export declare const neg: typeof neg_;
|
export declare const reciprocal: typeof reciprocal_;
|
export declare const round: typeof round_;
|
export declare const rsqrt: typeof rsqrt_;
|
export declare const sigmoid: typeof sigmoid_;
|
export declare const sign: typeof sign_;
|
export declare const isNaN: typeof isNaN_;
|
export declare const isInf: typeof isInf_;
|
export declare const isFinite: typeof isFinite_;
|
export declare const sin: typeof sin_;
|
export declare const sinh: typeof sinh_;
|
export declare const softplus: typeof softplus_;
|
export declare const sqrt: typeof sqrt_;
|
export declare const step: typeof step_;
|
export declare const tan: typeof tan_;
|
export declare const tanh: typeof tanh_;
|
export {};
|
