ndtypes 0.2.0dev4

data/ext/ruby_ndtypes/ndtypes/libndtypes/values.c

@@ -0,0 +1,228 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <string.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "seq.h"
+
+
+/*****************************************************************************/
+/*                    Values for the categorical type                        */
+/*****************************************************************************/
+
+void
+ndt_value_del(ndt_value_t *mem)
+{
+    if (mem == NULL) {
+        return;
+    }
+
+    if (mem->tag == ValString) {
+        ndt_free(mem->ValString);
+    }
+
+    ndt_free(mem);
+}
+
+void
+ndt_value_array_del(ndt_value_t *mem, int64_t ntypes)
+{
+    int64_t i;
+
+    if (mem == NULL) {
+        return;
+    }
+
+    for (i = 0; i < ntypes; i++) {
+        if (mem[i].tag == ValString) {
+            ndt_free(mem[i].ValString);
+        }
+    }
+
+    ndt_free(mem);
+}
+
+/* Value sequences */
+NDT_SEQ_NEW(ndt_value)
+NDT_SEQ_DEL(ndt_value)
+NDT_SEQ_GROW(ndt_value)
+NDT_SEQ_APPEND(ndt_value)
+NDT_SEQ_FINALIZE(ndt_value)
+
+
+/* Return a new ndt memory buffer. Input types are restricted. */
+ndt_value_t *
+ndt_value_from_number(enum ndt_value tag, char *v, ndt_context_t *ctx)
+{
+    ndt_value_t *mem;
+
+    mem = ndt_alloc_size(sizeof *mem);
+    if (mem == NULL) {
+        ndt_free(v);
+        return ndt_memory_error(ctx);
+    }
+    mem->tag = tag;
+
+    switch (tag) {
+    case ValBool:
+        mem->ValBool = ndt_strtobool(v, ctx);
+        break;
+    case ValInt64:
+        mem->ValInt64 = (int64_t)ndt_strtoll(v, INT64_MIN, INT64_MAX, ctx);
+        break;
+    case ValFloat64:
+        mem->ValFloat64 = ndt_strtod(v, ctx);
+        break;
+    case ValString: case ValNA:
+        ndt_err_format(ctx, NDT_InvalidArgumentError, "expected number tag");
+        break;
+    }
+
+    ndt_free(v);
+    if (ndt_err_occurred(ctx)) {
+        ndt_free(mem);
+        return NULL;
+    }
+
+    return mem;
+}
+
+/* Return a new ndt memory buffer. The input type is 'string'. */
+ndt_value_t *
+ndt_value_from_string(char *v, ndt_context_t *ctx)
+{
+    ndt_value_t *mem;
+
+    mem = ndt_alloc_size(sizeof *mem);
+    if (mem == NULL) {
+        ndt_free(v);
+        return ndt_memory_error(ctx);
+    }
+
+    /* XXX: check utf8 */
+    mem->tag = ValString;
+    mem->ValString = v;
+
+    return mem;
+}
+
+/* Return a new ndt memory buffer. The input type is 'NA'. */
+ndt_value_t *
+ndt_value_na(ndt_context_t *ctx)
+{
+    ndt_value_t *mem;
+
+    mem = ndt_alloc_size(sizeof *mem);
+    if (mem == NULL) {
+        return ndt_memory_error(ctx);
+    }
+    mem->tag = ValNA;
+
+    return mem;
+}
+
+/* Equality: NA does not compare equal to anything. */
+int
+ndt_value_equal(const ndt_value_t *x, const ndt_value_t *y)
+{
+    if (x->tag != y->tag) {
+        return 0;
+    }
+
+    switch(x->tag) {
+    case ValBool:
+        return x->ValBool == y->ValBool;
+    case ValInt64:
+        return x->ValInt64 == y->ValInt64;
+    case ValFloat64:
+        return x->ValFloat64 == y->ValFloat64;
+    case ValString:
+        return strcmp(x->ValString, y->ValString) == 0;
+    case ValNA:
+        return 0;
+    }
+
+    /* NOT REACHED: tags should be exhaustive. */
+    ndt_internal_error("invalid value");
+}
+
+/* Structural equality: NA compares equal to itself. */
+int
+ndt_value_mem_equal(const ndt_value_t *x, const ndt_value_t *y)
+{
+    if (x->tag != y->tag) {
+        return 0;
+    }
+
+    switch(x->tag) {
+    case ValBool:
+        return x->ValBool == y->ValBool;
+    case ValInt64:
+        return x->ValInt64 == y->ValInt64;
+    case ValFloat64:
+        return x->ValFloat64 == y->ValFloat64;
+    case ValString:
+        return strcmp(x->ValString, y->ValString) == 0;
+    case ValNA:
+        return 1;
+    }
+
+    /* NOT REACHED: tags should be exhaustive. */
+    ndt_internal_error("invalid value");
+}
+
+/* Sort order: NA compares equal to itself. */
+int
+ndt_value_compare(const ndt_value_t *x, const ndt_value_t *y)
+{
+    if (x->tag != y->tag) {
+        return x->tag - y->tag;
+    }
+
+    switch(x->tag) {
+    case ValBool:
+        return x->ValBool < y->ValBool ? -1 : x->ValBool != y->ValBool;
+    case ValInt64:
+        return x->ValInt64 < y->ValInt64 ? -1 : x->ValInt64 != y->ValInt64;
+    case ValFloat64:
+        return x->ValFloat64 < y->ValFloat64 ? -1 : x->ValFloat64 != y->ValFloat64;
+    case ValString:
+        return strcmp(x->ValString, y->ValString);
+    case ValNA:
+        return 0;
+    }
+
+    /* NOT REACHED: tags should be exhaustive. */
+    ndt_internal_error("invalid value");
+}

