Array Tests & Improvements (#1335)

* Add array_create, array_create_2d, array_equals, and array_copy
* Remove some old comments I added, arrays already overloaded
* Fix 2d var array constructor
* Add simple arrays tests into math tests

CommandLine/testing/SimpleTests/math_test.sog/create.edl

@@ -185,6 +185,46 @@ gtest_assert_true(point_in_rectangle(-2, -2, -3, -3, -1, -1));
 gtest_assert_true(point_in_rectangle(-3, -3, -3, -3, -1, -1));
 gtest_assert_false(point_in_rectangle(-4, -4, -3, -3, -1, -1));
 
+// Simple array function tests
+var user_array = array_create(5, 555);
+gtest_assert_true(is_array(user_array));
+for (i = 0; i < 5; i += 1) {
+  gtest_assert_eq(user_array[i], 555);
+}
+var user_array_smaller = array_create(3, 555);
+gtest_assert_eq(array_length_1d(user_array_smaller), 3);
+gtest_assert_false(array_equals(user_array, user_array_smaller));
+var user_array_larger = array_create(7, 555);
+gtest_assert_eq(array_length_1d(user_array_larger), 7);
+gtest_assert_false(array_equals(user_array, user_array_larger));
+var user_array_same = array_create(5, 555);
+gtest_assert_eq(array_length_1d(user_array_same), 5);
+gtest_assert_true(array_equals(user_array, user_array_same));
+var user_array_copy = array_create(3, 24);
+var user_array_copy2 = array_create(7, 347);
+array_copy(user_array_same, 0, user_array_copy, 0, 3);
+array_copy(user_array_same, 3, user_array_copy2, 6, 1);
+gtest_assert_eq(user_array_same[0], 24);
+gtest_assert_eq(user_array_same[1], 24);
+gtest_assert_eq(user_array_same[2], 24);
+gtest_assert_eq(user_array_same[3], 347);
+gtest_assert_eq(user_array_same[4], 555);
+
+// Simple 2D array tests
+var user_array_2d = array_create_2d(3, 5, 256);
+gtest_assert_true(is_array(user_array_2d));
+gtest_assert_eq(array_length_2d(user_array_2d, 0), 3);
+gtest_assert_eq(array_length_2d(user_array_2d, 1), 3);
+gtest_assert_eq(array_length_2d(user_array_2d, 2), 3);
+gtest_assert_eq(array_length_2d(user_array_2d, 3), 3);
+gtest_assert_eq(array_length_2d(user_array_2d, 4), 3);
+gtest_assert_eq(array_height_2d(user_array_2d), 5);
+for (i = 0; i < 5; i += 1) {
+  for (j = 0; j < 3; j += 1) {
+    gtest_assert_eq(user_array_2d[i,j], 256);
+  }
+}
+
 // These are common variable names that happen to conflict with Bessel functions.
 j0 = 1;
 y0 = 2;

ENIGMAsystem/SHELL/Universal_System/var4.cpp

@@ -265,12 +265,11 @@ var::operator const variant&() const { return **this; }
 
 var::var() : values(NULL) { initialize(); }
 var::var(variant x) : values(NULL) { initialize(); **this = x; }
-//TODO: Overload var for std::array
-var::var(variant x, size_t length, size_t length2) : values(NULL) {
+var::var(variant x, size_t length, size_t height) : values(NULL) {
   initialize();
-  for (size_t j = 0; j < length2; ++j) {
+  for (size_t j = 0; j < height; ++j) {
     for (size_t i = 0; i < length; ++i) {
-      (*this)(i, j) = x; 
+      (*this)(j, i) = x; 
     }
   }
 }

ENIGMAsystem/SHELL/Universal_System/var4.h

@@ -209,8 +209,7 @@ struct var
 
   var();
   var(const var&);
-  //TODO: Overload var for std::array
-  var(variant value, size_t length, size_t length2 = 1);
+  var(variant value, size_t length, size_t height = 1);
   types_extrapolate_alldec(var)
 
   types_extrapolate_alldec(variant& operator=)

ENIGMAsystem/SHELL/Universal_System/var_array.cpp

@@ -30,6 +30,20 @@
 
 namespace enigma_user {
 
+var array_create(size_t size, variant value) { return var(value, size); }
+var array_create_2d(size_t length, size_t height, variant value) { return var(value, length, height); }
+bool array_equals(const var& arr1, const var& arr2) {
+  if (arr1.array_len() != arr2.array_len()) return false;
+  for (size_t i = 0; i < arr1.array_len(); i++) {
+    if (arr1[i] != arr2[i]) return false;
+  }
+  return true;
+}
+void array_copy(var& dest, size_t dest_index, var& src, size_t src_index, size_t length) {
+  for (size_t i = 0; i < length; i++) {
+    dest[dest_index + i] = src[src_index + i];
+  }
+}
 int array_length_1d(const var& v) { return v.array_len(); }
 int array_length_2d(const var& v, int n) { return v.array_len(n); }
 int array_height_2d(const var& v) { return v.array_height(); }
@@ -38,4 +52,4 @@ bool is_array(const var& v) {
   return (v.array_height() > 1) || (v.array_len() > 1);
 }
 
-}  // namespace enigma_user
+}  // namespace enigma_user

ENIGMAsystem/SHELL/Universal_System/var_array.h

@@ -31,6 +31,10 @@
 #include "var4.h"
 
 namespace enigma_user {
+var array_create(size_t size, variant value=0);
+var array_create_2d(size_t length, size_t height, variant value=0);
+bool array_equals(const var& arr1, const var& arr2);
+void array_copy(var& dest, size_t dest_index, var& src, size_t src_index, size_t length);
 int array_length_1d(const var& v);
 int array_length_2d(const var& v, int n);
 int array_height_2d(const var& v);