Implement tile

src/lib/validate-input.js

@@ -620,3 +620,16 @@ export function validateTriangularParams(input, {diagonal = 0} = {}) {
     throw new Error(`The diagonal should be an integer.`);
   }
 }
+
+export function validateTileParams(input, repetitions) {
+  const inputRank = input.rank;
+  const repetitionsLength = repetitions.length;
+  if (repetitionsLength != inputRank ) {
+    throw new Error(
+        `The repetitions length ${repetitionsLength} is not equal to rank ${inputRank}.`);
+  }
+  if (!repetitions.every((v) => Number.isInteger(v) && v > 0)) {
+    throw new Error(
+        `Invalid repetitions ${repetitions} - it should be an Array of positive integers.`);
+  }
+}

src/tile.js

@@ -0,0 +1,28 @@
+'use strict';
+
+import {Tensor, sizeOfShape} from './lib/tensor.js';
+import {validateTileParams} from './lib/validate-input.js';
+
+/**
+ * Represents the tile operation that repeats a tensor the given number of times along each axis.
+ * @param {Tensor} input
+ * @param {Array} repetitions
+ * @return {Tensor}
+ */
+export function tile(input, repetitions) {
+  validateTileParams(...arguments);
+  const outputShape = input.shape.map((size, index) => {
+    return size * repetitions[index];
+  });
+  const output = new Tensor(outputShape);
+  for (let outputIndex = 0; outputIndex < sizeOfShape(outputShape); ++outputIndex) {
+    const loc = output.locationFromIndex(outputIndex);
+    const selectedInputLoc = loc.slice();
+    for (let i = 0; i < loc.length; ++i) {
+      selectedInputLoc[i] = loc[i] % input.shape[i];
+    }
+    const inputValue = input.getValueByLocation(selectedInputLoc);
+    output.setValueByIndex(outputIndex, inputValue);
+  }
+  return output;
+}

test/tile_test.js

@@ -0,0 +1,52 @@
+'use strict';
+
+import {tile} from '../src/tile.js';
+import {Tensor} from '../src/lib/tensor.js';
+import * as utils from './utils.js';
+
+describe('test tile', function() {
+  function testTile(input, repetitions, expected) {
+    const tensor = new Tensor(input.shape, input.data);
+    const outputTensor = tile(tensor, repetitions);
+    utils.checkShape(outputTensor, expected.shape);
+    utils.checkValue(outputTensor, expected.data);
+  }
+
+  it('tile 1D', function() {
+    const input = {
+      shape: [4],
+      data: [
+        1, 2, 3, 4,
+      ],
+    };
+    const repetitions = [2];
+    const expected = {
+      shape: [8],
+      data: [
+        1, 2, 3, 4, 1, 2, 3, 4,
+      ],
+    };
+    testTile(input, repetitions, expected);
+  });
+
+  it('tile 2D', function() {
+    const input = {
+      shape: [2, 2],
+      data: [
+        1, 2,
+        3, 4,
+      ],
+    };
+    const repetitions = [2, 3];
+    const expected = {
+      shape: [4, 6],
+      data: [
+        1, 2, 1, 2, 1, 2,
+        3, 4, 3, 4, 3, 4,
+        1, 2, 1, 2, 1, 2,
+        3, 4, 3, 4, 3, 4,
+      ],
+    };
+    testTile(input, repetitions, expected);
+  });
+});