Fixes for issues exposed by the blaze tests

Author: mwiebe

dynd/tests/test_numpy_interop.py

@@ -345,6 +345,22 @@ def assign_to(x,y):
         self.assertRaises(RuntimeError, nd.view, a, access='rw')
 
 class TestAsNumpy(unittest.TestCase):
+    def test_struct_as_numpy(self):
+        # Aligned cstruct
+        a = nd.array([[1, 2], [3, 4]], dtype='{x : int32, y: int64}')
+        b = nd.as_numpy(a)
+        self.assertEqual(b.dtype,
+                    np.dtype([('x', np.int32), ('y', np.int64)], align=True))
+        self.assertEqual(nd.as_py(a.x), b['x'].tolist())
+        self.assertEqual(nd.as_py(a.y), b['y'].tolist())
+        # Unaligned cstruct
+        a = nd.array([[1, 2], [3, 4]],
+                    dtype='{x : unaligned[int32], y: unaligned[int64]}')
+        b = nd.as_numpy(a)
+        self.assertEqual(b.dtype, np.dtype([('x', np.int32), ('y', np.int64)]))
+        self.assertEqual(nd.as_py(a.x), b['x'].tolist())
+        self.assertEqual(nd.as_py(a.y), b['y'].tolist())
+
     def test_cstruct_as_numpy(self):
         # Aligned cstruct
         a = nd.array([[1, 2], [3, 4]], dtype='c{x : int32, y: int64}')
@@ -377,6 +393,18 @@ def test_cstruct_via_pep3118(self):
         self.assertEqual(nd.as_py(a.x), b['x'].tolist())
         self.assertEqual(nd.as_py(a.y), b['y'].tolist())
 
+    def test_fixed_dim(self):
+        a = nd.array([1, 3, 5], type='3 * int32')
+        b = nd.as_numpy(a)
+        self.assertEqual(b.dtype, np.dtype('int32'))
+        self.assertEqual(b.tolist(), [1, 3, 5])
+
+    def test_fixed_dim_via_pep3118(self):
+        a = nd.array([1, 3, 5], type='3 * int32')
+        b = np.asarray(a)
+        self.assertEqual(b.dtype, np.dtype('int32'))
+        self.assertEqual(b.tolist(), [1, 3, 5])
+
 class TestNumpyScalarInterop(unittest.TestCase):
     def test_numpy_scalar_conversion_dtypes(self):
         self.assertEqual(nd.dtype_of(nd.array(np.bool_(True))), ndt.bool)

include/ndt_type.pxd

@@ -69,6 +69,7 @@ cdef extern from "dynd/type.hpp" namespace "dynd::ndt":
         type_id_t type_id()
         type_kind_t get_kind()
         size_t get_data_size()
+        size_t get_default_data_size(intptr_t, intptr_t*)
         size_t get_data_alignment()
         size_t get_metadata_size()
         base_type* extended()

src/_pydynd.pyx

@@ -173,6 +173,16 @@ cdef class w_type:
             else:
                 return None
 
