예제 #1
0
    def test_fixedstring_type_properties(self):
        d = ndt.make_fixedstring(10, 'ascii')
        self.assertEqual(str(d), "string[10,'ascii']")
        self.assertEqual(d.data_size, 10)
        self.assertEqual(d.data_alignment, 1)
        self.assertEqual(d.encoding, 'ascii')

        d = ndt.make_fixedstring(10, 'ucs2')
        self.assertEqual(str(d), "string[10,'ucs2']")
        self.assertEqual(d.data_size, 20)
        self.assertEqual(d.data_alignment, 2)
        self.assertEqual(d.encoding, 'ucs2')

        d = ndt.make_fixedstring(10, 'utf8')
        self.assertEqual(str(d), 'string[10]')
        self.assertEqual(d.data_size, 10)
        self.assertEqual(d.data_alignment, 1)
        self.assertEqual(d.encoding, 'utf8')

        d = ndt.make_fixedstring(10, 'utf16')
        self.assertEqual(str(d), "string[10,'utf16']")
        self.assertEqual(d.data_size, 20)
        self.assertEqual(d.data_alignment, 2)
        self.assertEqual(d.encoding, 'utf16')

        d = ndt.make_fixedstring(10, 'utf32')
        self.assertEqual(str(d), "string[10,'utf32']")
        self.assertEqual(d.data_size, 40)
        self.assertEqual(d.data_alignment, 4)
        self.assertEqual(d.encoding, 'utf32')
    def test_ndt_type_from_numpy_dtype(self):
        # Tests converting numpy dtypes to dynd types
        # native byte order
        self.assertEqual(ndt.bool, ndt.type(np.dtype(np.bool)))
        self.assertEqual(ndt.int8, ndt.type(np.dtype(np.int8)))
        self.assertEqual(ndt.int16, ndt.type(np.dtype(np.int16)))
        self.assertEqual(ndt.int32, ndt.type(np.dtype(np.int32)))
        self.assertEqual(ndt.int64, ndt.type(np.dtype(np.int64)))
        self.assertEqual(ndt.uint8, ndt.type(np.dtype(np.uint8)))
        self.assertEqual(ndt.uint16, ndt.type(np.dtype(np.uint16)))
        self.assertEqual(ndt.uint32, ndt.type(np.dtype(np.uint32)))
        self.assertEqual(ndt.uint64, ndt.type(np.dtype(np.uint64)))
        self.assertEqual(ndt.float32, ndt.type(np.dtype(np.float32)))
        self.assertEqual(ndt.float64, ndt.type(np.dtype(np.float64)))
        self.assertEqual(ndt.complex_float32, ndt.type(np.dtype(np.complex64)))
        self.assertEqual(ndt.complex_float64, ndt.type(np.dtype(np.complex128)))
        self.assertEqual(ndt.make_fixedstring(10, 'ascii'),
                    ndt.type(np.dtype('S10')))
        self.assertEqual(ndt.make_fixedstring(10, 'utf_32'),
                    ndt.type(np.dtype('U10')))

        # non-native byte order
        nonnative = self.nonnative

        self.assertEqual(ndt.make_byteswap(ndt.int16),
                ndt.type(np.dtype(nonnative + 'i2')))
        self.assertEqual(ndt.make_byteswap(ndt.int32),
                ndt.type(np.dtype(nonnative + 'i4')))
        self.assertEqual(ndt.make_byteswap(ndt.int64),
                ndt.type(np.dtype(nonnative + 'i8')))
        self.assertEqual(ndt.make_byteswap(ndt.uint16),
                ndt.type(np.dtype(nonnative + 'u2')))
        self.assertEqual(ndt.make_byteswap(ndt.uint32),
                ndt.type(np.dtype(nonnative + 'u4')))
        self.assertEqual(ndt.make_byteswap(ndt.uint64),
                ndt.type(np.dtype(nonnative + 'u8')))
        self.assertEqual(ndt.make_byteswap(ndt.float32),
                ndt.type(np.dtype(nonnative + 'f4')))
        self.assertEqual(ndt.make_byteswap(ndt.float64),
                ndt.type(np.dtype(nonnative + 'f8')))
        self.assertEqual(ndt.make_byteswap(ndt.complex_float32),
                ndt.type(np.dtype(nonnative + 'c8')))
        self.assertEqual(ndt.make_byteswap(ndt.complex_float64),
                ndt.type(np.dtype(nonnative + 'c16')))
    def test_numpy_dynd_fixedstring_interop(self):
        # Tests converting fixed-size string arrays to/from numpy
        # ASCII Numpy -> dynd
        a = np.array(['abc', 'testing', 'array'])
        b = nd.view(a)
        if sys.version_info >= (3, 0):
            self.assertEqual(ndt.make_fixedstring(7, 'utf_32'), nd.dtype_of(b))
        else:
            self.assertEqual(ndt.make_fixedstring(7, 'ascii'), nd.dtype_of(b))
        self.assertEqual(nd.dtype_of(b), ndt.type(a.dtype))

        # Make sure it's ascii
        a = a.astype('S7')
        b = nd.view(a)

        # ASCII dynd -> Numpy
        c = np.asarray(b)
        self.assertEqual(a.dtype, c.dtype)
        assert_array_equal(a, c)
        # verify 'a' and 'c' are looking at the same data
        a[1] = 'modify'
        assert_array_equal(a, c)

        # ASCII dynd -> UTF32 dynd
        b_u = b.ucast(ndt.make_fixedstring(7, 'utf_32'))
        self.assertEqual(
                ndt.make_convert(
                    ndt.make_fixedstring(7, 'utf_32'),
                    ndt.make_fixedstring(7, 'ascii')),
                nd.dtype_of(b_u))
        # Evaluate to its value array
        b_u = b_u.eval()
        self.assertEqual(
                ndt.make_fixedstring(7, 'utf_32'),
                nd.dtype_of(b_u))

        # UTF32 dynd -> Numpy
        c_u = np.asarray(b_u)
        self.assertEqual(nd.dtype_of(b_u), ndt.type(c_u.dtype))
        assert_array_equal(a.astype('U'), c_u)
        # 'a' and 'c_u' are not looking at the same data
        a[1] = 'diff'
        self.assertFalse(np.all(a == c_u))
