org.tensorflow.op.MathOps Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of libtensorflow Show documentation
Pure-Java code for the TensorFlow machine intelligence library.
The newest version!
package org.tensorflow.op;

import org.tensorflow.Operand;
import org.tensorflow.Shape;
import org.tensorflow.op.math.Abs;
import org.tensorflow.op.math.AccumulateN;
import org.tensorflow.op.math.Acos;
import org.tensorflow.op.math.Acosh;
import org.tensorflow.op.math.Add;
import org.tensorflow.op.math.AddN;
import org.tensorflow.op.math.Angle;
import org.tensorflow.op.math.ApproximateEqual;
import org.tensorflow.op.math.ArgMax;
import org.tensorflow.op.math.ArgMin;
import org.tensorflow.op.math.Asin;
import org.tensorflow.op.math.Asinh;
import org.tensorflow.op.math.Atan;
import org.tensorflow.op.math.Atan2;
import org.tensorflow.op.math.Atanh;
import org.tensorflow.op.math.BesselI0e;
import org.tensorflow.op.math.BesselI1e;
import org.tensorflow.op.math.Betainc;
import org.tensorflow.op.math.Bincount;
import org.tensorflow.op.math.Ceil;
import org.tensorflow.op.math.CheckNumerics;
import org.tensorflow.op.math.CompareAndBitpack;
import org.tensorflow.op.math.ComplexAbs;
import org.tensorflow.op.math.Conj;
import org.tensorflow.op.math.Cos;
import org.tensorflow.op.math.Cosh;
import org.tensorflow.op.math.Cumprod;
import org.tensorflow.op.math.Cumsum;
import org.tensorflow.op.math.Digamma;
import org.tensorflow.op.math.Div;
import org.tensorflow.op.math.DivNoNan;
import org.tensorflow.op.math.Equal;
import org.tensorflow.op.math.Erf;
import org.tensorflow.op.math.Erfc;
import org.tensorflow.op.math.Exp;
import org.tensorflow.op.math.Expm1;
import org.tensorflow.op.math.Fact;
import org.tensorflow.op.math.Floor;
import org.tensorflow.op.math.FloorDiv;
import org.tensorflow.op.math.FloorMod;
import org.tensorflow.op.math.Greater;
import org.tensorflow.op.math.GreaterEqual;
import org.tensorflow.op.math.Igamma;
import org.tensorflow.op.math.Igammac;
import org.tensorflow.op.math.Imag;
import org.tensorflow.op.math.InvertPermutation;
import org.tensorflow.op.math.IsFinite;
import org.tensorflow.op.math.IsInf;
import org.tensorflow.op.math.IsNan;
import org.tensorflow.op.math.Less;
import org.tensorflow.op.math.LessEqual;
import org.tensorflow.op.math.Lgamma;
import org.tensorflow.op.math.Log;
import org.tensorflow.op.math.Log1p;
import org.tensorflow.op.math.LogicalAnd;
import org.tensorflow.op.math.LogicalNot;
import org.tensorflow.op.math.LogicalOr;
import org.tensorflow.op.math.Maximum;
import org.tensorflow.op.math.Mean;
import org.tensorflow.op.math.Minimum;
import org.tensorflow.op.math.Mod;
import org.tensorflow.op.math.Mul;
import org.tensorflow.op.math.Neg;
import org.tensorflow.op.math.NotEqual;
import org.tensorflow.op.math.Polygamma;
import org.tensorflow.op.math.PopulationCount;
import org.tensorflow.op.math.Pow;
import org.tensorflow.op.math.QuantizedAdd;
import org.tensorflow.op.math.QuantizedMul;
import org.tensorflow.op.math.Real;
import org.tensorflow.op.math.RealDiv;
import org.tensorflow.op.math.Reciprocal;
import org.tensorflow.op.math.Rint;
import org.tensorflow.op.math.Round;
import org.tensorflow.op.math.Rsqrt;
import org.tensorflow.op.math.SegmentMax;
import org.tensorflow.op.math.SegmentMean;
import org.tensorflow.op.math.SegmentMin;
import org.tensorflow.op.math.SegmentProd;
import org.tensorflow.op.math.SegmentSum;
import org.tensorflow.op.math.Sigmoid;
import org.tensorflow.op.math.Sign;
import org.tensorflow.op.math.Sin;
import org.tensorflow.op.math.Sinh;
import org.tensorflow.op.math.Softplus;
import org.tensorflow.op.math.Sqrt;
import org.tensorflow.op.math.Square;
import org.tensorflow.op.math.SquaredDifference;
import org.tensorflow.op.math.Sub;
import org.tensorflow.op.math.Tan;
import org.tensorflow.op.math.Tanh;
import org.tensorflow.op.math.TruncateDiv;
import org.tensorflow.op.math.TruncateMod;
import org.tensorflow.op.math.UnsortedSegmentMax;
import org.tensorflow.op.math.UnsortedSegmentMin;
import org.tensorflow.op.math.UnsortedSegmentProd;
import org.tensorflow.op.math.UnsortedSegmentSum;
import org.tensorflow.op.math.Xdivy;
import org.tensorflow.op.math.Xlogy;
import org.tensorflow.op.math.Zeta;