+    property default_data_size:
+        """
+        tp.default_data_size
+
+        The size, in bytes, of the data for a default-constructed
+        instance of this dynd type.
+        """
+        def __get__(self):
+            return (GET(self.v)).get_default_data_size(0, <intptr_t *>0)
+
     property data_alignment:
         """
         tp.data_alignment

src/array_as_numpy.cpp

@@ -16,6 +16,7 @@
 #include "utility_functions.hpp"
 
 #include <dynd/types/strided_dim_type.hpp>
+#include <dynd/types/fixed_dim_type.hpp>
 #include <dynd/types/cfixed_dim_type.hpp>
 #include <dynd/types/fixedstring_type.hpp>
 #include <dynd/types/base_struct_type.hpp>
@@ -122,22 +123,34 @@ static void make_numpy_dtype_for_copy(pyobject_ownref *out_numpy_dtype,
 #endif
             }
         case strided_dim_type_id:
+        case fixed_dim_type_id:
         case cfixed_dim_type_id: {
             if (ndim > 0) {
                 // If this is one of the array dimensions, it simply
                 // becomes one of the numpy ndarray dimensions
-                if (dt.get_type_id() == strided_dim_type_id) {
+                switch (dt.get_type_id()) {
+                case strided_dim_type_id: {
                     const strided_dim_type *sad = dt.tcast<strided_dim_type>();
                     make_numpy_dtype_for_copy(out_numpy_dtype,
                                     ndim - 1, sad->get_element_type(),
                                     metadata + sizeof(strided_dim_type_metadata));
-                } else {
+                    return;
+                }
+                case fixed_dim_type_id: {
+                    const fixed_dim_type *fad = dt.tcast<fixed_dim_type>();
+                    make_numpy_dtype_for_copy(out_numpy_dtype,
+                                    ndim - 1, fad->get_element_type(),
+                                    metadata + sizeof(fixed_dim_type_metadata));
+                    return;
+                }
+                case cfixed_dim_type_id: {
                     const cfixed_dim_type *fad = dt.tcast<cfixed_dim_type>();
                     make_numpy_dtype_for_copy(out_numpy_dtype,
                                     ndim - 1, fad->get_element_type(),
-                                    metadata + sizeof(strided_dim_type_metadata));
+                                    metadata);
+                    return;
+                }
                 }
-                return;
             } else {
                 // If this isn't one of the array dimensions, it maps into
                 // a numpy dtype with a shape
@@ -158,6 +171,12 @@ static void make_numpy_dtype_for_copy(pyobject_ownref *out_numpy_dtype,
                         dim_size = sad->get_dim_size(metadata, NULL);
                         element_tp = sad->get_element_type();
                         metadata += sizeof(strided_dim_type_metadata);
+                    } else if (dt.get_type_id() == fixed_dim_type_id) {
+                        const fixed_dim_type *fad =
+                                        element_tp.tcast<fixed_dim_type>();
+                        dim_size = fad->get_fixed_dim_size();
+                        element_tp = fad->get_element_type();
+                        metadata += sizeof(fixed_dim_type_metadata);
                     } else if (dt.get_type_id() == cfixed_dim_type_id) {
                         const cfixed_dim_type *fad =
                                         element_tp.tcast<cfixed_dim_type>();
@@ -372,6 +391,24 @@ static void as_numpy_analysis(pyobject_ownref *out_numpy_dtype, bool *out_requir
             }
             break;
         }
+        case fixed_dim_type_id: {
+            const fixed_dim_type *fad = dt.tcast<fixed_dim_type>();
+            if (ndim > 0) {
+                // If this is one of the array dimensions, it simply
+                // becomes one of the numpy ndarray dimensions
+                as_numpy_analysis(out_numpy_dtype, out_requires_copy,
+                                ndim - 1, fad->get_element_type(),
+                                metadata + sizeof(fixed_dim_type_metadata));
+                return;
+            } else {
+                // If this isn't one of the array dimensions, it maps into
+                // a numpy dtype with a shape
+                out_numpy_dtype->clear();
+                *out_requires_copy = true;
+                return;
+            }
+            break;
+        }
         case cfixed_dim_type_id: {
             const cfixed_dim_type *fad = dt.tcast<cfixed_dim_type>();
             if (ndim > 0) {
@@ -481,13 +518,15 @@ static void as_numpy_analysis(pyobject_ownref *out_numpy_dtype, bool *out_requir
                 PyList_SET_ITEM((PyObject *)offsets_obj, i, PyLong_FromSize_t(offsets[i]));
             }
 
-            pyobject_ownref itemsize_obj(PyLong_FromSize_t(dt.get_data_size()));
 
             pyobject_ownref dict_obj(PyDict_New());
             PyDict_SetItemString(dict_obj, "names", names_obj);
             PyDict_SetItemString(dict_obj, "formats", formats_obj);
             PyDict_SetItemString(dict_obj, "offsets", offsets_obj);
-            PyDict_SetItemString(dict_obj, "itemsize", itemsize_obj);
+            if (dt.get_data_size() > 0) {
+                pyobject_ownref itemsize_obj(PyLong_FromSize_t(dt.get_data_size()));
+                PyDict_SetItemString(dict_obj, "itemsize", itemsize_obj);
+            }
 
             PyArray_Descr *result = NULL;
             if (!PyArray_DescrConverter(dict_obj, &result)) {