[ops ] guard shape for decimal and negative values

tfjs-core/src/ops/broadcast_to.ts

@@ -22,6 +22,7 @@ import {Tensor} from '../tensor';
 import {NamedTensorMap} from '../tensor_types';
 import {convertToTensor} from '../tensor_util_env';
 import {Rank, ShapeMap, TensorLike} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {clone} from './clone';
 import {op} from './operation';
@@ -50,6 +51,8 @@ function broadcastTo_<R extends Rank>(
     throw new Error(`broadcastTo(): Invalid broadcast shape [${shape}].`);
   }
 
+  assertNonNegativeIntegerDimensions(shape);
+
   if (shape.length < input.rank) {
     throw new Error(`broadcastTo(): shape.length=${shape.length} < input.rank=${
         input.rank}.`);

tfjs-core/src/ops/broadcast_to_test.ts

@@ -73,4 +73,9 @@ describeWithFlags('broadcastTo', ALL_ENVS, () => {
 
     expectArraysClose(await df(a).array(), await dh(a).array());
   });
+
+  it('should throw error when shape is not integer', () => {
+    const a = tf.scalar(4.2);
+    expect(() => tf.broadcastTo(a, [2, 2.22, 3.33])).toThrow();
+  });
 });

tfjs-core/src/ops/fill.ts

@@ -20,6 +20,7 @@ import {Fill, FillAttrs} from '../kernel_names';
 import {NamedAttrMap} from '../kernel_registry';
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 /**
  * Creates a `tf.Tensor` filled with a scalar value.
@@ -37,6 +38,8 @@ import {DataType, Rank, ShapeMap} from '../types';
  */
 function fill<R extends Rank>(
     shape: ShapeMap[R], value: number|string, dtype?: DataType): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
+
   const attrs: FillAttrs = {shape, value, dtype};
 
   return ENGINE.runKernel(Fill, {}, attrs as {} as NamedAttrMap);

tfjs-core/src/ops/fill_test.ts

@@ -78,4 +78,8 @@ describeWithFlags('fill', ALL_ENVS, () => {
     expect(a.shape).toEqual([2, 1, 2, 1, 2]);
     expectArraysClose(await a.data(), [2, 2, 2, 2, 2, 2, 2, 2]);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.fill([2, 2.22, 3.33], 1)).toThrow();
+  });
 });

tfjs-core/src/ops/ones.ts

@@ -19,7 +19,7 @@ import {ENGINE} from '../engine';
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
 import {makeOnesTypedArray, sizeFromShape} from '../util';
-
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 import {complex} from './complex';
 import {zeros} from './zeros';
 
@@ -38,6 +38,7 @@ import {zeros} from './zeros';
  */
 export function ones<R extends Rank>(
     shape: ShapeMap[R], dtype: DataType = 'float32'): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   if (dtype === 'complex64') {
     const real = ones(shape, 'float32');
     const imag = zeros(shape, 'float32');

tfjs-core/src/ops/ones_test.ts

@@ -131,4 +131,8 @@ describeWithFlags('ones', ALL_ENVS, () => {
     expect(a.shape).toEqual([3, 2, 1, 1]);
     expectArraysEqual(await a.data(), [1, 1, 1, 1, 1, 1]);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.ones([2, 2.22, 3.33])).toThrow();
+  });
 });

tfjs-core/src/ops/rand.ts

@@ -19,6 +19,7 @@ import {ENGINE} from '../engine';
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
 import {sizeFromShape} from '../util';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {op} from './operation';
 