/**
 * An API for building {@code math} operations as {@link Op Op}s
 *
 * @see {@link Ops}
 */
public final class MathOps {
  private final Scope scope;

  MathOps(Scope scope) {
    this.scope = scope;
  }

  /**
   * Builds an {@link UnsortedSegmentMax} operation
   *
   * @param data 
   * @param segmentIds A tensor whose shape is a prefix of `data.shape`.
   * @param numSegments 
   * @return a new instance of UnsortedSegmentMax
   * @see org.tensorflow.op.math.UnsortedSegmentMax
   */
  public  UnsortedSegmentMax unsortedSegmentMax(Operand data,
      Operand segmentIds, Operand numSegments) {
    return UnsortedSegmentMax.create(scope, data, segmentIds, numSegments);
  }

  /**
   * Builds an {@link LogicalOr} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of LogicalOr
   * @see org.tensorflow.op.math.LogicalOr
   */
  public LogicalOr logicalOr(Operand x, Operand y) {
    return LogicalOr.create(scope, x, y);
  }

  /**
   * Builds an {@link SegmentMean} operation
   *
   * @param data 
   * @param segmentIds A 1-D tensor whose size is equal to the size of `data`'s
   * @return a new instance of SegmentMean
   * @see org.tensorflow.op.math.SegmentMean
   */
  public  SegmentMean segmentMean(Operand data, Operand segmentIds) {
    return SegmentMean.create(scope, data, segmentIds);
  }

  /**
   * Builds an {@link TruncateDiv} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of TruncateDiv
   * @see org.tensorflow.op.math.TruncateDiv
   */
  public  TruncateDiv truncateDiv(Operand x, Operand y) {
    return TruncateDiv.create(scope, x, y);
  }

  /**
   * Builds an {@link BesselI0e} operation
   *
   * @param x 
   * @return a new instance of BesselI0e
   * @see org.tensorflow.op.math.BesselI0e
   */
  public  BesselI0e besselI0e(Operand x) {
    return BesselI0e.create(scope, x);
  }

  /**
   * Builds an {@link Square} operation
   *
   * @param x 
   * @return a new instance of Square
   * @see org.tensorflow.op.math.Square
   */
  public  Square square(Operand x) {
    return Square.create(scope, x);
  }

  /**
   * Builds an {@link LogicalNot} operation
   *
   * @param x 
   * @return a new instance of LogicalNot
   * @see org.tensorflow.op.math.LogicalNot
   */
  public LogicalNot logicalNot(Operand x) {
    return LogicalNot.create(scope, x);
  }

  /**
   * Builds an {@link ArgMin} operation
   *
   * @param input 
   * @param dimension int32 or int64, must be in the range `[-rank(input), rank(input))`.
   * @param outputType 
   * @return a new instance of ArgMin
   * @see org.tensorflow.op.math.ArgMin
   */
  public  ArgMin argMin(Operand input,
      Operand dimension, Class outputType) {
    return ArgMin.create(scope, input, dimension, outputType);
  }

  /**
   * Builds an {@link Equal} operation
   *
   * @param x 
   * @param y 
   * @param options carries optional attributes values
   * @return a new instance of Equal
   * @see org.tensorflow.op.math.Equal
   */
  public  Equal equal(Operand x, Operand y, Equal.Options... options) {
    return Equal.create(scope, x, y, options);
  }

  /**
   * Builds an {@link PopulationCount} operation
   *
   * @param x 
   * @return a new instance of PopulationCount
   * @see org.tensorflow.op.math.PopulationCount
   */
  public  PopulationCount populationCount(Operand x) {
    return PopulationCount.create(scope, x);
  }

  /**
   * Builds an {@link Greater} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Greater
   * @see org.tensorflow.op.math.Greater
   */
  public  Greater greater(Operand x, Operand y) {
    return Greater.create(scope, x, y);
  }

  /**
   * Builds an {@link Mean} operation
   *
   * @param input The tensor to reduce.
   * @param axis The dimensions to reduce. Must be in the range
   * @param options carries optional attributes values
   * @return a new instance of Mean
   * @see org.tensorflow.op.math.Mean
   */
  public  Mean mean(Operand input, Operand axis,
      Mean.Options... options) {
    return Mean.create(scope, input, axis, options);
  }

  /**
   * Builds an {@link Mul} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Mul
   * @see org.tensorflow.op.math.Mul
   */
  public  Mul mul(Operand x, Operand y) {
    return Mul.create(scope, x, y);
  }

