deeplearning4j/deeplearning4j

NDBase has 166 methods (exceeds 20 allowed). Consider refactoring.

Open

public class NDBase {
  public NDBase() {
  }

  /**

File NDBase.java has 790 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*
 *  ******************************************************************************
 *  *
 *  *
 *  * This program and the accompanying materials are made available under the

Method stridedSlice has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray stridedSlice(INDArray in, long[] begin, long[] end, long[] strides, int beginMask,
      int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask) {

Method stridedSlice has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray stridedSlice(INDArray in, INDArray begin, INDArray end, INDArray strides,
      int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask) {

Method tensorMmul has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray tensorMmul(INDArray x, INDArray y, int[] dimensionsX, int[] dimensionsY,
      boolean transposeX, boolean transposeY, boolean transposeZ) {

Method batchMmul has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray[] batchMmul(INDArray alphas, INDArray betas, INDArray[] inputsA,
      INDArray[] inputsB, boolean transposeA, boolean transposeB) {

Method oneHot has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray oneHot(INDArray indices, int depth, int axis, double on, double off,
      DataType dataType) {

Method oneHot has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray oneHot(INDArray indices, int depth, int axis, double on, double off) {

Method mmul has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public INDArray mmul(INDArray x, INDArray y, boolean transposeX, boolean transposeY,
      boolean transposeZ) {

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray linspace(INDArray start, INDArray stop, INDArray number, DataType dataType) {
    NDValidation.validateNumerical("linspace", "start", start);
    NDValidation.validateNumerical("linspace", "stop", stop);
    NDValidation.validateInteger("linspace", "number", number);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.shape.Linspace(start, stop, number, dataType))[0];

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray range(INDArray from, INDArray to, INDArray step, DataType dataType) {
    NDValidation.validateNumerical("range", "from", from);
    NDValidation.validateNumerical("range", "to", to);
    NDValidation.validateNumerical("range", "step", step);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.random.impl.Range(from, to, step, dataType))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMean(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMean", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMean", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentMean", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMean(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterMin(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterMin", "ref", ref);
    NDValidation.validateNumerical("scatterMin", "indices", indices);
    NDValidation.validateNumerical("scatterMin", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterMin(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterNdAdd(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterNdAdd", "ref", ref);
    NDValidation.validateNumerical("scatterNdAdd", "indices", indices);
    NDValidation.validateNumerical("scatterNdAdd", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterNdAdd(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterUpdate(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterUpdate", "ref", ref);
    NDValidation.validateNumerical("scatterUpdate", "indices", indices);
    NDValidation.validateNumerical("scatterUpdate", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterUpdate(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray clipByNorm(INDArray x, INDArray clipValue, INDArray dimensions) {
    NDValidation.validateNumerical("clipByNorm", "x", x);
    NDValidation.validateNumerical("clipByNorm", "clipValue", clipValue);
    NDValidation.validateNumerical("clipByNorm", "dimensions", dimensions);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.clip.ClipByNorm(x, clipValue, dimensions))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterAdd(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterAdd", "ref", ref);
    NDValidation.validateNumerical("scatterAdd", "indices", indices);
    NDValidation.validateNumerical("scatterAdd", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterAdd(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentProd(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentProd", "data", data);
    NDValidation.validateNumerical("unsortedSegmentProd", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentProd", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentProd(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterNdUpdate(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterNdUpdate", "ref", ref);
    NDValidation.validateNumerical("scatterNdUpdate", "indices", indices);
    NDValidation.validateNumerical("scatterNdUpdate", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterNdUpdate(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterNdSub(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterNdSub", "ref", ref);
    NDValidation.validateNumerical("scatterNdSub", "indices", indices);
    NDValidation.validateNumerical("scatterNdSub", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterNdSub(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterMul(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterMul", "ref", ref);
    NDValidation.validateNumerical("scatterMul", "indices", indices);
    NDValidation.validateNumerical("scatterMul", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterMul(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray sparseToDense(INDArray indices, INDArray shape, INDArray values) {
    NDValidation.validateNumerical("sparseToDense", "indices", indices);
    NDValidation.validateNumerical("sparseToDense", "shape", shape);
    NDValidation.validateNumerical("sparseToDense", "values", values);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.compat.CompatSparseToDense(indices, shape, values))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentSqrtN(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentSqrtN", "data", data);
    NDValidation.validateNumerical("unsortedSegmentSqrtN", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentSqrtN", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentSqrtN(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterMax(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterMax", "ref", ref);
    NDValidation.validateNumerical("scatterMax", "indices", indices);
    NDValidation.validateNumerical("scatterMax", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterMax(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMax(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMax", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMax", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentMax", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMax(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray clipByValue(INDArray x, INDArray clipValueMin, INDArray clipValueMax) {
    NDValidation.validateNumerical("clipByValue", "x", x);
    NDValidation.validateNumerical("clipByValue", "clipValueMin", clipValueMin);
    NDValidation.validateNumerical("clipByValue", "clipValueMax", clipValueMax);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.clip.ClipByValue(x, clipValueMin, clipValueMax))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterSub(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterSub", "ref", ref);
    NDValidation.validateNumerical("scatterSub", "indices", indices);
    NDValidation.validateNumerical("scatterSub", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterSub(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray scatterDiv(INDArray ref, INDArray indices, INDArray updates) {
    NDValidation.validateNumerical("scatterDiv", "ref", ref);
    NDValidation.validateNumerical("scatterDiv", "indices", indices);
    NDValidation.validateNumerical("scatterDiv", "updates", updates);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.scatter.ScatterDiv(ref, indices, updates))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentSum(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentSum", "data", data);
    NDValidation.validateNumerical("unsortedSegmentSum", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentSum", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentSum(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 21 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMin(INDArray data, INDArray segmentIds, INDArray numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMin", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMin", "segmentIds", segmentIds);
    NDValidation.validateInteger("unsortedSegmentMin", "numSegments", numSegments);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMin(data, segmentIds, numSegments))[0];

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  public INDArray cumprod(INDArray in, boolean exclusive, boolean reverse, long... axis) {
    NDValidation.validateNumerical("cumprod", "in", in);
    Preconditions.checkArgument(axis.length >= 1, "axis has incorrect size/length. Expected: axis.length >= 1, got %s", axis.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.custom.CumProd(in, exclusive, reverse, axis))[0];
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  public INDArray cumsum(INDArray in, boolean exclusive, boolean reverse, long... axis) {
    NDValidation.validateNumerical("cumsum", "in", in);
    Preconditions.checkArgument(axis.length >= 1, "axis has incorrect size/length. Expected: axis.length >= 1, got %s", axis.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.custom.CumSum(in, exclusive, reverse, axis))[0];
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  public INDArray cumprod(INDArray in, long... axis) {
    NDValidation.validateNumerical("cumprod", "in", in);
    Preconditions.checkArgument(axis.length >= 1, "axis has incorrect size/length. Expected: axis.length >= 1, got %s", axis.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.custom.CumProd(in, false, false, axis))[0];
  }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  public INDArray cumsum(INDArray in, long... axis) {
    NDValidation.validateNumerical("cumsum", "in", in);
    Preconditions.checkArgument(axis.length >= 1, "axis has incorrect size/length. Expected: axis.length >= 1, got %s", axis.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.custom.CumSum(in, false, false, axis))[0];
  }

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

  public INDArray argmax(INDArray in, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("argmax", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.indexaccum.custom.ArgMax(in, keepDims, dimensions))[0];
  }

• Read up
  Read up

Similar blocks of code found in 6 locations. Consider refactoring.

Open

  public INDArray argmin(INDArray in, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("argmin", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.indexaccum.custom.ArgMin(in, keepDims, dimensions))[0];
  }

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

  public INDArray variance(INDArray x, boolean biasCorrected, boolean keepDims,
      long... dimensions) {
    NDValidation.validateNumerical("variance", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.summarystats.Variance(x, biasCorrected, keepDims, dimensions));

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

  public INDArray standardDeviation(INDArray x, boolean biasCorrected, boolean keepDims,
      long... dimensions) {
    NDValidation.validateNumerical("standardDeviation", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.summarystats.StandardDeviation(x, biasCorrected, keepDims, dimensions));

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

  public INDArray matchConditionCount(INDArray in, Condition condition, boolean keepDim,
      long... dimensions) {
    NDValidation.validateNumerical("matchConditionCount", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.longer.MatchCondition(in, condition, keepDim, dimensions));

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public INDArray argmin(INDArray in, long... dimensions) {
    NDValidation.validateNumerical("argmin", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.indexaccum.custom.ArgMin(in, false, dimensions))[0];
  }

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public INDArray argmax(INDArray in, long... dimensions) {
    NDValidation.validateNumerical("argmax", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.indexaccum.custom.ArgMax(in, false, dimensions))[0];
  }

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public INDArray mmul(INDArray x, INDArray y, boolean transposeX, boolean transposeY,
      boolean transposeZ) {
    NDValidation.validateNumerical("mmul", "x", x);
    NDValidation.validateNumerical("mmul", "y", y);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.Mmul(x, y, transposeX, transposeY, transposeZ))[0];

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

  public INDArray standardDeviation(INDArray x, boolean biasCorrected, long... dimensions) {
    NDValidation.validateNumerical("standardDeviation", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.summarystats.StandardDeviation(x, biasCorrected, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

  public INDArray matchConditionCount(INDArray in, Condition condition, long... dimensions) {
    NDValidation.validateNumerical("matchConditionCount", "in", in);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.longer.MatchCondition(in, condition, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

  public INDArray variance(INDArray x, boolean biasCorrected, long... dimensions) {
    NDValidation.validateNumerical("variance", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.summarystats.Variance(x, biasCorrected, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray mean(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("mean", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Mean(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray normmax(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("normmax", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.NormMax(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray prod(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("prod", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Prod(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray squaredNorm(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("squaredNorm", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.SquaredNorm(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray norm2(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("norm2", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Norm2(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray min(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("min", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Min(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray sum(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("sum", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Sum(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray norm1(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("norm1", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Norm1(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 28 locations. Consider refactoring.

Open

  public INDArray max(INDArray x, boolean keepDims, long... dimensions) {
    NDValidation.validateNumerical("max", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Max(x, keepDims, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray mean(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("mean", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Mean(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray norm1(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("norm1", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Norm1(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray max(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("max", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Max(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray min(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("min", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Min(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray normmax(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("normmax", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.NormMax(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray sum(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("sum", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Sum(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray norm2(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("norm2", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.Norm2(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray prod(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("prod", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.same.Prod(x, false, dimensions));
  }

• Read up
  Read up

Similar blocks of code found in 27 locations. Consider refactoring.

Open

  public INDArray squaredNorm(INDArray x, long... dimensions) {
    NDValidation.validateNumerical("squaredNorm", "x", x);
    Preconditions.checkArgument(dimensions.length >= 0, "dimensions has incorrect size/length. Expected: dimensions.length >= 0, got %s", dimensions.length);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.floating.SquaredNorm(x, false, dimensions));
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

  public INDArray mmul(INDArray x, INDArray y) {
    NDValidation.validateNumerical("mmul", "x", x);
    NDValidation.validateNumerical("mmul", "y", y);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.reduce.Mmul(x, y, false, false, false))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMean(INDArray data, INDArray segmentIds, int numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMean", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMean", "segmentIds", segmentIds);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMean(data, segmentIds, numSegments))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray sequenceMask(INDArray lengths, INDArray maxLen, DataType dataType) {
    NDValidation.validateNumerical("sequenceMask", "lengths", lengths);
    NDValidation.validateInteger("sequenceMask", "maxLen", maxLen);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.shape.SequenceMask(lengths, maxLen, dataType))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray slice(INDArray input, INDArray begin, INDArray size) {
    NDValidation.validateInteger("slice", "begin", begin);
    NDValidation.validateInteger("slice", "size", size);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.shape.Slice(input, begin, size))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMax(INDArray data, INDArray segmentIds, int numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMax", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMax", "segmentIds", segmentIds);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMax(data, segmentIds, numSegments))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentProd(INDArray data, INDArray segmentIds, int numSegments) {
    NDValidation.validateNumerical("unsortedSegmentProd", "data", data);
    NDValidation.validateNumerical("unsortedSegmentProd", "segmentIds", segmentIds);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentProd(data, segmentIds, numSegments))[0];
  }

• Read up
  Read up

Similar blocks of code found in 14 locations. Consider refactoring.

Open

  public INDArray unsortedSegmentMin(INDArray data, INDArray segmentIds, int numSegments) {
    NDValidation.validateNumerical("unsortedSegmentMin", "data", data);
    NDValidation.validateNumerical("unsortedSegmentMin", "segmentIds", segmentIds);
    return Nd4j.exec(new org.nd4j.linalg.api.ops.impl.transforms.segment.UnsortedSegmentMin(data, segmentIds, numSegments))[0];
  }

• Read up
  Read up