data/ext/ruby_ndtypes/ndtypes/python/bench.py

@@ -0,0 +1,49 @@
+from ndtypes import *
+import time
+
+# =============================================================================
+#                       Type with huge number of offsets
+# =============================================================================
+
+s = "var(offsets=[0,10000000]) * var(offsets=%s) * int64" % list(range(10000001))
+print("Parse 10_000_000 var offsets:")
+start = time.time()
+t = ndt(s)
+end = time.time()
+print(end-start)
+
+
+b = t.serialize()
+print("\nDeserialize 10_000_000 var offsets:")
+start = time.time()
+u = ndt.deserialize(b)
+end = time.time()
+print(end-start)
+
+assert t == u
+
+
+# =============================================================================
+#                                  Large type
+# =============================================================================
+
+s = """
+{battingpost: 100 * {yearID: ?int32, round: ?string, playerID: ?string, teamID: ?string, lgID: (?string, int64, 5 * 10 * {a: complex128, b: ?int32}), G: ?int32, AB: ?int32, R: ?int32, H: (int32, 10 * int32), HR: {a: 10 * float64, b: 10 * int32}, RBI: ?int32, SB: ?int32, CS: ?int32, BB: ?int32, SO: ?int32, IBB: ?int32, HBP: ?int32, SH: ?int32, SF: ?int32, GIDP: ?int32, AString: fixed_string(100,'utf32'), BString: fixed_string(100), CBytes: bytes(align=16), DBytes: fixed_bytes(size=1600, align=16)}, awardsmanagers: 10 * {managerID: ?string, awardID: ?string, yearID: ?int32, lgID: ?string, tie: ?string, notes: ?string}, hofold: 10 * {hofID: ?string, yearid: ?int32, votedBy: ?string, ballots: ?int32, votes: ?int32, inducted: ?string, category: ?string}, salaries: 10 * {yearID: ?int32, teamID: ?string, lgID: ?string, playerID: ?string, salary: ?float64}, pitchingpost: 10 * {playerID: ?string, yearID: ?int32, round: ?string, teamID: ?string, lgID: ?string, W: ?int32, L: ?int32, G: ?int32, GS: ?int32, CG: ?int32, SHO: ?int32, SV: ?int32, IPouts: ?int32, H: ?int32, ER: ?int32, HR: ?int32, BB: ?int32, SO: ?int32, BAOpp: ?float64, ERA: ?float64, IBB: ?int32, WP: ?int32, HBP: ?int32, BK: ?int32, BFP: ?int32, GF: ?int32, R: ?int32, SH: ?int32, SF: ?int32, GIDP: ?int32}, managers: 10 * {managerID: ?string, yearID: ?int32, teamID: ?string, lgID: ?string, inseason: ?int32, G: ?int32, W: ?int32, L: ?int32, rank: ?int32, plyrMgr: ?string}, teams: 10 * {yearID: ?int32, lgID: ?string, teamID: ?string, franchID: ?string, divID: ?string, Rank: ?int32, G: ?int32, Ghome: ?int32, W: ?int32, L: ?int32, DivWin: ?string, WCWin: ?string, LgWin: ?string, WSWin: ?string, R: ?int32, AB: ?int32, H: ?int32, B: ?int32, B: ?int32, HR: ?int32, BB: ?int32, SO: ?int32, SB: ?int32, CS: ?int32, HBP: ?int32, SF: ?int32, RA: ?int32, ER: ?int32, ERA: ?float64, CG: ?int32, SHO: ?int32, SV: ?int32, IPouts: ?int32, HA: ?int32, HRA: ?int32, BBA: ?int32, SOA: ?int32, E: ?int32, DP: ?int32, FP: ?float64, name: ?string, park: ?string, attendance: ?int32, BPF: ?int32, PPF: ?int32, teamIDBR: ?string, teamIDlahman45: ?string, teamIDretro: ?string}}
+"""
+
+print("\nParse large type (100_000 repetitions):")
+start = time.time()
+for i in range(100000):
+    t = ndt(s)
+end = time.time()
+print(end-start)
+
+b = t.serialize()
+print("\nDeserialize large type (100_000 repetitions):")
+start = time.time()
+for i in range(100000):
+    u = ndt.deserialize(b)
+end = time.time()
+print(end-start)
+
+assert t == u