  /**
   * Builds an {@link CheckNumerics} operation
   *
   * @param tensor 
   * @param message Prefix of the error message.
   * @return a new instance of CheckNumerics
   * @see org.tensorflow.op.math.CheckNumerics
   */
  public  CheckNumerics checkNumerics(Operand tensor, String message) {
    return CheckNumerics.create(scope, tensor, message);
  }

  /**
   * Builds an {@link Neg} operation
   *
   * @param x 
   * @return a new instance of Neg
   * @see org.tensorflow.op.math.Neg
   */
  public  Neg neg(Operand x) {
    return Neg.create(scope, x);
  }

  /**
   * Builds an {@link Betainc} operation
   *
   * @param a 
   * @param b 
   * @param x 
   * @return a new instance of Betainc
   * @see org.tensorflow.op.math.Betainc
   */
  public  Betainc betainc(Operand a, Operand b, Operand x) {
    return Betainc.create(scope, a, b, x);
  }

  /**
   * Builds an {@link Bincount} operation
   *
   * @param arr int32 `Tensor`.
   * @param size non-negative int32 scalar `Tensor`.
   * @param weights is an int32, int64, float32, or float64 `Tensor` with the same
   * @return a new instance of Bincount
   * @see org.tensorflow.op.math.Bincount
   */
  public  Bincount bincount(Operand arr, Operand size,
      Operand weights) {
    return Bincount.create(scope, arr, size, weights);
  }

  /**
   * Builds an {@link Asinh} operation
   *
   * @param x 
   * @return a new instance of Asinh
   * @see org.tensorflow.op.math.Asinh
   */
  public  Asinh asinh(Operand x) {
    return Asinh.create(scope, x);
  }

  /**
   * Builds an {@link SegmentMin} operation
   *
   * @param data 
   * @param segmentIds A 1-D tensor whose size is equal to the size of `data`'s
   * @return a new instance of SegmentMin
   * @see org.tensorflow.op.math.SegmentMin
   */
  public  SegmentMin segmentMin(Operand data,
      Operand segmentIds) {
    return SegmentMin.create(scope, data, segmentIds);
  }

  /**
   * Builds an {@link ArgMax} operation
   *
   * @param input 
   * @param dimension int32 or int64, must be in the range `[-rank(input), rank(input))`.
   * @param outputType 
   * @return a new instance of ArgMax
   * @see org.tensorflow.op.math.ArgMax
   */
  public  ArgMax argMax(Operand input,
      Operand dimension, Class outputType) {
    return ArgMax.create(scope, input, dimension, outputType);
  }

  /**
   * Builds an {@link Atan} operation
   *
   * @param x 
   * @return a new instance of Atan
   * @see org.tensorflow.op.math.Atan
   */
  public  Atan atan(Operand x) {
    return Atan.create(scope, x);
  }

  /**
   * Builds an {@link Xlogy} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Xlogy
   * @see org.tensorflow.op.math.Xlogy
   */
  public  Xlogy xlogy(Operand x, Operand y) {
    return Xlogy.create(scope, x, y);
  }

  /**
   * Builds an {@link Acos} operation
   *
   * @param x 
   * @return a new instance of Acos
   * @see org.tensorflow.op.math.Acos
   */
  public  Acos acos(Operand x) {
    return Acos.create(scope, x);
  }

  /**
   * Builds an {@link InvertPermutation} operation
   *
   * @param x 1-D.
   * @return a new instance of InvertPermutation
   * @see org.tensorflow.op.math.InvertPermutation
   */
  public  InvertPermutation invertPermutation(Operand x) {
    return InvertPermutation.create(scope, x);
  }

  /**
   * Builds an {@link Tan} operation
   *
   * @param x 
   * @return a new instance of Tan
   * @see org.tensorflow.op.math.Tan
   */
  public  Tan tan(Operand x) {
    return Tan.create(scope, x);
  }

  /**
   * Builds an {@link Xdivy} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Xdivy
   * @see org.tensorflow.op.math.Xdivy
   */
  public  Xdivy xdivy(Operand x, Operand y) {
    return Xdivy.create(scope, x, y);
  }

  /**
   * Builds an {@link UnsortedSegmentMin} operation
   *
   * @param data 
   * @param segmentIds A tensor whose shape is a prefix of `data.shape`.
   * @param numSegments 
   * @return a new instance of UnsortedSegmentMin
   * @see org.tensorflow.op.math.UnsortedSegmentMin
   */
  public  UnsortedSegmentMin unsortedSegmentMin(Operand data,
      Operand segmentIds, Operand numSegments) {
    return UnsortedSegmentMin.create(scope, data, segmentIds, numSegments);
  }