@@ -36,6 +37,7 @@ import {op} from './operation';
 function rand_<R extends Rank>(
     shape: ShapeMap[R], randFunction: () => number,
     dtype?: DataType): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   const size = sizeFromShape(shape);
   let values = null;
   if (dtype == null || dtype === 'float32') {

tfjs-core/src/ops/rand_test.ts

@@ -131,6 +131,11 @@ describeWithFlags('rand', ALL_ENVS, () => {
     expect(result.dtype).toBe('bool');
     expectValuesInRange(await result.data(), 0, 1);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.rand([2, 2.22, 3.33], () => util.randUniform(0, 2)))
+        .toThrow();
+  });
 });
 
 function isFloat(n: number): boolean {

tfjs-core/src/ops/random_gamma.ts

@@ -17,6 +17,7 @@
 
 import {Tensor} from '../tensor';
 import {Rank, ShapeMap} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {buffer} from './buffer';
 import {op} from './operation';
@@ -41,6 +42,7 @@ import {RandGamma} from './rand_util';
 function randomGamma_<R extends Rank>(
     shape: ShapeMap[R], alpha: number, beta = 1,
     dtype: 'float32'|'int32' = 'float32', seed?: number): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   if (beta == null) {
     beta = 1;
   }

tfjs-core/src/ops/random_gamma_test.ts

@@ -122,4 +122,8 @@ describeWithFlags('randomGamma', ALL_ENVS, () => {
     expect(result.dtype).toBe('int32');
     expectValuesInRange(await result.data(), GAMMA_MIN, GAMMA_MAX);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.randomGamma([2, 2.22, 3.33], 2, 2)).toThrow();
+  });
 });

tfjs-core/src/ops/random_normal.ts

@@ -17,6 +17,7 @@
 
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {buffer} from './buffer';
 import {op} from './operation';
@@ -40,6 +41,7 @@ import {MPRandGauss} from './rand_util';
 function randomNormal_<R extends Rank>(
     shape: ShapeMap[R], mean = 0, stdDev = 1, dtype?: 'float32'|'int32',
     seed?: number): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   if (dtype != null && (dtype as DataType) === 'bool') {
     throw new Error(`Unsupported data type ${dtype}`);
   }

tfjs-core/src/ops/random_normal_test.ts

@@ -138,4 +138,9 @@ describeWithFlags('randomNormal', ALL_ENVS, () => {
     jarqueBeraNormalityTest(await result.data());
     expectArrayInMeanStdRange(await result.data(), 0, 2, EPSILON);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.randomNormal([2, 2.22, 3.33], 0, 2, 'int32', SEED))
+        .toThrow();
+  });
 });

tfjs-core/src/ops/random_uniform.ts

@@ -17,6 +17,7 @@
 
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {buffer} from './buffer';
 import {op} from './operation';
@@ -45,6 +46,7 @@ import {UniformRandom} from './rand_util';
 function randomUniform_<R extends Rank>(
     shape: ShapeMap[R], minval = 0, maxval = 1, dtype: DataType = 'float32',
     seed?: number|string): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   const res = buffer(shape, dtype);
   const random = new UniformRandom(minval, maxval, null, seed);
   for (let i = 0; i < res.values.length; i++) {

tfjs-core/src/ops/random_uniform_test.ts

@@ -154,4 +154,8 @@ describeWithFlags('randomUniform', ALL_ENVS, () => {
     expect(result.dtype).toBe('bool');
     expectValuesInRange(await result.data(), 0, 1);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.randomUniform([2, 2.22, 3.33], 0, 1)).toThrow();
+  });
 });

tfjs-core/src/ops/scatter_nd.ts

@@ -22,6 +22,7 @@ import {Tensor} from '../tensor';
 import {NamedTensorMap} from '../tensor_types';
 import {convertToTensor} from '../tensor_util_env';
 import {Rank, ShapeMap, TensorLike} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {op} from './operation';
 import * as scatter_nd_util from './scatter_nd_util';
@@ -48,6 +49,7 @@ import * as scatter_nd_util from './scatter_nd_util';
 function scatterND_<R extends Rank>(
     indices: Tensor|TensorLike, updates: Tensor|TensorLike,
     shape: ShapeMap[R]): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   const $indices = convertToTensor(indices, 'indices', 'scatterND', 'int32');
   const $updates = convertToTensor(updates, 'updates', 'scatterND');
   scatter_nd_util.validateInput($updates, $indices, shape);

tfjs-core/src/ops/scatter_nd_test.ts

@@ -149,4 +149,11 @@ describeWithFlags('scatterND', ALL_ENVS, () => {
     const shape = [5, 3];
     expect(() => tf.scatterND(indices, updates, shape)).toThrow();
   });
