Ejemplo n.º 1
0
    def test_return_type(self):
        sig, symtab = infer(func_with_signature, functype(int_, [int_]))
        assert sig == int_(int_)

        sig, symtab = infer(func_with_signature, functype(int_, [float_]))
        assert sig == int_(float_)

        sig, symtab = infer(func_with_signature, functype(float_, [int_]))
        assert sig == float_(int_)
Ejemplo n.º 2
0
    def test_rebind_arg(self):
        sig, symtab = infer(arg_rebind, functype(int_, [int_]),
                            allow_rebind_args=True)
        assert sig == int_(int_)
        assert symtab['a'].type == c_string_type

        try:
            sig, symtab = infer(arg_rebind, functype(int_, [int_]),
                                allow_rebind_args=False)
        except minierror.UnpromotableTypeError, e:
            msg = str(sorted(e.args, key=str))
            self.assertEqual("[(double, const char *)]", msg)
Ejemplo n.º 3
0
 def test_none_newaxis(self):
     sig, symtab = infer(none_newaxis, functype(None, [double[:]]))
     self.assertEqual(symtab['f'].type, double[:, :])
     #self.assertEqual(symtab['g'].type, double[:, :])
     self.assertEqual(symtab['h'].type, double[:, :])
     #self.assertEqual(symtab['i'].type, double[:, :])
     #self.assertEqual(symtab['j'].type, double[:, :, :])
     self.assertEqual(symtab['k'].type, double[:, :])
     self.assertEqual(symtab['l'].type, double[:, :])
Ejemplo n.º 4
0
    def test_empty(self):
        sig, symtab = infer(_empty, functype(None, [int_]))
        for i in range(1, 4):
            self.assertEqual(symtab['a%d' % i].type, double[:])

        for i in range(4, 8):
            self.assertEqual(symtab['a%d' % i].type, float_[:])

        self.assertEqual(symtab['a8'].type, int64[:, :])
Ejemplo n.º 5
0
    def test_empty_arg(self):
        from numba import typesystem as nt
        empty_t = nt.ModuleAttributeType(module=np, attr='empty')
        zeros_t = nt.ModuleAttributeType(module=np, attr='zeros')
        ones_t = nt.ModuleAttributeType(module=np, attr='ones')

        sig, symtab = infer(_empty_arg, functype(None, [int_, empty_t,
                                                        zeros_t, ones_t]))
        for i in range(1, 4):
            self.assertEqual(symtab['a%d' % i].type, double[:])
Ejemplo n.º 6
0
    def test_slicing(self):
        sig, symtab = infer(slicing, functype(None, [double[:]]))
        self.assertEqual(symtab['n'].type, typesystem.NewAxisType())

        self.assertEqual(symtab['b'].type, double)
        self.assertEqual(symtab['c'].type, double)
        self.assertEqual(symtab['d'].type, double[:])
        self.assertEqual(symtab['e'].type, double[:])
        self.assertEqual(symtab['f'].type, double[:, :])
        self.assertEqual(symtab['g'].type, double[:, :])
        self.assertEqual(symtab['h'].type, double[:, :])
        self.assertEqual(symtab['i'].type, double[:, :])
        self.assertEqual(symtab['j'].type, double[:, :])
        self.assertEqual(symtab['k'].type, double[:, :])
        self.assertEqual(symtab['l'].type, double[:, :])
Ejemplo n.º 7
0
 def test_rebind_arg(self):
     sig, symtab = infer(arg_rebind, functype(int_, [int_]),
                         allow_rebind_args=True)
     assert sig == int_(int_)
     assert symtab['a'].type == c_string_type
Ejemplo n.º 8
0
 def test_empty_like(self):
     sig, symtab = infer(empty_like, functype(None, [double[:]]))
     self.assertEqual(symtab['b'].type, double[:])
     self.assertEqual(symtab['c'].type, int32[:])
     self.assertEqual(symtab['d'].type, double[:])
Ejemplo n.º 9
0
 def test_type_infer_arange(self):
     sig, symtab = infer(arange, functype())
     self.assertEqual(symtab['a'].type, npy_intp[:])
     self.assertEqual(symtab['b'].type, double[:])
Ejemplo n.º 10
0
 def test_type_infer_for_loop(self):
     sig, symtab = infer(_for_loop, functype(None, [int_, int_, int_]))
     self.assertTrue(symtab['acc'].type.is_int)
     self.assertEqual(symtab['value'].type, Py_ssize_t)
     self.assertEqual(sig.return_type, Py_ssize_t)
Ejemplo n.º 11
0
 def test_type_infer_simple_func(self):
     sig, symtab = infer(_simple_func, functype(None, [double]))
     self.assertEqual(sig.return_type, double)