  /**
   * Builds an {@link IsFinite} operation
   *
   * @param x 
   * @return a new instance of IsFinite
   * @see org.tensorflow.op.math.IsFinite
   */
  public  IsFinite isFinite(Operand x) {
    return IsFinite.create(scope, x);
  }

  /**
   * Builds an {@link Floor} operation
   *
   * @param x 
   * @return a new instance of Floor
   * @see org.tensorflow.op.math.Floor
   */
  public  Floor floor(Operand x) {
    return Floor.create(scope, x);
  }

  /**
   * Builds an {@link Log} operation
   *
   * @param x 
   * @return a new instance of Log
   * @see org.tensorflow.op.math.Log
   */
  public  Log log(Operand x) {
    return Log.create(scope, x);
  }

  /**
   * Builds an {@link Sqrt} operation
   *
   * @param x 
   * @return a new instance of Sqrt
   * @see org.tensorflow.op.math.Sqrt
   */
  public  Sqrt sqrt(Operand x) {
    return Sqrt.create(scope, x);
  }

  /**
   * Builds an {@link TruncateMod} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of TruncateMod
   * @see org.tensorflow.op.math.TruncateMod
   */
  public  TruncateMod truncateMod(Operand x, Operand y) {
    return TruncateMod.create(scope, x, y);
  }

  /**
   * Builds an {@link UnsortedSegmentSum} operation
   *
   * @param data 
   * @param segmentIds A tensor whose shape is a prefix of `data.shape`.
   * @param numSegments 
   * @return a new instance of UnsortedSegmentSum
   * @see org.tensorflow.op.math.UnsortedSegmentSum
   */
  public  UnsortedSegmentSum unsortedSegmentSum(Operand data,
      Operand segmentIds, Operand numSegments) {
    return UnsortedSegmentSum.create(scope, data, segmentIds, numSegments);
  }

  /**
   * Builds an {@link CompareAndBitpack} operation
   *
   * @param input Values to compare against `threshold` and bitpack.
   * @param threshold Threshold to compare against.
   * @return a new instance of CompareAndBitpack
   * @see org.tensorflow.op.math.CompareAndBitpack
   */
  public  CompareAndBitpack compareAndBitpack(Operand input, Operand threshold) {
    return CompareAndBitpack.create(scope, input, threshold);
  }

  /**
   * Builds an {@link FloorDiv} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of FloorDiv
   * @see org.tensorflow.op.math.FloorDiv
   */
  public  FloorDiv floorDiv(Operand x, Operand y) {
    return FloorDiv.create(scope, x, y);
  }

  /**
   * Builds an {@link RealDiv} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of RealDiv
   * @see org.tensorflow.op.math.RealDiv
   */
  public  RealDiv realDiv(Operand x, Operand y) {
    return RealDiv.create(scope, x, y);
  }

  /**
   * Builds an {@link Angle} operation
   *
   * @param input 
   * @return a new instance of Angle
   * @see org.tensorflow.op.math.Angle
   */
  public  Angle angle(Operand input) {
    return Angle.create(scope, input);
  }

  /**
   * Builds an {@link Imag} operation
   *
   * @param input 
   * @param Tout 
   * @return a new instance of Imag
   * @see org.tensorflow.op.math.Imag
   */
  public  Imag imag(Operand input, Class Tout) {
    return Imag.create(scope, input, Tout);
  }

  /**
   * Builds an {@link QuantizedMul} operation
   *
   * @param x 
   * @param y 
   * @param minX The float value that the lowest quantized `x` value represents.
   * @param maxX The float value that the highest quantized `x` value represents.
   * @param minY The float value that the lowest quantized `y` value represents.
   * @param maxY The float value that the highest quantized `y` value represents.
   * @param Toutput 
   * @return a new instance of QuantizedMul
   * @see org.tensorflow.op.math.QuantizedMul
   */
  public  QuantizedMul quantizedMul(Operand x, Operand y, Operand minX,
      Operand maxX, Operand minY, Operand maxY, Class Toutput) {
    return QuantizedMul.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
  }

  /**
   * Builds an {@link IsInf} operation
   *
   * @param x 
   * @return a new instance of IsInf
   * @see org.tensorflow.op.math.IsInf
   */
  public  IsInf isInf(Operand x) {
    return IsInf.create(scope, x);
  }

  /**
   * Builds an {@link Real} operation
   *
   * @param input 
   * @param Tout 
   * @return a new instance of Real
   * @see org.tensorflow.op.math.Real
   */
  public  Real real(Operand input, Class Tout) {
    return Real.create(scope, input, Tout);
  }

  /**
   * Builds an {@link Mod} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Mod
   * @see org.tensorflow.op.math.Mod
   */
  public  Mod mod(Operand x, Operand y) {
    return Mod.create(scope, x, y);
  }

