ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test.h

@@ -38,6 +38,13 @@
 #include "ndtypes.h"
 
 
+
+#define XSTRINGIZE(v) #v
+#define STRINGIZE(v) XSTRINGIZE(v)
+
+#define loc() __FILE__ ":" STRINGIZE(__LINE__)
+
+
 typedef struct {
     const char *input;
     const char *indented;
@@ -50,12 +57,24 @@ typedef struct {
 } match_testcase_t;
 
 typedef struct {
+    const char *t1;
+    const char *t2;
+    const char *expected;
+} unify_testcase_t;
+
+typedef struct {
+    const char *loc;
+    bool success;
+
     const char *signature;
-    const char *in[128];
-    const char *out[128];
-    const char *broadcast[128];
+    const char *args[NDT_MAX_ARGS];
+    const char *kwargs[NDT_MAX_ARGS];
+
     int outer_dims;
-    bool success;
+    int nin;
+    int nout;
+    int nargs;
+    const char *types[NDT_MAX_ARGS];
 } typecheck_testcase_t;
 
 typedef struct {
@@ -72,6 +91,7 @@ extern const indent_testcase_t indent_tests[];
 extern const char *typedef_tests[];
 extern const char *typedef_error_tests[];
 extern const match_testcase_t match_tests[];
+extern const unify_testcase_t unify_tests[];
 extern const typecheck_testcase_t typecheck_tests[];
 extern const numba_testcase_t numba_tests[];
 extern const char *buffer_tests[];

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_array.c

@@ -75,7 +75,7 @@ int
 test_array(void)
 {
     ndt_context_t *ctx;
-    ndt_t *t;
+    const ndt_t *t;
 
     ctx = ndt_context_new();
     if (ctx == NULL) {
@@ -105,7 +105,7 @@ test_array(void)
         fprintf(stderr, "test_array (1 test case)\n");
     }
 
-    ndt_del(t);
+    ndt_decref(t);
     ndt_context_del(ctx);
 
     return 0;

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_buffer.c

@@ -42,7 +42,7 @@ const char *buffer_tests[] = {
   "H", "I", "L", "Q",
   "n", "N",
   "e", "f", "d",
-  "E", "F", "D",
+  "Ze", "Zf", "Zd",
   "s", "100s",
   "T{b:a:100s:b:}",
 
@@ -52,21 +52,21 @@ const char *buffer_tests[] = {
   "(2,3)b",
   "(0,2,0)B",
   "(1,2,3,4)h",
-  "(2,3,10)F",
-  "(20,2,100)D",
+  "(2,3,10)Zf",
+  "(20,2,100)Zd",
   "(10,2)s",
   "(10,2)100s",
   "(10,2)T{b:a:100s:b:}",
   "(10,2)T{b:a:100s:b:}",
 
-  "T{T{F:foo:(2,3)L:bar:}:a:100s:b:}",
+  "T{T{Zf:foo:(2,3)L:bar:}:a:100s:b:}",
 
   "f -> f",
   "ff -> f",
   "fc -> f",
-  "F -> Q",
+  "Zf -> Q",
 
-  "T{b:a:100s:b:} -> T{T{F:foo:(2,3)L:bar:}:a:100s:b:}",
+  "T{b:a:100s:b:} -> T{T{Zf:foo:(2,3)L:bar:}:a:100s:b:}",
 
    NULL
 };
@@ -83,9 +83,9 @@ const char *buffer_roundtrip_tests[] = {
   "=e", "<e", ">e",
   "=f", "<f", ">f",
   "=d", "<d", ">d",
-  "=E", "<E", ">E",
-  "=F", "<F", ">F",
-  "=D", "<D", ">D",
+  "=Ze", "<Ze", ">Ze",
+  "=Zf", "<Zf", ">Zf",
+  "=Zd", "<Zd", ">Zd",
 
   "(2)=Q",
   "(2)<Q",
@@ -98,16 +98,16 @@ const char *buffer_roundtrip_tests[] = {
   "(2,3,4)>Q",
 
   "T{=b:a:100s:b:}",
-  "T{T{=F:foo:(2,3)=I:bar:}:a:100s:b:}",
+  "T{T{=Zf:foo:(2,3)=I:bar:}:a:100s:b:}",
 
    NULL
 };
 
 const char *buffer_error_tests[] = {
   "&",
-  "Ze",
-  "Zf",
-  "Zd",
+  "E",
+  "F",
+  "D",
   "O", "O",
   "T{O:a:100O:b:}",
 
@@ -131,7 +131,7 @@ const char *buffer_error_tests[] = {
   "(10,2)T{b:a:100s:b:{",
   "(10,2)T{b:a:100s:b:}}",
 
-  "T{T{F:foo:(2,3)%:bar:}:a:100s:b:}",
+  "T{T{Zf:foo:(2,3)%:bar:}:a:100s:b:}",
 
    NULL
 };

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_match.c

@@ -177,23 +177,23 @@ const match_testcase_t match_tests[] = {
     "?bool",
     1 },
 
-  { "10 * Signed",
-    "10 * Signed",
+  { "10 * signed",
+    "10 * signed",
     0 },
 
-  { "10 * Signed",
+  { "10 * signed",
     "10 * int32",
     1 },
 
-  { "Signed",
-    "Signed",
+  { "signed",
+    "signed",
     0 },
 
-  { "Signed",
+  { "signed",
     "int64",
     1 },
 
-  { "?Signed",
+  { "?signed",
     "?int16",
     1 },
 
@@ -206,7 +206,7 @@ const match_testcase_t match_tests[] = {
     1 },
 
   { "?int8",
-    "?Signed",
+    "?signed",
     0 },
 
   { "10 * int16",
@@ -245,20 +245,20 @@ const match_testcase_t match_tests[] = {
     "?int64",
     1 },
 
-  { "10 * Unsigned",
+  { "10 * unsigned",
     "10 * uint16",
     1 },
 
-  { "10 * Unsigned",
+  { "10 * unsigned",
     "10 * uint8",
     1 },
 
-  { "Unsigned",
-    "Unsigned",
+  { "unsigned",
+    "unsigned",
     0 },
 
-  { "?Unsigned",
-    "?Unsigned",
+  { "?unsigned",
+    "?unsigned",
     0 },
 
   { "10 * uint8",
@@ -309,11 +309,11 @@ const match_testcase_t match_tests[] = {
     "?uint64",
     1 },
 
-  { "10 * Float",
-    "10 * Float",
+  { "10 * float",
+    "10 * float",
     0 },
 
-  { "10 * Float",
+  { "10 * float",
     "10 * float64",
     1 },
 
@@ -325,30 +325,22 @@ const match_testcase_t match_tests[] = {
     "?float64",
     1 },
 
-  { "10 * Complex",
+  { "10 * complex",
     "10 * complex128",
     1 },
 
-  { "10 * Complex",
+  { "10 * complex",
     "10 * complex64",
     1 },
 
-  { "Complex",
-    "Complex",
+  { "complex",
+    "complex",
     0 },
 
-  { "Complex",
+  { "complex",
     "complex128",
     1 },
 
-  { "?Complex",
-    "?X",
-    0 },
-
-  { "?X",
-    "?Complex",
-    0 },
-
   { "10 * complex64",
     "10 * complex64",
     1 },
@@ -2391,6 +2383,16 @@ const match_testcase_t match_tests[] = {
   { "... * F[N * 2 * float64]",
     "!10 * 3 * 2 * float64", 0 },
 
+  /* array... */
+  { "array... of float64",
+    "2 * 3 * float64", 0 },
+
+  { "array... of float64",
+    "array of float64", 1 },
+
+  { "array... of float64",
+    "array of array of float64", 1 },
+
   /* END MANUALLY GENERATED */
 
   { NULL, NULL, 0 }

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_parse.c

@@ -45,6 +45,8 @@ const char *parse_tests[] = {
   "10 * L * Any",
   "10 * 10 * L * Any",
   "var * Any",
+  "array of Any",
+  "array of array of Any",
   "... * Any",
   "10 * Any",
   "Any",
@@ -210,6 +212,8 @@ const char *parse_tests[] = {
   "10 * (Any, ...)",
   "(Any, ...)",
   "10 * {...}",
+  "10 * Float of float64",
+  "10 * Float of float64 | Int of int8",
   "{...}",
   "10 * {a: Any}",
   "{a: Any}",
@@ -255,19 +259,26 @@ const char *parse_tests[] = {
   "1286044356 * LbR6JPFI * 2096958782 * uint8",
   "categorical(-507014936.36, -25910, 'xM3Mys0XqH', 4265882500)",
   "var * var * FixedBytesKind",
+  "array of FixedBytesKind",
+  "array of array of FixedBytesKind",
   "var * var * var * fixed_bytes(size=2816010912, align=16)",
+  "array of fixed_bytes(size=2816010912, align=16)",
   "36 * 16 * fixed_bytes(size=912328236, align=2)",
   "var * var * float64",
+  "array of float64",
   "var * var * var * ZcTmBXnKPi",
+  "array of ZcTmBXnKPi",
   "categorical('omhwkoWVWw', 43, 946986991)",
   "var * float32",
   "var * var * var * uint16",
   "var * var * var * ScalarKind",
+  "array of ScalarKind",
   "fixed_bytes(size=280180380, align=2)",
   "fixed_string(1901614748, 'utf-32')",
   "var * M7",
   "var * bytes(align=2)",
   "var * var * ULy8(char)",
+  "array of ULy8(char)",
   "fixed_bytes(size=1882259744, align=16)",
   "categorical(-136747211.015, -58, -83)",
   "3739637665 * 1476113530 * 1701021063 * IKd * 450514382 * WXn",
@@ -275,6 +286,7 @@ const char *parse_tests[] = {
   "var * R8KFFEabJ",
   "var * QoFb",
   "var * fixed_string(1233383142, 'utf-32')",
+  "array of fixed_string(1233383142, 'utf-32')",
   "fixed_bytes(size=2882797968, align=4)",
   "fixed_bytes(size=1233209904, align=8)",
   "WhRsMHHXYp(categorical(145))",
@@ -299,6 +311,7 @@ const char *parse_tests[] = {
   "(int32, float64) -> int32",
   "int32, float64 -> int32",
   "(...) -> int32",
+  "void -> float32",
 
   "10 * defined_t",
   "defined_t",
@@ -306,6 +319,12 @@ const char *parse_tests[] = {
   "10 * foo_t",
   "foo_t",
 
+  /* bfloat16 */
+  "10 * bfloat16",
+
+  /* bcomplex32 */
+  "10 * bcomplex32",
+
   /* Half-float */
   "10 * float16",
   "10 * complex32",
@@ -326,6 +345,14 @@ const char *parse_tests[] = {
   "var(offsets=[0,10]) * var(offsets=[0,1,3,6,10,15,21,28,36,45,55]) * float64",
   "var(offsets=[0,2]) * var(offsets=[0,3,7]) * var(offsets=[0,5,11,18,26,35,45,56]) * float64",
 
+  /* Tagged unions */
+  "2 * 3  * ThisRecord of {first: (int64, complex128), second: string}",
+  "2 * 3  * ThisRecord of {first: (int64, complex128), second: string} | ThatTuple of (bytes, string)",
+  "2 * 3  * Int of int64 | ThisRecord of {first: (int64, complex128), second: string} | ThatTuple of (bytes, string)",
+  "array of Int of int64 | ThisRecord of {first: (int64, complex128), second: uint8} | ThatTuple of (float64, float64)",
+
+  "fixed(shape=10) * complex128",
+
   /* Short ref notation */
   "&float64",
   "&2 * 10 * {a: (&int64, &float64)}",
@@ -334,14 +361,24 @@ const char *parse_tests[] = {
   "!2 * 10 * float16",
   "!2 * 10 * {a: !2 * 10 * float16}",
   "!2 * 10 * {a: !2 * 10 * float16}",
+  "!2 * 10 * bfloat16",
+  "!2 * 10 * {a: !2 * 10 * bfloat16}",
+  "!2 * 10 * {a: !2 * 10 * bfloat16}",
   "!2 * 10 * {a: !2 * 10 * (int64, string)}",
 
+  /* Nested variable dimensions */
+  "var(offsets=[0, 2]) * var(offsets=[0,4,10]) * (var(offsets=[0,2]) * var(offsets=[0,3,5]) * float32, int64)",
+
   "2 * N * {a: !2 * 10 * (int64, string)}",
 
   /* Overflow */
   "9223372036854775807 * uint8",
   "1 * 1 * 9223372036854775807 * uint8",
 
+  /* var..., array... */
+  "var... * (int8, int64)",
+  "array... of (int8, int64)",
+
   /* END MANUALLY GENERATED */
 
    NULL

data/ext/ruby_ndtypes/ndtypes/libndtypes/tests/test_parse_error.c

@@ -396,6 +396,7 @@ const char *parse_error_tests[] = {
   "?[10 * 10 $ X * Any$",
   "?[10 * 10 $ X * Any$",
   "$var * Any",
+  "$array of Any",
   "=var * Any",
   "$[var * Any]",
   "xxx[var * Any]",
@@ -15925,6 +15926,17 @@ const char *parse_error_tests[] = {
   "?=10 * {x: int64$ a: Any}]",
   "?[10 * {x: int64$ a: Any}$",
   "?[10 * {x: int64$ a: Any}$",
+  "?10 * $Tag of int64",
+  "?10 * Tag $of int64",
+  "?10 * Tag of $int64",
+  "?10 * Tag of int64$",
+  "?10 * Tag of int64$",
+  "?10 * A of int64 $| B of float64",
+  "?10 * A of int64 | $B of float64",
+  "?10 * A of int64 | B $of float64",
+  "?10 * A of int64 | B of $float64",
+  "?10 * A of int64 | B of float64$",
+  "?10 * A of int64 | B of float64$",
   "{x: int64$ a: Any}",
   "?{x: int64$ a: Any}",
   "?({x: int64$ a: Any})",
@@ -27736,10 +27748,13 @@ const char *parse_error_tests[] = {
   "fixed_bytes(1342281638, align=xxx)",
   "Y5vtk * var * 905934102 * 1310846899 * fixed[3359714476] * LKgwlEDf * 2822334059 * ; PKI_8Ob8(fixed_string(795133707))",
   "?(E00Lr_HMM * ... * UAzC * var * M4nJaK * , var * var * 1002912577 * PZPD)",
+  "?(E00Lr_HMM * ... * UAzC * array of M4nJaK * , array of array of 1002912577 * PZPD)",
   "?ref(fixed_string(3865363101, 'ucs-10'))",
   "fixed[3622391868] * SUc9IusL * CaPaWth4m * CEwSPY_6Z * HPW * SbvgP * 29709a97707 * 1300296096 * Fixed * VA8O",
   "fixed[1603107638)] * 2764230114 * IRXLe * Odlw6RSx * ... * Fixed * var * 2484716214 * ScalarKind",
+  "fixed[1603107638)] * 2764230114 * IRXLe * Odlw6RSx * ... * Fixed * array of 2484716214 * ScalarKind",
   "ZmQxcy * var * 1098824011 * var * var * (,,,)",
+  "ZmQxcy * array of 1098824011 of array of array * (,,,)",
   "ref(?x1869144321 * Y3_Dm0 * int32)",
   "categorical[\"a\", 1619552300, 490620000000000000000000000000000000000000, 18772, -84, 'l']",
   "?fixed[2889099917] * ... * var * JgdIXy5M * var * Wr2[categorical['gLsA7BM43V', 16460]]",
@@ -27747,6 +27762,7 @@ const char *parse_error_tests[] = {
   "?var * Fixed * FdN_HERKv * 4204012258 * var * fixed[233758212000000000000000000000000000] * Fixed * FixedBytesKind",
   "?categorical[30987, -16536, -270032755.642, -189, -823800099]",
   "?Fixed * 1998811088 * var * var * var * var * bytes(align=-58)",
+  "?Fixed * 1998811088 * array of array of array of array of bytes(align=-58)",
   "257051452 * QRgi * Fixed * 4147849906 * var * P4h8i8 * var * 3924618173 * fixed[207255421] * int100",
   "categorical[408786241.474, 2840608325, 44038, 1763886348, \"jOt', 24]",
   "?[OQ78AW32d[categorical[49]%]",
@@ -27833,6 +27849,26 @@ const char *parse_error_tests[] = {
   "10 * 2 * (Dims... * int64)",
   "(Dims... * M * N * T, Dims... * N * P * T)",
 
+  /* Nested variable dimensions */
+  "var(offsets=[0,2]) * var(offsets=[0,4,10]) * (var(offsets=[0,2]) * var(offsets=[0,3]) * float32, int64)",
+  "var(offsets=[0,2]) * var(offsets=[0,4,10]) * (var(offsets=[0,1]) * var(offsets=[0,3,5]) * float32, int64)",
+  "var(offsets=[0,2]) * var(offsets=[0,4]) * (var(offsets=[0,2]) * var(offsets=[0,3,5]) * float32, int64)",
+  "var(offsets=[0,1]) * var(offsets=[0,4,10]) * (var(offsets=[0,2]) * var(offsets=[0,3,5]) * float32, int64)",
+  "var(offsets=[0,2]) * var(offsets=[0,4,10]) * (var(offsets=[0,2]) * var(offsets=[0,3,5]) * float32, intXX)",
+  "var(offsets=[0,2]) * var(offsets=[0,4,10]) * (var(offsets=[0,2]) * var(offsets=[0,3,5)) * float32, int64)",
+  "var(offsets=[0,2]) * var(offsets=[0,4,10]) * (var(offsets=(0,2]) * var(offsets=[0,3,5]) * float32, int64)",
+
+  /* Unions */
+  "2 * 3 * []",
+  "Array of 2 * 3 * int64 | $Record of { s: int64 }",
+  "Array of 2 * 3 * int64 | Record of { s: int64XX }",
+  "This of int64 | Array of 2 * 3 * (float64, ref(int64))",
+
+  /* var... and array... */
+  "var... of float64",
+  "var... * (int64, str)",
+  "array... * float64",
+  "array... * (int64, str)",
   /* END MANUALLY GENERATED */
 
   NULL