예제 #4
0
 def test_utf_encodings(self):
     # Ensure all of the UTF encodings work ok for a basic string
     x = u'\uc548\ub155 hello'
     # UTF-8
     a = nd.array(x)
     a = a.ucast(ndt.make_fixedstring(16, 'utf_8'))
     a = a.eval()
     self.assertEqual(nd.type_of(a), ndt.make_fixedstring(16, 'utf_8'))
     self.assertEqual(type(nd.as_py(a)), unicode)
     self.assertEqual(nd.as_py(a), x)
     # UTF-16
     a = nd.array(x)
     a = a.ucast(ndt.make_fixedstring(8, 'utf_16'))
     a = a.eval()
     self.assertEqual(nd.type_of(a), ndt.make_fixedstring(8, 'utf_16'))
     self.assertEqual(type(nd.as_py(a)), unicode)
     self.assertEqual(nd.as_py(a), x)
     # UTF-32
     a = nd.array(x)
     a = a.ucast(ndt.make_fixedstring(8, 'utf_32'))
     a = a.eval()
     self.assertEqual(nd.type_of(a), ndt.make_fixedstring(8, 'utf_32'))
     self.assertEqual(type(nd.as_py(a)), unicode)
     self.assertEqual(nd.as_py(a), x)
예제 #5
0
 def test_type_id(self):
     # Numeric type id
     self.assertEqual(self.type_id_of(ndt.bool),
                     _lowlevel.type_id.BOOL)
     self.assertEqual(self.type_id_of(ndt.int8),
                     _lowlevel.type_id.INT8)
     self.assertEqual(self.type_id_of(ndt.int16),
                     _lowlevel.type_id.INT16)
     self.assertEqual(self.type_id_of(ndt.int32),
                     _lowlevel.type_id.INT32)
     self.assertEqual(self.type_id_of(ndt.int64),
                     _lowlevel.type_id.INT64)
     self.assertEqual(self.type_id_of(ndt.uint8),
                     _lowlevel.type_id.UINT8)
     self.assertEqual(self.type_id_of(ndt.uint16),
                     _lowlevel.type_id.UINT16)
     self.assertEqual(self.type_id_of(ndt.uint32),
                     _lowlevel.type_id.UINT32)
     self.assertEqual(self.type_id_of(ndt.uint64),
                     _lowlevel.type_id.UINT64)
     self.assertEqual(self.type_id_of(ndt.float32),
                     _lowlevel.type_id.FLOAT32)
     self.assertEqual(self.type_id_of(ndt.float64),
                     _lowlevel.type_id.FLOAT64)
     self.assertEqual(self.type_id_of(ndt.complex_float32),
                     _lowlevel.type_id.COMPLEX_FLOAT32)
     self.assertEqual(self.type_id_of(ndt.complex_float64),
                     _lowlevel.type_id.COMPLEX_FLOAT64)
     # String/bytes
     self.assertEqual(self.type_id_of(ndt.string),
                     _lowlevel.type_id.STRING)
     self.assertEqual(self.type_id_of(ndt.make_fixedstring(16)),
                     _lowlevel.type_id.FIXEDSTRING)
     self.assertEqual(self.type_id_of(ndt.bytes),
                     _lowlevel.type_id.BYTES)
     self.assertEqual(self.type_id_of(ndt.make_fixedbytes(16)),
                     _lowlevel.type_id.FIXEDBYTES)
     self.assertEqual(self.type_id_of(ndt.json),
                     _lowlevel.type_id.JSON)
     # Date
     self.assertEqual(self.type_id_of(ndt.date),
                     _lowlevel.type_id.DATE)
     # Property
     self.assertEqual(self.type_id_of(nd.type_of(ndt.date(2000, 1, 1).year)),
                     _lowlevel.type_id.PROPERTY)
     # Categorical
     self.assertEqual(self.type_id_of(ndt.make_categorical([1, 2, 3])),
                     _lowlevel.type_id.CATEGORICAL)
     # Struct
     self.assertEqual(self.type_id_of(ndt.make_struct(
                                 [ndt.int32, ndt.int32], ['x', 'y'])),
                     _lowlevel.type_id.STRUCT)
     self.assertEqual(self.type_id_of(ndt.type('{x : int32, y : int32}')),
                     _lowlevel.type_id.FIXEDSTRUCT)
     # Convert/byteswap/view
     self.assertEqual(self.type_id_of(ndt.make_convert(
                                 ndt.int32, ndt.int8)),
                     _lowlevel.type_id.CONVERT)
     self.assertEqual(self.type_id_of(ndt.make_byteswap(ndt.int32)),
                     _lowlevel.type_id.BYTESWAP)
     self.assertEqual(self.type_id_of(ndt.make_view(
                                 ndt.int32, ndt.uint32)),
                     _lowlevel.type_id.VIEW)
     # CUDA types
     if ndt.cuda_support:
         self.assertEqual(self.type_id_of(ndt.type('cuda_device[int32]')),
                          _lowlevel.type_id.CUDA_DEVICE)
         self.assertEqual(self.type_id_of(ndt.type('cuda_host[int32]')),
                          _lowlevel.type_id.CUDA_HOST)
     # Uniform arrays
     self.assertEqual(self.type_id_of(ndt.type('3 * int32')),
                     _lowlevel.type_id.FIXED_DIM)
     self.assertEqual(self.type_id_of(ndt.type('strided * int32')),
                     _lowlevel.type_id.STRIDED_DIM)
     self.assertEqual(self.type_id_of(ndt.type('var * int32')),
                     _lowlevel.type_id.VAR_DIM)
     # GroupBy
     self.assertEqual(self.type_id_of(nd.type_of(nd.groupby([1, 2],
                                                            ['a', 'a']))),
                     _lowlevel.type_id.GROUPBY)
     # Type
     self.assertEqual(self.type_id_of(ndt.type('type')),
                     _lowlevel.type_id.TYPE)