  /**
   * Builds an {@link Acosh} operation
   *
   * @param x 
   * @return a new instance of Acosh
   * @see org.tensorflow.op.math.Acosh
   */
  public  Acosh acosh(Operand x) {
    return Acosh.create(scope, x);
  }

  /**
   * Builds an {@link Polygamma} operation
   *
   * @param a 
   * @param x 
   * @return a new instance of Polygamma
   * @see org.tensorflow.op.math.Polygamma
   */
  public  Polygamma polygamma(Operand a, Operand x) {
    return Polygamma.create(scope, a, x);
  }

  /**
   * Builds an {@link Sigmoid} operation
   *
   * @param x 
   * @return a new instance of Sigmoid
   * @see org.tensorflow.op.math.Sigmoid
   */
  public  Sigmoid sigmoid(Operand x) {
    return Sigmoid.create(scope, x);
  }

  /**
   * Builds an {@link Ceil} operation
   *
   * @param x 
   * @return a new instance of Ceil
   * @see org.tensorflow.op.math.Ceil
   */
  public  Ceil ceil(Operand x) {
    return Ceil.create(scope, x);
  }

  /**
   * Builds an {@link LogicalAnd} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of LogicalAnd
   * @see org.tensorflow.op.math.LogicalAnd
   */
  public LogicalAnd logicalAnd(Operand x, Operand y) {
    return LogicalAnd.create(scope, x, y);
  }

  /**
   * Builds an {@link Rint} operation
   *
   * @param x 
   * @return a new instance of Rint
   * @see org.tensorflow.op.math.Rint
   */
  public  Rint rint(Operand x) {
    return Rint.create(scope, x);
  }

  /**
   * Builds an {@link Sin} operation
   *
   * @param x 
   * @return a new instance of Sin
   * @see org.tensorflow.op.math.Sin
   */
  public  Sin sin(Operand x) {
    return Sin.create(scope, x);
  }

  /**
   * Builds an {@link Erf} operation
   *
   * @param x 
   * @return a new instance of Erf
   * @see org.tensorflow.op.math.Erf
   */
  public  Erf erf(Operand x) {
    return Erf.create(scope, x);
  }

  /**
   * Builds an {@link ApproximateEqual} operation
   *
   * @param x 
   * @param y 
   * @param options carries optional attributes values
   * @return a new instance of ApproximateEqual
   * @see org.tensorflow.op.math.ApproximateEqual
   */
  public  ApproximateEqual approximateEqual(Operand x, Operand y,
      ApproximateEqual.Options... options) {
    return ApproximateEqual.create(scope, x, y, options);
  }

  /**
   * Builds an {@link Minimum} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Minimum
   * @see org.tensorflow.op.math.Minimum
   */
  public  Minimum minimum(Operand x, Operand y) {
    return Minimum.create(scope, x, y);
  }

  /**
   * Builds an {@link Erfc} operation
   *
   * @param x 
   * @return a new instance of Erfc
   * @see org.tensorflow.op.math.Erfc
   */
  public  Erfc erfc(Operand x) {
    return Erfc.create(scope, x);
  }

  /**
   * Builds an {@link Imag} operation
   *
   * @param input 
   * @return a new instance of Imag
   * @see org.tensorflow.op.math.Imag
   */
  public  Imag imag(Operand input) {
    return Imag.create(scope, input);
  }

  /**
   * Builds an {@link Angle} operation
   *
   * @param input 
   * @param Tout 
   * @return a new instance of Angle
   * @see org.tensorflow.op.math.Angle
   */
  public  Angle angle(Operand input, Class Tout) {
    return Angle.create(scope, input, Tout);
  }

  /**
   * Builds an {@link Atan2} operation
   *
   * @param y 
   * @param x 
   * @return a new instance of Atan2
   * @see org.tensorflow.op.math.Atan2
   */
  public  Atan2 atan2(Operand y, Operand x) {
    return Atan2.create(scope, y, x);
  }

  /**
   * Builds an {@link NotEqual} operation
   *
   * @param x 
   * @param y 
   * @param options carries optional attributes values
   * @return a new instance of NotEqual
   * @see org.tensorflow.op.math.NotEqual
   */
  public  NotEqual notEqual(Operand x, Operand y, NotEqual.Options... options) {
    return NotEqual.create(scope, x, y, options);
  }

  /**
   * Builds an {@link Expm1} operation
   *
   * @param x 
   * @return a new instance of Expm1
   * @see org.tensorflow.op.math.Expm1
   */
  public  Expm1 expm1(Operand x) {
    return Expm1.create(scope, x);
  }

  /**
   * Builds an {@link AddN} operation
   *
   * @param inputs 
   * @return a new instance of AddN
   * @see org.tensorflow.op.math.AddN
   */
  public  AddN addN(Iterable> inputs) {
    return AddN.create(scope, inputs);
  }

