Verifying the legitimacy of the elements in an n-dimensional array

Question

Verifying the legitimacy of the elements in an n-dimensional array

In my journey to create my own Tensor class (n-dimensional arrays) in typescript, I have devised a structure where the data is stored in a 1D array property, and the shape of the data is stored separately for indexing purposes.

My goal is to develop a function similar to numpy.array, which takes in multi-dimensional array data, flattens it into a 1D array, and then extracts the shape.

However, it is crucial for this function to validate if the input array has a consistent shape throughout (often referred to as having a "homogeneous shape").

Example 1

For instance, giving the following input to the function:

data = [
  [[1, 2], [3, 4]],
  [[5, 6], [7, 8]],
]

the expected output would be a tensor with the shape (2, 2, 2) and a flat array of elements [1, 2, 3, ..., 8] representing the data inside the tensor.

Example 2

Conversely, if the input is:

data = [
  [[1], [3, 4]],
  [[5, 6], [7, 8]],
]

the function should fail to validate the input due to the inconsistent shape with a sub-array containing only the element 1.

Example 3

Similarly, when provided with:

data = [
  [[1], 2],
  [3, 4],
]

the function should fail for the same reason, as the sub-array containing 1 is inconsistent with the rest of the data.

While numpy.array is capable of detecting such inconsistencies and raising errors, I am in search of an algorithm or method to achieve the same. Any guidance or assistance in this experimental project would be greatly appreciated.

Note: While I understand that utilizing an existing library for this task would be more efficient, my current endeavor is purely for educational purposes. As I lack extensive knowledge about tensors, any suggestions on where to start or what to learn beforehand would be highly valued.

arrays typescript numpy tensor

Answer 1

Answer №1

This may not be the most efficient solution, but it is functional for an experimental project. The output includes an additional '0' for the dimensions, which represents the inner dimension. You can either remove the first element of the array or handle this case differently. In my opinion, it is reasonable to consider a number as an array with zero dimensions.

/// This code snippet checks if two arrays are equal
function arraysEqual(a: any[], b: any[]) {
  if (a === b) return true;
  if (a == null || b == null) return false;
  if (a.length !== b.length) return false;

  for (var i = 0; i < a.length; ++i) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

function testArray(x: any): [number[], number[]] {
  if (Array.isArray(x)) {
    let lastDim: number[] | undefined = undefined;
    let numbers: number[] = [];
    if (x.length === 0) {
      throw "Empty array";
    }
    for (const el of x) {
      const [d, n] = testArray(el);
      if (lastDim === undefined) {
        lastDim = d;
      }

      if (!arraysEqual(lastDim, d)) {
        throw "Dimensions not equal";
      }
      numbers.push(...n);
    }
    if (lastDim === undefined) {
      throw "Should never happen, but this line makes typescript happy :)";
    }
    lastDim.push(x.length);
    return [lastDim, numbers];
  } else if (typeof x === "number") {
    return [[0], [x]];
  } else {
    throw "Not an array or a number";
  }
}

const data1 = [
  [
    [1, 2],
    [3, 4],
  ],
  [
    [5, 6],
    [7, 8],
  ],
];

console.log(testArray(data1));

const data2 = [
  [[1], [3, 4]],
  [
    [5, 6],
    [7, 8],
  ],
];

try {
  console.log(testArray(data2));
} catch (e) {
  console.error(e);
}

const data3 = [
  [[1], 2],
  [3, 4],
];

try {
  console.log(testArray(data3));
} catch (e) {
  console.error(e);
}

[LOG]: [[0, 2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]] 
[ERR]: "Dimensions not equal" 
[ERR]: "Dimensions not equal"

Answer 2

This may not be the most efficient solution, but it is functional for an experimental project. The output includes an additional '0' for the dimensions, which represents the inner dimension. You can either remove the first element of the array or handle this case differently. In my opinion, it is reasonable to consider a number as an array with zero dimensions.

/// This code snippet checks if two arrays are equal
function arraysEqual(a: any[], b: any[]) {
  if (a === b) return true;
  if (a == null || b == null) return false;
  if (a.length !== b.length) return false;

  for (var i = 0; i < a.length; ++i) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

function testArray(x: any): [number[], number[]] {
  if (Array.isArray(x)) {
    let lastDim: number[] | undefined = undefined;
    let numbers: number[] = [];
    if (x.length === 0) {
      throw "Empty array";
    }
    for (const el of x) {
      const [d, n] = testArray(el);
      if (lastDim === undefined) {
        lastDim = d;
      }

      if (!arraysEqual(lastDim, d)) {
        throw "Dimensions not equal";
      }
      numbers.push(...n);
    }
    if (lastDim === undefined) {
      throw "Should never happen, but this line makes typescript happy :)";
    }
    lastDim.push(x.length);
    return [lastDim, numbers];
  } else if (typeof x === "number") {
    return [[0], [x]];
  } else {
    throw "Not an array or a number";
  }
}

const data1 = [
  [
    [1, 2],
    [3, 4],
  ],
  [
    [5, 6],
    [7, 8],
  ],
];

console.log(testArray(data1));

const data2 = [
  [[1], [3, 4]],
  [
    [5, 6],
    [7, 8],
  ],
];

try {
  console.log(testArray(data2));
} catch (e) {
  console.error(e);
}

const data3 = [
  [[1], 2],
  [3, 4],
];

try {
  console.log(testArray(data3));
} catch (e) {
  console.error(e);
}

[LOG]: [[0, 2, 2, 2], [1, 2, 3, 4, 5, 6, 7, 8]] 
[ERR]: "Dimensions not equal" 
[ERR]: "Dimensions not equal"

Verifying the legitimacy of the elements in an n-dimensional array

Example 1

Example 2

Example 3

Answer №1

Similar questions

What are some best practices for integrating ES2020 into an Angular project?

Converting a JSON array into a single JSON object using Powershell

Ways to transform a nested list to mimic the behavior of a numpy array

What is the process for establishing the default type for an Activity Entity in Microsoft Dynamics?

Unable to execute functions on observable outcomes

Encountered an error during npm installation: Fetch Package Metadata error occurred while attempting to request from http://registry.npmjs.org/concurrently, the cause being a socket hangup

Merging an unspecified number of observables in Rxjs

Performing unit tests in Angular 2 with karma

Learning how to use arrow functions with the `subscribe` function in

How do I retrieve the data returned from the component.ts file in Angular Material's MatTableModule when it is not directly inside the mat-table in the template?

What sets PHP array apart from PHP Constant?

Transforming retrieved data into an array using Node.js

What methods can I use to prevent a JavaScript array from getting filled during page loading?

Formatting HTML Output Using PHP

Creating regex to detect the presence of Donorbox EmbedForm in a web page

Guide on linking enum values with types in TypeScript

JavaScript rearrange array elements

Utilize Angular's ng-repeat directive to iterate through this JSON data structure for implementing user-to

Tabulating Non-Prime Numbers

Using Typescript: Utilizing generic types within the parent class