data/ext/ruby_ndtypes/ndtypes/python/ndt_randtype.py

@@ -0,0 +1,409 @@
+#
+# BSD 3-Clause License
+#
+# Copyright (c) 2017-2018, plures
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# Functions for generating test cases.
+
+import sys
+from itertools import accumulate, count, product
+from collections import namedtuple
+from random import randrange
+from ndtypes import ndt, ApplySpec
+from _testbuffer import get_sizeof_void_p
+
+
+SIZEOF_PTR = get_sizeof_void_p()
+
+Mem = namedtuple("Mem", "itemsize align")
+
+
+# ======================================================================
+#                    Check contiguous fixed dimensions
+# ======================================================================
+
+def c_datasize(t):
+    """Check the datasize of contiguous arrays."""
+    datasize = t.itemsize
+    for v in t.shape:
+        datasize *= v
+    return datasize
+
+
+# ======================================================================
+#              Check fixed dimensions with arbitary strides
+# ======================================================================
+
+def verify_datasize(t):
+    """Verify the datasize of fixed dimensions with arbitrary strides."""
+
+    if t.itemsize == 0:
+        return t.datasize == 0
+    if t.datasize % t.itemsize:
+        return False
+    if t.ndim <= 0:
+        return t.ndim == 0 and not t.shape and not t.strides
+    if any(v < 0 for v in t.shape):
+        return False
+    if any(v % t.itemsize for v in t.strides):
+        return False
+
+    if 0 in t.shape:
+        return t.datasize == 0
+
+    imin = sum(t.strides[j]*(t.shape[j]-1) for j in range(t.ndim)
+               if t.strides[j] <= 0)
+    imax = sum(t.strides[j]*(t.shape[j]-1) for j in range(t.ndim)
+               if t.strides[j] > 0)
+
+    return t.datasize == (abs(imin) + imax + t.itemsize)
+
+
+# ======================================================================
+#                             Typed values
+# ======================================================================
+
+DTYPE_TEST_CASES = [
+   # Tuples
+   ("()", Mem(itemsize=0, align=1)),
+   ("(complex128)", Mem(itemsize=16, align=8)),
+
+   ("(int8, int64)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, pack=1)", Mem(itemsize=9, align=1)),
+   ("(int8, int64, pack=2)", Mem(itemsize=10, align=2)),
+   ("(int8, int64, pack=4)", Mem(itemsize=12, align=4)),
+   ("(int8, int64, pack=8)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, pack=16)", Mem(itemsize=32, align=16)),
+
+   ("(int8, int64, align=1)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, align=2)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, align=4)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, align=8)", Mem(itemsize=16, align=8)),
+   ("(int8, int64, align=16)", Mem(itemsize=16, align=16)),
+
+   ("(int8 |align=1|, int64)", Mem(itemsize=16, align=8)),
+   ("(int8 |align=2|, int64)", Mem(itemsize=16, align=8)),
+   ("(int8 |align=4|, int64)", Mem(itemsize=16, align=8)),
+   ("(int8 |align=8|, int64)", Mem(itemsize=16, align=8)),
+   ("(int8 |align=16|, int64)", Mem(itemsize=16, align=16)),
+
+   ("(uint16, (complex64))", Mem(itemsize=12, align=4)),
+   ("(uint16, (complex64), pack=1)", Mem(itemsize=10, align=1)),
+   ("(uint16, (complex64), pack=2)", Mem(itemsize=10, align=2)),
+   ("(uint16, (complex64), pack=4)", Mem(itemsize=12, align=4)),
+   ("(uint16, (complex64), pack=8)", Mem(itemsize=16, align=8)),
+
+   ("(uint16, (complex64), align=1)", Mem(itemsize=12, align=4)),
+   ("(uint16, (complex64), align=2)", Mem(itemsize=12, align=4)),
+   ("(uint16, (complex64), align=4)", Mem(itemsize=12, align=4)),
+   ("(uint16, (complex64), align=8)", Mem(itemsize=16, align=8)),
+
+   # References to tuples
+   ("&(uint16, (complex64), align=1)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("(uint16, &(complex64), pack=1)", Mem(itemsize=2+SIZEOF_PTR, align=1)),
+
+   # Constructor containing references to tuples
+   ("Some(&(uint16, (complex64), align=1))", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("Some((uint16, &(complex64), pack=1))", Mem(itemsize=2+SIZEOF_PTR, align=1)),
+
+   # Optional tuples
+   ("?(uint16, (complex64), align=1)", Mem(itemsize=12, align=4)),
+   ("(uint16, ?(complex64), align=1)", Mem(itemsize=12, align=4)),
+   ("?(uint16, ?(complex64), align=1)", Mem(itemsize=12, align=4)),
+   ("?(uint16, (complex64), align=2)", Mem(itemsize=12, align=4)),
+   ("(uint16, ?(complex64), align=4)", Mem(itemsize=12, align=4)),
+   ("?(uint16, ?(complex64), align=8)", Mem(itemsize=16, align=8)),
+
+   # References to optional tuples or tuples with optional subtrees
+   ("&?(uint16, (complex64), align=1)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&(uint16, ?(complex64), align=1)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   # Constructor containing optional tuples or tuples with optional subtrees
+   ("Some(?(uint16, (complex64), align=1))", Mem(itemsize=12, align=4)),
+   ("Some((uint16, ?(complex64), align=1))", Mem(itemsize=12, align=4)),
+
+   # Records
+   ("{}", Mem(itemsize=0, align=1)),
+   ("{x: complex128}", Mem(itemsize=16, align=8)),
+
+   ("{x: int8, y: int64}", Mem(itemsize=16, align=8)),
+   ("{x: int8, y: int64, pack=1}", Mem(itemsize=9, align=1)),
+   ("{x: int8, y: int64, pack=2}", Mem(itemsize=10, align=2)),
+   ("{x: int8, y: int64, pack=4}", Mem(itemsize=12, align=4)),
+   ("{x: int8, y: int64, pack=8}", Mem(itemsize=16, align=8)),
+   ("{x: int8, y: int64, pack=16}", Mem(itemsize=32, align=16)),
+
+   ("{x: uint16, y: {z: complex128}}", Mem(itemsize=24, align=8)),
+   ("{x: uint16, y: {z: complex128, align=16}}", Mem(itemsize=32, align=16)),
+   ("{x: uint16, y: {z: complex128}, align=16}", Mem(itemsize=32, align=16)),
+
+   # Primitive types
+   ("bool", Mem(itemsize=1, align=1)),
+
+   ("int8", Mem(itemsize=1, align=1)),
+   ("int16", Mem(itemsize=2, align=2)),
+   ("int32", Mem(itemsize=4, align=4)),
+   ("int64", Mem(itemsize=8, align=8)),
+
+   ("uint8", Mem(itemsize=1, align=1)),
+   ("uint16", Mem(itemsize=2, align=2)),
+   ("uint32", Mem(itemsize=4, align=4)),
+   ("uint64", Mem(itemsize=8, align=8)),
+
+   ("float32", Mem(itemsize=4, align=4)),
+   ("float64", Mem(itemsize=8, align=8)),
+
+   ("complex64", Mem(itemsize=8, align=4)),
+   ("complex128", Mem(itemsize=16, align=8)),
+
+   # Primitive optional types
+   ("?bool", Mem(itemsize=1, align=1)),
+
+   ("?int8", Mem(itemsize=1, align=1)),
+   ("?int16", Mem(itemsize=2, align=2)),
+   ("?int32", Mem(itemsize=4, align=4)),
+   ("?int64", Mem(itemsize=8, align=8)),
+
+   ("?uint8", Mem(itemsize=1, align=1)),
+   ("?uint16", Mem(itemsize=2, align=2)),
+   ("?uint32", Mem(itemsize=4, align=4)),
+   ("?uint64", Mem(itemsize=8, align=8)),
+
+   ("?float32", Mem(itemsize=4, align=4)),
+   ("?float64", Mem(itemsize=8, align=8)),
+
+   ("?complex64", Mem(itemsize=8, align=4)),
+   ("?complex128", Mem(itemsize=16, align=8)),
+
+   # References
+   ("&bool", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("&int8", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&int16", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&int32", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&int64", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(uint8)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(uint16)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(uint32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(uint64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(float32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(float64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(complex64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(complex128)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   # Optional references
+   ("?&bool", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("?&int8", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?&int16", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?&int32", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?&int64", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("?ref(uint8)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?ref(uint16)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?ref(uint32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?ref(uint64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("?ref(float32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?ref(float64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("?ref(complex64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("?ref(complex128)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   # References to optional types
+   ("&?bool", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("&?int8", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&?int16", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&?int32", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("&?int64", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(?uint8)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(?uint16)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(?uint32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(?uint64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(?float32)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(?float64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   ("ref(?complex64)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+   ("ref(?complex128)", Mem(itemsize=SIZEOF_PTR, align=SIZEOF_PTR)),
+
+   # Constructors
+   ("Some(bool)", Mem(itemsize=1, align=1)),
+
+   ("Some(int8)", Mem(itemsize=1, align=1)),
+   ("Some(int16)", Mem(itemsize=2, align=2)),
+   ("Some(int32)", Mem(itemsize=4, align=4)),
+   ("Some(int64)", Mem(itemsize=8, align=8)),
+
+   ("Some(uint8)", Mem(itemsize=1, align=1)),
+   ("Some(uint16)", Mem(itemsize=2, align=2)),
+   ("Some(uint32)", Mem(itemsize=4, align=4)),
+   ("Some(uint64)", Mem(itemsize=8, align=8)),
+
+   ("Some(float32)", Mem(itemsize=4, align=4)),
+   ("Some(float64)", Mem(itemsize=8, align=8)),
+
+   ("Some(complex64)", Mem(itemsize=8, align=4)),
+   ("Some(complex128)", Mem(itemsize=16, align=8)),
+
+   # Optional constructors
+   ("?Some(bool)", Mem(itemsize=1, align=1)),
+
+   ("?Some(int8)", Mem(itemsize=1, align=1)),
+   ("?Some(int16)", Mem(itemsize=2, align=2)),
+   ("?Some(int32)", Mem(itemsize=4, align=4)),
+   ("?Some(int64)", Mem(itemsize=8, align=8)),
+
+   ("?Some(uint8)", Mem(itemsize=1, align=1)),
+   ("?Some(uint16)", Mem(itemsize=2, align=2)),
+   ("?Some(uint32)", Mem(itemsize=4, align=4)),
+   ("?Some(uint64)", Mem(itemsize=8, align=8)),
+
+   ("?Some(float32)", Mem(itemsize=4, align=4)),
+   ("?Some(float64)", Mem(itemsize=8, align=8)),
+
+   ("?Some(complex64)", Mem(itemsize=8, align=4)),
+   ("?Some(complex128)", Mem(itemsize=16, align=8)),
+
+   # Constructors containing optional types
+   ("Some(?bool)", Mem(itemsize=1, align=1)),
+
+   ("Some(?int8)", Mem(itemsize=1, align=1)),
+   ("Some(?int16)", Mem(itemsize=2, align=2)),
+   ("Some(?int32)", Mem(itemsize=4, align=4)),
+   ("Some(?int64)", Mem(itemsize=8, align=8)),
+
+   ("Some(?uint8)", Mem(itemsize=1, align=1)),
+   ("Some(?uint16)", Mem(itemsize=2, align=2)),
+   ("Some(?uint32)", Mem(itemsize=4, align=4)),
+   ("Some(?uint64)", Mem(itemsize=8, align=8)),
+
+   ("Some(?float32)", Mem(itemsize=4, align=4)),
+   ("Some(?float64)", Mem(itemsize=8, align=8)),
+
+   ("Some(?complex64)", Mem(itemsize=8, align=4)),
+   ("Some(?complex128)", Mem(itemsize=16, align=8)),
+]
+
+# ======================================================================
+#                              Broadcasting
+# ======================================================================
+
+def genindices(factor):
+    for i in range(4):
+        yield ()
+    for i in range(4):
+        yield (factor * i,)
+    for i in range(4):
+        for j in range(4):
+            yield (factor * i, factor * j)
+    for i in range(4):
+        for j in range(4):
+            for k in range(4):
+                yield (factor * i, factor * j, factor * k)
+
+BROADCAST_TEST_CASES = [
+    ApplySpec(
+        flags = 'C|Fortran|Strided|Xnd',
+        sig = ndt("uint8 -> float64"),
+        in_types = [ndt("uint8")],
+        out_types = [ndt("float64")],
+        in_broadcast = [],
+        outer_dims = 0),
+
+    ApplySpec(
+        flags = 'Elemwise1D|C|Fortran|Strided|Xnd',
+        sig = ndt("... * uint8 -> ... * float64"),
+        in_types = [ndt("2 * uint8")],
+        out_types = [ndt("2 * float64")],
+        in_broadcast = [ndt("2 * uint8")],
+        outer_dims = 1),
+
+    ApplySpec(
+        flags = 'C|Fortran|Strided|Xnd',
+        sig = ndt("F[... * uint8] -> F[... * float64]"),
+        in_types = [ndt("!2 * 3 * uint8")],
+        out_types = [ndt("!2 * 3 * float64")],
+        in_broadcast = [ndt("!2 * 3 * uint8")],
+        outer_dims = 2),
+
+    ApplySpec(
+        flags = 'C|Fortran|Strided|Xnd',
+        sig = ndt("... * uint8 -> ... * float64"),
+        in_types = [ndt("fixed(shape=2, step=10) * uint8")],
+        out_types = [ndt("2 * float64")],
+        in_broadcast = [ndt("fixed(shape=2, step=10) * uint8")],
+        outer_dims = 1),
+
+    ApplySpec(
+        flags = 'Strided|Xnd',
+        sig = ndt("... * N * uint8 -> ... * N * float64"),
+        in_types = [ndt("fixed(shape=2, step=10) * uint8")],
+        out_types = [ndt("2 * float64")],
+        in_broadcast = [ndt("fixed(shape=2, step=10) * uint8")],
+        outer_dims = 0),
+
+    ApplySpec(
+        flags = 'C|Fortran|Strided|Xnd',
+        sig = ndt("... * N * uint8 -> ... * N * float64"),
+        in_types = [ndt("2 * 3 * uint8")],
+        out_types = [ndt("2 * 3 * float64")],
+        in_broadcast = [ndt("2 * 3 * uint8")],
+        outer_dims = 1),
+
+    ApplySpec(
+        flags = 'C|Strided|Xnd',
+        sig = ndt("... * N * M * uint8 -> ... * N * M * float64"),
+        in_types = [ndt("2 * 3 * uint8")],
+        out_types = [ndt("2 * 3 * float64")],
+        in_broadcast = [ndt("2 * 3 * uint8")],
+        outer_dims = 0),
+
+    ApplySpec(
+        flags = 'Xnd',
+        sig = ndt("N * D * float64 -> P * float64"),
+        in_types = [ndt("2 * 10 * float64")],
+        out_types = [ndt("P * float64")],
+        in_broadcast = [],
+        outer_dims = 0),
+
+    ApplySpec(
+        flags = 'C|Fortran|Xnd',
+        sig = ndt("var... * float64 -> var... * float64"),
+        in_types = [ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")],
+        out_types = [ndt("var(offsets=[0,2]) * var(offsets=[0,4,11]) * float64")],
+        in_broadcast = [],
+        outer_dims = 2)
+]