  /**
   * Builds an {@link QuantizedAdd} operation
   *
   * @param x 
   * @param y 
   * @param minX The float value that the lowest quantized `x` value represents.
   * @param maxX The float value that the highest quantized `x` value represents.
   * @param minY The float value that the lowest quantized `y` value represents.
   * @param maxY The float value that the highest quantized `y` value represents.
   * @param Toutput 
   * @return a new instance of QuantizedAdd
   * @see org.tensorflow.op.math.QuantizedAdd
   */
  public  QuantizedAdd quantizedAdd(Operand x, Operand y, Operand minX,
      Operand maxX, Operand minY, Operand maxY, Class Toutput) {
    return QuantizedAdd.create(scope, x, y, minX, maxX, minY, maxY, Toutput);
  }

  /**
   * Builds an {@link Log1p} operation
   *
   * @param x 
   * @return a new instance of Log1p
   * @see org.tensorflow.op.math.Log1p
   */
  public  Log1p log1p(Operand x) {
    return Log1p.create(scope, x);
  }

  /**
   * Builds an {@link FloorMod} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of FloorMod
   * @see org.tensorflow.op.math.FloorMod
   */
  public  FloorMod floorMod(Operand x, Operand y) {
    return FloorMod.create(scope, x, y);
  }

  /**
   * Builds an {@link Exp} operation
   *
   * @param x 
   * @return a new instance of Exp
   * @see org.tensorflow.op.math.Exp
   */
  public  Exp exp(Operand x) {
    return Exp.create(scope, x);
  }

  /**
   * Builds an {@link Digamma} operation
   *
   * @param x 
   * @return a new instance of Digamma
   * @see org.tensorflow.op.math.Digamma
   */
  public  Digamma digamma(Operand x) {
    return Digamma.create(scope, x);
  }

  /**
   * Builds an {@link SquaredDifference} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of SquaredDifference
   * @see org.tensorflow.op.math.SquaredDifference
   */
  public  SquaredDifference squaredDifference(Operand x, Operand y) {
    return SquaredDifference.create(scope, x, y);
  }

  /**
   * Builds an {@link GreaterEqual} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of GreaterEqual
   * @see org.tensorflow.op.math.GreaterEqual
   */
  public  GreaterEqual greaterEqual(Operand x, Operand y) {
    return GreaterEqual.create(scope, x, y);
  }

  /**
   * Builds an {@link IsNan} operation
   *
   * @param x 
   * @return a new instance of IsNan
   * @see org.tensorflow.op.math.IsNan
   */
  public  IsNan isNan(Operand x) {
    return IsNan.create(scope, x);
  }

  /**
   * Builds an {@link Sub} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Sub
   * @see org.tensorflow.op.math.Sub
   */
  public  Sub sub(Operand x, Operand y) {
    return Sub.create(scope, x, y);
  }

  /**
   * Builds an {@link Asin} operation
   *
   * @param x 
   * @return a new instance of Asin
   * @see org.tensorflow.op.math.Asin
   */
  public  Asin asin(Operand x) {
    return Asin.create(scope, x);
  }

  /**
   * Builds an {@link Round} operation
   *
   * @param x 
   * @return a new instance of Round
   * @see org.tensorflow.op.math.Round
   */
  public  Round round(Operand x) {
    return Round.create(scope, x);
  }

  /**
   * Builds an {@link Cumprod} operation
   *
   * @param x A `Tensor`. Must be one of the following types: `float32`, `float64`,
   * @param axis A `Tensor` of type `int32` (default: 0). Must be in the range
   * @param options carries optional attributes values
   * @return a new instance of Cumprod
   * @see org.tensorflow.op.math.Cumprod
   */
  public  Cumprod cumprod(Operand x, Operand axis,
      Cumprod.Options... options) {
    return Cumprod.create(scope, x, axis, options);
  }

  /**
   * Builds an {@link Igamma} operation
   *
   * @param a 
   * @param x 
   * @return a new instance of Igamma
   * @see org.tensorflow.op.math.Igamma
   */
  public  Igamma igamma(Operand a, Operand x) {
    return Igamma.create(scope, a, x);
  }

  /**
   * Builds an {@link Sign} operation
   *
   * @param x 
   * @return a new instance of Sign
   * @see org.tensorflow.op.math.Sign
   */
  public  Sign sign(Operand x) {
    return Sign.create(scope, x);
  }

  /**
   * Builds an {@link Div} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Div
   * @see org.tensorflow.op.math.Div
   */
  public  Div div(Operand x, Operand y) {
    return Div.create(scope, x, y);
  }

  /**
   * Builds an {@link Less} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Less
   * @see org.tensorflow.op.math.Less
   */
  public  Less less(Operand x, Operand y) {
    return Less.create(scope, x, y);
  }

