Implement cast

.eslintrc.js

@@ -7,6 +7,7 @@ module.exports = {
     'chai': 'readonly',
     'BigInt': 'readonly',
     'BigInt64Array': 'readonly',
+    'BigUint64Array': 'readonly',
   },
   rules: {
     'semi': 'error',

src/cast.js

@@ -0,0 +1,46 @@
+'use strict';
+
+import {Tensor} from '../src/lib/tensor.js';
+
+/**
+ * Cast each element in the input tensor to the target data type.
+ * @param {Tensor} input
+ * @return {Tensor}
+ */
+
+export function cast(input, type) {
+  let outputArray;
+  switch (type) {
+    case 'float32':
+      outputArray = new Float32Array(input.data);
+      break;
+    case 'int32':
+      outputArray = new Int32Array(input.data);
+      break;
+    case 'uint32':
+      outputArray = new Uint32Array(input.data);
+      break;
+    case 'int64':
+      outputArray = new BigInt64Array(Array.from(input.data, (num) => BigInt(Math.round(num))));
+      break;
+    case 'int8':
+      outputArray = new Int8Array(input.data);
+      break;
+    case 'uint8':
+      outputArray = new Uint8Array(input.data);
+      break;
+    case 'float16':
+      // todo
+      throw new Error('Unsupported output type: float16' );
+    // case 'uint64':
+    //   // todo
+    //   throw new Error('Unsupported output type: uint64' );
+    // case 'uint64':
+    //   outputArray = new BigUint64Array(Array.from(input.data, (num) => BigInt(Math.round(num))));
+    //   break;
+    default:
+      throw new Error('Unsupported output type: ' + type);
+  }
+  const output = new Tensor(input.shape, outputArray);
+  return output;
+}

test/cast_test.js

@@ -0,0 +1,111 @@
+'use strict';
+
+import {Tensor} from '../src/lib/tensor.js';
+import {cast} from '../src/cast.js';
+import * as utils from './utils.js';
+
+describe('test cast', function() {
+  function testCast(input, type, expected) {
+    const tensorInput = new Tensor(input.shape, input.data);
+    const outputTensor = cast(tensorInput, type);
+    utils.checkShape(outputTensor, expected.shape);
+    utils.checkValue(outputTensor, expected.data);
+  }
+
+  it('cast float32', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.2100000381469727, 1234, -1234,
+      ],
+    };
+    testCast(input, 'float32', expected);
+  });
+
+  it('cast int32', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        0, 0, 3, 1234, -1234,
+      ],
+    };
+    testCast(input, 'int32', expected);
+  });
+
+
+  it('cast uint32', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        0, 0, 3, 1234, 4294966062,
+      ],
+    };
+    testCast(input, 'uint32', expected);
+  });
+
+  it('cast int64', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        0n, 0n, 3n, 1234n, -1234n,
+      ],
+    };
+    testCast(input, 'int64', expected);
+  });
+
+  it('cast int8', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        0, 0, 3, -46, 46,
+      ],
+    };
+    testCast(input, 'int8', expected);
+  });
+
+  it('cast uint8', function() {
+    const input = {
+      shape: [5],
+      data: [
+        -0.25, 0.25, 3.21, 1234, -1234,
+      ],
+    };
+    const expected = {
+      shape: [5],
+      data: [
+        0, 0, 3, 210, 46,
+      ],
+    };
+    testCast(input, 'uint8', expected);
+  });
+});