Math

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def abs[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAbs

def acos[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAcos

def acosh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAcosh

def add[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathAdd

def addN[D <: ReducibleDataType](inputs: Seq[Tensor[D]]): Tensor[D]

$OpDocMathAddN

def all(input: Tensor[types.BOOLEAN], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[types.BOOLEAN]

$OpDocMathAll

def any(input: Tensor[types.BOOLEAN], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[types.BOOLEAN]

$OpDocMathAny

def approximatelyEqual[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D], tolerance: Float = 0.00001f): Tensor[types.BOOLEAN]

$OpDocMathApproximatelyEqual

def argmax[D <: MathDataType, I <: Int32OrInt64, IR <: Int32OrInt64](input: Tensor[D], axes: Tensor[I], outputDataType: IR): Tensor[IR]

$OpDocMathArgmax

def argmax[D <: MathDataType, I <: Int32OrInt64](input: Tensor[D], axes: Tensor[I]): Tensor[types.INT64]

$OpDocMathArgmax

def argmin[D <: MathDataType, I <: Int32OrInt64, IR <: Int32OrInt64](input: Tensor[D], axes: Tensor[I], outputDataType: IR): Tensor[IR]

$OpDocMathArgmin

def argmin[D <: MathDataType, I <: Int32OrInt64](input: Tensor[D], axes: Tensor[I]): Tensor[types.INT64]

$OpDocMathArgmin

final def asInstanceOf[T0]: T0

def asin[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAsin

def asinh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAsinh

def atan[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAtan

def atan2[D <: Float32OrFloat64](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathAtan2

def atanh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathAtanh

def binCount[D <: Int32OrInt64OrFloat32OrFloat64](input: Tensor[types.INT32], weights: Tensor[D] = null, minLength: Tensor[types.INT32] = null, maxLength: Tensor[types.INT32] = null, dataType: D = null): Tensor[D]

$OpDocMathBinCount

def bucketize[D <: Int32OrInt64OrFloat32OrFloat64](input: Tensor[D], boundaries: Seq[Float]): Tensor[D]

$OpDocMathBucketize

def ceil[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathCeil

def clone(): AnyRef

def complex128(real: Tensor[types.FLOAT64], imag: Tensor[types.FLOAT64]): Tensor[types.COMPLEX128]

$OpDocMathComplex

def complex64(real: Tensor[types.FLOAT32], imag: Tensor[types.FLOAT32]): Tensor[types.COMPLEX64]

$OpDocMathComplex

def conjugate[D <: ComplexDataType, TL[DD <: types.DataType] <: TensorLike[DD]](input: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathConjugate

def cos[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathCos

def cosh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathCosh

def countNonZero[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[types.INT64]

$OpDocMathCountNonZero

def cross[D <: MathDataType](a: Tensor[D], b: Tensor[D]): Tensor[D]

$OpDocMathCross

def cumprod[D <: MathDataType](input: Tensor[D], axis: Tensor[types.INT32] = 0, exclusive: Boolean = false, reverse: Boolean = false): Tensor[D]

$OpDocMathCumprod

def cumsum[D <: MathDataType](input: Tensor[D], axis: Tensor[types.INT32] = 0, exclusive: Boolean = false, reverse: Boolean = false): Tensor[D]

$OpDocMathCumsum

def diag[D <: MathDataType](diagonal: Tensor[D]): Tensor[D]

$OpDocMathDiag

def diagPart[D <: MathDataType](input: Tensor[D]): Tensor[D]

$OpDocMathDiagPart

def digamma[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathDigamma

def divide[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathDivide

final def eq(arg0: AnyRef): Boolean

def equal[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

$OpDocMathEqual

def equals(arg0: Any): Boolean

def erf[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathErf

def erfc[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathErfc

def exp[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathExp

def expm1[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathExpm1

def finalize(): Unit

def floor[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathFloor

def floorMod[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathFloorMod

final def getClass(): Class[_]

def greater[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

OpDocMathGreater

def greaterEqual[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

OpDocMathGreaterEqual

def hashCode(): Int

def igamma[D <: Float32OrFloat64](a: Tensor[D], x: Tensor[D]): Tensor[D]

$OpDocMathIgamma

def igammac[D <: Float32OrFloat64](a: Tensor[D], x: Tensor[D]): Tensor[D]

$OpDocMathIgammac

def incompleteBeta[D <: Float32OrFloat64](a: Tensor[D], b: Tensor[D], x: Tensor[D]): Tensor[D]

$OpDocMathIncompleteBeta

def isFinite[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[types.BOOLEAN]

$OpDocMathIsFinite

def isInf[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[types.BOOLEAN]

$OpDocMathIsInf

final def isInstanceOf[T0]: Boolean

def isNaN[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[types.BOOLEAN]

$OpDocMathIsNaN

def less[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

OpDocMathLess

def lessEqual[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

OpDocMathLessEqual

def linspace[D <: BFloat16OrFloat32OrFloat64, I <: Int32OrInt64](start: Tensor[D], stop: Tensor[D], numberOfValues: Tensor[I]): Tensor[D]

$OpDocMathLinspace

def log[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathLog

def log1p[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathLog1p

def logGamma[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathLogGamma

def logSigmoid[D <: RealDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathLogSigmoid

def logSumExp[D <: MathDataType](input: Tensor[D], axes: Seq[Int] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathLogSumExp

def logicalAnd(x: Tensor[types.BOOLEAN], y: Tensor[types.BOOLEAN]): Tensor[types.BOOLEAN]

$OpDocMathLogicalAnd

def logicalNot(x: Tensor[types.BOOLEAN]): Tensor[types.BOOLEAN]

$OpDocMathLogicalNot

def logicalOr(x: Tensor[types.BOOLEAN], y: Tensor[types.BOOLEAN]): Tensor[types.BOOLEAN]

$OpDocMathLogicalOr

def logicalXOr(x: Tensor[types.BOOLEAN], y: Tensor[types.BOOLEAN]): Tensor[types.BOOLEAN]

$OpDocMathLogicalXOr

def matmul[D <: MathDataType](a: Tensor[D], b: Tensor[D], transposeA: Boolean = false, transposeB: Boolean = false, conjugateA: Boolean = false, conjugateB: Boolean = false, aIsSparse: Boolean = false, bIsSparse: Boolean = false): Tensor[D]

$OpDocMathMatmul

def matrixBandPart[D <: MathDataType, I <: Int32OrInt64](input: Tensor[D], numSubDiagonals: Tensor[I], numSuperDiagonals: Tensor[I]): Tensor[D]

$OpDocMathMatrixBandPart

def matrixDiag[D <: MathDataType](diagonal: Tensor[D]): Tensor[D]

$OpDocMathMatrixDiag

def matrixDiagPart[D <: MathDataType](input: Tensor[D]): Tensor[D]

$OpDocMathMatrixDiagPart

def matrixSetDiag[D <: MathDataType](input: Tensor[D], diagonal: Tensor[D]): Tensor[D]

$OpDocMathMatrixSetDiag

def max[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathMax

def maximum[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathMaximum

def mean[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathMean

def min[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathMin

def minimum[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathMinimum

def mod[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathMod

def multiply[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathMultiply

final def ne(arg0: AnyRef): Boolean

def negate[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathNegate

def notEqual[D <: ReducibleDataType](x: Tensor[D], y: Tensor[D]): Tensor[types.BOOLEAN]

$OpDocMathNotEqual

final def notify(): Unit

final def notifyAll(): Unit

def polygamma[D <: Float32OrFloat64](n: Tensor[D], x: Tensor[D]): Tensor[D]

$OpDocMathPolygamma

def pow[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathPow

def prod[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathProd

def range[D <: NumericDataType](start: Tensor[D], limit: Tensor[D], delta: Tensor[D] = null): Tensor[D]

$OpDocMathRange

def realDivide[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathRealDivide

def reciprocal[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathReciprocal

def round[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathRound

def roundInt[D <: Float16OrFloat32OrFloat64, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathRoundInt

def rsqrt[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathRsqrt

def scalarMul[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](scalar: Tensor[D], tensor: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathScalarMul

def segmentMax[D <: ReducibleDataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I]): Tensor[D]

$OpDocMathSegmentMax

def segmentMean[D <: ReducibleDataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I]): Tensor[D]

$OpDocMathSegmentMean

def segmentMin[D <: ReducibleDataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I]): Tensor[D]

$OpDocMathSegmentMin

def segmentProd[D <: ReducibleDataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I]): Tensor[D]

$OpDocMathSegmentProd

def segmentSum[D <: ReducibleDataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I]): Tensor[D]

$OpDocMathSegmentSum

def select[D <: types.DataType](condition: Tensor[types.BOOLEAN], x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathSelect

def sigmoid[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSigmoid

def sign[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSign

def sin[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSin

def sinh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSinh

def sparseSegmentMean[D <: types.DataType, I1 <: Int32OrInt64, I2 <: Int32OrInt64](data: Tensor[D], indices: Tensor[I1], segmentIndices: Tensor[I2], numSegments: Tensor[types.INT32] = null): Tensor[D]

$OpDocMathSparseSegmentMean

def sparseSegmentSum[D <: types.DataType, I1 <: Int32OrInt64, I2 <: Int32OrInt64](data: Tensor[D], indices: Tensor[I1], segmentIndices: Tensor[I2], numSegments: Tensor[types.INT32] = null): Tensor[D]

$OpDocMathSparseSegmentSum

def sparseSegmentSumSqrtN[D <: types.DataType, I1 <: Int32OrInt64, I2 <: Int32OrInt64](data: Tensor[D], indices: Tensor[I1], segmentIndices: Tensor[I2], numSegments: Tensor[types.INT32] = null): Tensor[D]

$OpDocMathSparseSegmentSumSqrtN

def sqrt[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSqrt

def square[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathSquare

def squaredDifference[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathSquaredDifference

def subtract[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathSubtract

def sum[D <: ReducibleDataType](input: Tensor[D], axes: Tensor[types.INT32] = null, keepDims: Boolean = false): Tensor[D]

$OpDocMathSum

final def synchronized[T0](arg0: ⇒ T0): T0

def tan[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathTan

def tanh[D <: MathDataType, TL[DD <: types.DataType] <: TensorLike[DD]](x: TL[D])(implicit ev: Aux[TL, D]): TL[D]

$OpDocMathTanh

def tensorDot[D <: MathDataType](a: Tensor[D], b: Tensor[D], axesA: Tensor[types.INT32], axesB: Tensor[types.INT32]): Tensor[D]

Dynamic version (i.e., where axesA and axesB may be tensors) of the tensorDot op.

def tensorDot[D <: MathDataType](a: Tensor[D], b: Tensor[D], numAxes: Tensor[types.INT32]): Tensor[D]

Dynamic version (i.e., where numAxes may be a tensor) of the tensorDot op.

def toString(): String

def trace[D <: MathDataType](input: Tensor[D]): Tensor[D]

$OpDocMathTrace

def truncateDivide[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathTruncateDivide

def truncateMod[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathTruncateMod

def unsortedSegmentMax[D <: types.DataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I], segmentsNumber: Tensor[types.INT32]): Tensor[D]

$OpDocMathUnsortedSegmentMax

def unsortedSegmentSum[D <: types.DataType, I <: Int32OrInt64](data: Tensor[D], segmentIndices: Tensor[I], segmentsNumber: Tensor[types.INT32]): Tensor[D]

$OpDocMathUnsortedSegmentSum

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zerosFraction[D <: ReducibleDataType](input: Tensor[D]): Tensor[types.FLOAT32]

$OpDocMathZerosFraction

def zeta[D <: Float32OrFloat64](x: Tensor[D], q: Tensor[D]): Tensor[D]

$OpDocMathZeta

def floorDivide[D <: MathDataType](x: Tensor[D], y: Tensor[D]): Tensor[D]

$OpDocMathFloorDivide