  /**
   * Builds an {@link Pow} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Pow
   * @see org.tensorflow.op.math.Pow
   */
  public  Pow pow(Operand x, Operand y) {
    return Pow.create(scope, x, y);
  }

  /**
   * Builds an {@link LessEqual} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of LessEqual
   * @see org.tensorflow.op.math.LessEqual
   */
  public  LessEqual lessEqual(Operand x, Operand y) {
    return LessEqual.create(scope, x, y);
  }

  /**
   * Builds an {@link Igammac} operation
   *
   * @param a 
   * @param x 
   * @return a new instance of Igammac
   * @see org.tensorflow.op.math.Igammac
   */
  public  Igammac igammac(Operand a, Operand x) {
    return Igammac.create(scope, a, x);
  }

  /**
   * Builds an {@link Zeta} operation
   *
   * @param x 
   * @param q 
   * @return a new instance of Zeta
   * @see org.tensorflow.op.math.Zeta
   */
  public  Zeta zeta(Operand x, Operand q) {
    return Zeta.create(scope, x, q);
  }

  /**
   * Builds an {@link SegmentMax} operation
   *
   * @param data 
   * @param segmentIds A 1-D tensor whose size is equal to the size of `data`'s
   * @return a new instance of SegmentMax
   * @see org.tensorflow.op.math.SegmentMax
   */
  public  SegmentMax segmentMax(Operand data,
      Operand segmentIds) {
    return SegmentMax.create(scope, data, segmentIds);
  }

  /**
   * Builds an {@link Abs} operation
   *
   * @param x 
   * @return a new instance of Abs
   * @see org.tensorflow.op.math.Abs
   */
  public  Abs abs(Operand x) {
    return Abs.create(scope, x);
  }

  /**
   * Builds an {@link DivNoNan} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of DivNoNan
   * @see org.tensorflow.op.math.DivNoNan
   */
  public  DivNoNan divNoNan(Operand x, Operand y) {
    return DivNoNan.create(scope, x, y);
  }

  /**
   * Builds an {@link Sinh} operation
   *
   * @param x 
   * @return a new instance of Sinh
   * @see org.tensorflow.op.math.Sinh
   */
  public  Sinh sinh(Operand x) {
    return Sinh.create(scope, x);
  }

  /**
   * Builds an {@link Rsqrt} operation
   *
   * @param x 
   * @return a new instance of Rsqrt
   * @see org.tensorflow.op.math.Rsqrt
   */
  public  Rsqrt rsqrt(Operand x) {
    return Rsqrt.create(scope, x);
  }

  /**
   * Builds an {@link BesselI1e} operation
   *
   * @param x 
   * @return a new instance of BesselI1e
   * @see org.tensorflow.op.math.BesselI1e
   */
  public  BesselI1e besselI1e(Operand x) {
    return BesselI1e.create(scope, x);
  }

  /**
   * Builds an {@link Lgamma} operation
   *
   * @param x 
   * @return a new instance of Lgamma
   * @see org.tensorflow.op.math.Lgamma
   */
  public  Lgamma lgamma(Operand x) {
    return Lgamma.create(scope, x);
  }

  /**
   * Builds an {@link ComplexAbs} operation
   *
   * @param x 
   * @param Tout 
   * @return a new instance of ComplexAbs
   * @see org.tensorflow.op.math.ComplexAbs
   */
  public  ComplexAbs complexAbs(Operand x, Class Tout) {
    return ComplexAbs.create(scope, x, Tout);
  }

  /**
   * Builds an {@link SegmentSum} operation
   *
   * @param data 
   * @param segmentIds A 1-D tensor whose size is equal to the size of `data`'s
   * @return a new instance of SegmentSum
   * @see org.tensorflow.op.math.SegmentSum
   */
  public  SegmentSum segmentSum(Operand data, Operand segmentIds) {
    return SegmentSum.create(scope, data, segmentIds);
  }

  /**
   * Builds an {@link Tanh} operation
   *
   * @param x 
   * @return a new instance of Tanh
   * @see org.tensorflow.op.math.Tanh
   */
  public  Tanh tanh(Operand x) {
    return Tanh.create(scope, x);
  }

  /**
   * Builds an {@link ComplexAbs} operation
   *
   * @param x 
   * @return a new instance of ComplexAbs
   * @see org.tensorflow.op.math.ComplexAbs
   */
  public  ComplexAbs complexAbs(Operand x) {
    return ComplexAbs.create(scope, x);
  }

  /**
   * Builds an {@link Cumsum} operation
   *
   * @param x A `Tensor`. Must be one of the following types: `float32`, `float64`,
   * @param axis A `Tensor` of type `int32` (default: 0). Must be in the range
   * @param options carries optional attributes values
   * @return a new instance of Cumsum
   * @see org.tensorflow.op.math.Cumsum
   */
  public  Cumsum cumsum(Operand x, Operand axis,
      Cumsum.Options... options) {
    return Cumsum.create(scope, x, axis, options);
  }