+
+  it('should throw error when shape is not integer', () => {
+    const indices = [0, 4, 2];
+    const updates = [100, 101, 102];
+    const shape = [5.55, 2.22];
+    expect(() => tf.scatterND(indices, updates, shape)).toThrow();
+  });
 });

tfjs-core/src/ops/sparse_to_dense.ts

@@ -23,6 +23,7 @@ import {Scalar, Tensor} from '../tensor';
 import {NamedTensorMap} from '../tensor_types';
 import {convertToTensor} from '../tensor_util_env';
 import {Rank, ScalarLike, ShapeMap, TensorLike} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {op} from './operation';
 
@@ -67,6 +68,8 @@ import {op} from './operation';
 function sparseToDense_<R extends Rank>(
     sparseIndices: Tensor|TensorLike, sparseValues: Tensor|TensorLike,
     outputShape: ShapeMap[R], defaultValue: Scalar|ScalarLike = 0): Tensor<R> {
+  assertNonNegativeIntegerDimensions(outputShape);
+
   const $sparseIndices =
       convertToTensor(sparseIndices, 'sparseIndices', 'sparseToDense', 'int32');
   const $sparseValues = convertToTensor(

tfjs-core/src/ops/sparse_to_dense_test.ts

@@ -149,4 +149,12 @@ describeWithFlags('sparseToDense', ALL_ENVS, () => {
     expect(() => tf.sparseToDense(indices, values, shape, defaultValue))
         .toThrow();
   });
+
+  it('should throw error when shape is not integer', () => {
+    const indices = [[0, 1], [1, 1]];
+    const values = [5, 6];
+    const shape = [2.22, 2.22];
+    expect(() => tf.sparseToDense(indices, values, shape, tf.scalar(1)))
+        .toThrow();
+  });
 });

tfjs-core/src/ops/truncated_normal.ts

@@ -17,6 +17,7 @@
 
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
+import {assertNonNegativeIntegerDimensions} from '../util_base';
 
 import {buffer} from './buffer';
 import {op} from './operation';
@@ -45,6 +46,7 @@ import {MPRandGauss} from './rand_util';
 function truncatedNormal_<R extends Rank>(
     shape: ShapeMap[R], mean = 0, stdDev = 1, dtype?: 'float32'|'int32',
     seed?: number): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   if (dtype != null && (dtype as DataType) === 'bool') {
     throw new Error(`Unsupported data type $ { dtype }`);
   }

tfjs-core/src/ops/truncated_normal_test.ts

@@ -124,4 +124,9 @@ describeWithFlags('truncatedNormal', ALL_ENVS, () => {
     assertTruncatedValues(await result.data(), 0, 5);
     expectArrayInMeanStdRange(await result.data(), 0, 5, EPSILON);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.truncatedNormal([5.55, 3.33, 2.22], 0, 5, 'int32', SEED))
+        .toThrow();
+  });
 });

tfjs-core/src/ops/zeros.ts

@@ -18,7 +18,7 @@
 import {ENGINE} from '../engine';
 import {Tensor} from '../tensor';
 import {DataType, Rank, ShapeMap} from '../types';
-import {makeZerosTypedArray, sizeFromShape} from '../util';
+import {assertNonNegativeIntegerDimensions, makeZerosTypedArray, sizeFromShape} from '../util';
 
 import {complex} from './complex';
 
@@ -37,6 +37,7 @@ import {complex} from './complex';
  */
 export function zeros<R extends Rank>(
     shape: ShapeMap[R], dtype: DataType = 'float32'): Tensor<R> {
+  assertNonNegativeIntegerDimensions(shape);
   if (dtype === 'complex64') {
     const real = zeros(shape, 'float32');
     const imag = zeros(shape, 'float32');

tfjs-core/src/ops/zeros_test.ts

@@ -131,4 +131,8 @@ describeWithFlags('zeros', ALL_ENVS, () => {
     expect(a.shape).toEqual([3, 2, 1, 1]);
     expectArraysEqual(await a.data(), [0, 0, 0, 0, 0, 0]);
   });
+
+  it('should throw error when shape is not integer', () => {
+    expect(() => tf.zeros([2, 2.22, 3.33])).toThrow();
+  });
 });