  /**
   * Builds an {@link AccumulateN} operation
   *
   * @param inputs A list of `Tensor` objects, each with same shape and type.
   * @param shape Shape of elements of `inputs`.
   * @return a new instance of AccumulateN
   * @see org.tensorflow.op.math.AccumulateN
   */
  public  AccumulateN accumulateN(Iterable> inputs, Shape shape) {
    return AccumulateN.create(scope, inputs, shape);
  }

  /**
   * Builds an {@link Cosh} operation
   *
   * @param x 
   * @return a new instance of Cosh
   * @see org.tensorflow.op.math.Cosh
   */
  public  Cosh cosh(Operand x) {
    return Cosh.create(scope, x);
  }

  /**
   * Builds an {@link Conj} operation
   *
   * @param input 
   * @return a new instance of Conj
   * @see org.tensorflow.op.math.Conj
   */
  public  Conj conj(Operand input) {
    return Conj.create(scope, input);
  }

  /**
   * Builds an {@link SegmentProd} operation
   *
   * @param data 
   * @param segmentIds A 1-D tensor whose size is equal to the size of `data`'s
   * @return a new instance of SegmentProd
   * @see org.tensorflow.op.math.SegmentProd
   */
  public  SegmentProd segmentProd(Operand data, Operand segmentIds) {
    return SegmentProd.create(scope, data, segmentIds);
  }

  /**
   * Builds an {@link ArgMax} operation
   *
   * @param input 
   * @param dimension int32 or int64, must be in the range `[-rank(input), rank(input))`.
   * @return a new instance of ArgMax
   * @see org.tensorflow.op.math.ArgMax
   */
  public  ArgMax argMax(Operand input, Operand dimension) {
    return ArgMax.create(scope, input, dimension);
  }

  /**
   * Builds an {@link Add} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Add
   * @see org.tensorflow.op.math.Add
   */
  public  Add add(Operand x, Operand y) {
    return Add.create(scope, x, y);
  }

  /**
   * Builds an {@link Fact} operation
   *
   * @return a new instance of Fact
   * @see org.tensorflow.op.math.Fact
   */
  public Fact fact() {
    return Fact.create(scope);
  }

  /**
   * Builds an {@link Cos} operation
   *
   * @param x 
   * @return a new instance of Cos
   * @see org.tensorflow.op.math.Cos
   */
  public  Cos cos(Operand x) {
    return Cos.create(scope, x);
  }

  /**
   * Builds an {@link UnsortedSegmentProd} operation
   *
   * @param data 
   * @param segmentIds A tensor whose shape is a prefix of `data.shape`.
   * @param numSegments 
   * @return a new instance of UnsortedSegmentProd
   * @see org.tensorflow.op.math.UnsortedSegmentProd
   */
  public  UnsortedSegmentProd unsortedSegmentProd(Operand data,
      Operand segmentIds, Operand numSegments) {
    return UnsortedSegmentProd.create(scope, data, segmentIds, numSegments);
  }

  /**
   * Builds an {@link Softplus} operation
   *
   * @param features 
   * @return a new instance of Softplus
   * @see org.tensorflow.op.math.Softplus
   */
  public  Softplus softplus(Operand features) {
    return Softplus.create(scope, features);
  }

  /**
   * Builds an {@link Real} operation
   *
   * @param input 
   * @return a new instance of Real
   * @see org.tensorflow.op.math.Real
   */
  public  Real real(Operand input) {
    return Real.create(scope, input);
  }

  /**
   * Builds an {@link ArgMin} operation
   *
   * @param input 
   * @param dimension int32 or int64, must be in the range `[-rank(input), rank(input))`.
   * @return a new instance of ArgMin
   * @see org.tensorflow.op.math.ArgMin
   */
  public  ArgMin argMin(Operand input, Operand dimension) {
    return ArgMin.create(scope, input, dimension);
  }

  /**
   * Builds an {@link Atanh} operation
   *
   * @param x 
   * @return a new instance of Atanh
   * @see org.tensorflow.op.math.Atanh
   */
  public  Atanh atanh(Operand x) {
    return Atanh.create(scope, x);
  }

  /**
   * Builds an {@link Maximum} operation
   *
   * @param x 
   * @param y 
   * @return a new instance of Maximum
   * @see org.tensorflow.op.math.Maximum
   */
  public  Maximum maximum(Operand x, Operand y) {
    return Maximum.create(scope, x, y);
  }

  /**
   * Builds an {@link Reciprocal} operation
   *
   * @param x 
   * @return a new instance of Reciprocal
   * @see org.tensorflow.op.math.Reciprocal
   */
  public  Reciprocal reciprocal(Operand x) {
    return Reciprocal.create(scope, x);
  }
}