Пример #1
0
def expm1(a, b):
    print((numba.typeof(a)))
    print((numba.typeof(np.expm1(a))))
#    result = a**2 + b**2
#    print "... :)"
#    print np.expm1(result), "..."
    return np.expm1(a**2) + b
Пример #2
0
 def check_scal(scal):
     x = 4
     y = 5
     cres = compile_isolated(pyfunc, (typeof(scal), typeof(x), typeof(y)))
     expected = pyfunc(scal, x, y)
     got = cres.entry_point(scal, x, y)
     self.assertPreciseEqual(got, expected)
Пример #3
0
 def test_use_dtype(self):
     # Test using the dtype attribute inside the Numba function itself
     b = np.empty(1, dtype=np.int16)
     pyfunc = use_dtype
     cfunc = self.get_cfunc(pyfunc, (typeof(self.a), typeof(b)))
     expected = pyfunc(self.a, b)
     self.assertPreciseEqual(cfunc(self.a, b), expected)
Пример #4
0
 def test_array_return(self):
     a = numpy.arange(10)
     i = 2
     at, it = typeof(a), typeof(i)
     cres = compile_isolated(array_return, (at, it))
     cfunc = cres.entry_point
     self.assertIs(a, cfunc(a, i))
Пример #5
0
 def test_array_ndenumerate_2d(self):
     arr = np.arange(12).reshape(4, 3)
     arrty = typeof(arr)
     self.assertEqual(arrty.ndim, 2)
     self.assertEqual(arrty.layout, 'C')
     self.assertTrue(arr.flags.c_contiguous)
     # Test with C-contiguous array
     self.check_array_ndenumerate_sum(arr, arrty)
     # Test with Fortran-contiguous array
     arr = arr.transpose()
     self.assertFalse(arr.flags.c_contiguous)
     self.assertTrue(arr.flags.f_contiguous)
     arrty = typeof(arr)
     self.assertEqual(arrty.layout, 'F')
     self.check_array_ndenumerate_sum(arr, arrty)
     # Test with non-contiguous array
     arr = arr[::2]
     self.assertFalse(arr.flags.c_contiguous)
     self.assertFalse(arr.flags.f_contiguous)
     arrty = typeof(arr)
     self.assertEqual(arrty.layout, 'A')
     self.check_array_ndenumerate_sum(arr, arrty)
     # Boolean array
     arr = np.bool_([1, 0, 0, 1]).reshape((2, 2))
     self.check_array_ndenumerate_sum(arr, typeof(arr))
Пример #6
0
 def test_record_type_equiv(self):
     rec_dt = np.dtype([('a', np.int32), ('b', np.float32)])
     rec_ty = typeof(rec_dt)
     art1 = rec_ty[::1]
     arr = np.zeros(5, dtype=rec_dt)
     art2 = typeof(arr)
     self.assertEqual(art2.dtype.dtype, rec_ty)
     self.assertEqual(art1, art2)
Пример #7
0
def test_typeof_numba2(arg):
    """
    >>> test_typeof_numba2(10)
    (10+0j)
    """
    x = 1 + 2j
    arg = numba.typeof(x)(arg)
    return numba.typeof(arg)(arg)
Пример #8
0
 def test_np_ndindex_array(self):
     func = np_ndindex_array
     arr = np.arange(12, dtype=np.int32)
     self.check_array_unary(arr, typeof(arr), func)
     arr = arr.reshape((4, 3))
     self.check_array_unary(arr, typeof(arr), func)
     arr = arr.reshape((2, 2, 3))
     self.check_array_unary(arr, typeof(arr), func)
Пример #9
0
    def run_array_index_test(self, func):
        A1 = np.arange(6).reshape(2,3)
        A2 = A1.copy()
        i = 0
        pfunc = self.compile_parallel(func, (numba.typeof(A1), numba.typeof(i)))

        func(A1, i)
        pfunc(A2, i)
        np.testing.assert_array_equal(A1, A2)
Пример #10
0
 def check(arr, ind):
     arrty = typeof(arr)
     cr = self.ccache.compile(pyfunc, (arrty, typeof(ind), arrty.dtype))
     # Use np.copy() to keep the layout
     expected = np.copy(arr)
     got = np.copy(arr)
     pyfunc(expected, ind, 123)
     cr.entry_point(got, ind, 123)
     self.assertPreciseEqual(got, expected)
Пример #11
0
    def test_sinc(self):
        """
        Tests the sinc() function.
        This test is purely to assert numerical computations are correct.
        """

        # Ignore sign of zeros, this will need masking depending on numpy
        # version once the fix to numpy complex division is in upstream
        # See: https://github.com/numpy/numpy/pull/6699
        isoz = True

        # Testing sinc(1.) leads to sin(pi)/pi, which is below machine
        # precision in practice on most machines. Small floating point
        # differences in sin() etc. may lead to large differences in the result
        # that are at a range that is inaccessible using standard width
        # floating point representations.
        # e.g. Assume float64 type.
        # sin(pi) ~= 1e-16, but should be zero
        # sin(pi)/pi ~= 1e-17, should be zero, error carried from above
        # float64 has log10(2^53)~=15.9 digits of precision and the magnitude
        # change in the alg is > 16  digits (1.0...0 -> 0.0...0),
        # so comparison via ULP is invalid.
        # We therefore opt to assume that values under machine precision are
        # equal in this case.
        tol = "eps"

        pyfunc = sinc

        def check(x_types, x_values, **kwargs):
            self.run_unary(pyfunc, x_types, x_values,
                                ignore_sign_on_zero=isoz, abs_tol=tol,
                                **kwargs)

        # real domain scalar context
        x_values = [1., -1., 0.0, -0.0, 0.5, -0.5, 5, -5, 5e-21, -5e-21]
        x_types = [types.float32, types.float64] * (len(x_values) // 2)
        check(x_types, x_values)

        # real domain vector context
        x_values = [np.array(x_values, dtype=np.float64)]
        x_types = [typeof(v) for v in x_values]
        check(x_types, x_values)

        # complex domain scalar context
        x_values = [1.+0j, -1+0j, 0.0+0.0j, -0.0+0.0j, 0+1j, 0-1j, 0.5+0.0j,
                    -0.5+0.0j, 0.5+0.5j, -0.5-0.5j, 5+5j, -5-5j,
                    # the following are to test sin(x)/x for small x
                    5e-21+0j, -5e-21+0j, 5e-21j, +(0-5e-21j)
                    ]
        x_types = [types.complex64, types.complex128] * (len(x_values) // 2)
        check(x_types, x_values, ulps=2)

        # complex domain vector context
        x_values = [np.array(x_values, dtype=np.complex128)]
        x_types = [typeof(v) for v in x_values]
        check(x_types, x_values, ulps=2)
Пример #12
0
 def check_scal(scal):
     x = 4
     y = 5
     np.random.shuffle(_types)
     x = _types[0](4)
     y = _types[1](5)
     cres = compile_isolated(pyfunc, (typeof(scal), typeof(x), typeof(y)))
     expected = pyfunc(scal, x, y)
     got = cres.entry_point(scal, x, y)
     self.assertPreciseEqual(got, expected)
Пример #13
0
    def check_array_flat(self, arr):
        out = np.zeros(arr.size, dtype=arr.dtype)
        nb_out = out.copy()

        cres = compile_isolated(array_flat, [typeof(arr), typeof(out)])
        cfunc = cres.entry_point

        array_flat(arr, out)
        cfunc(arr, nb_out)

        self.assertTrue(np.all(out == nb_out), (out, nb_out))
Пример #14
0
    def test_simple_literal(self):
        @njit
        def foo():
            d = Dict()
            d[123] = 321
            return d

        k, v = 123, 321
        d = foo()
        self.assertEqual(dict(d), {k: v})
        self.assertEqual(typeof(d).key_type, typeof(k))
        self.assertEqual(typeof(d).value_type, typeof(v))
Пример #15
0
 def check_arr(arr):
     x = np.zeros_like(arr, dtype=np.float64)
     y = np.copy(x)
     x.fill(4)
     y.fill(9)
     cres = compile_isolated(pyfunc, (typeof(arr), typeof(x), typeof(y)))
     expected = pyfunc(arr, x, y)
     got = cres.entry_point(arr, x, y)
     # Contiguity of result varies accross Numpy versions, only
     # check contents.
     self.assertEqual(got.dtype, expected.dtype)
     np.testing.assert_array_equal(got, expected)
Пример #16
0
    def test_simple_args(self):
        @njit
        def foo(k, v):
            d = Dict()
            d[k] = v
            return d

        k, v = 123, 321
        d = foo(k, v)
        self.assertEqual(dict(d), {k: v})
        self.assertEqual(typeof(d).key_type, typeof(k))
        self.assertEqual(typeof(d).value_type, typeof(v))
Пример #17
0
    def test_simple_upcast(self):
        @njit
        def foo(k, v, w):
            d = Dict()
            d[k] = v
            d[k] = w
            return d

        k, v, w = 123, 32.1, 321
        d = foo(k, v, w)
        self.assertEqual(dict(d), {k: w})
        self.assertEqual(typeof(d).key_type, typeof(k))
        self.assertEqual(typeof(d).value_type, typeof(v))
Пример #18
0
    def test_pow_usecase(self):
        args = [
            (2, 3),
            (2.0, 3),
            (2, 3.0),
            (2j, 3.0j),
        ]

        for x, y in args:
            cres = compile_isolated(pow_usecase, (typeof(x), typeof(y)),
                                    flags=no_pyobj_flags)
            r = cres.entry_point(x, y)
            self.assertPreciseEqual(r, pow_usecase(x, y))
Пример #19
0
    def check_array_flat(self, arr, arrty=None):
        out = np.zeros(arr.size, dtype=arr.dtype)
        nb_out = out.copy()
        if arrty is None:
            arrty = typeof(arr)

        cres = compile_isolated(array_flat, [arrty, typeof(out)])
        cfunc = cres.entry_point

        array_flat(arr, out)
        cfunc(arr, nb_out)

        self.assertPreciseEqual(out, nb_out)
Пример #20
0
 def check_arr(arr):
     cres = compile_isolated(pyfunc, (typeof(arr),))
     expected = pyfunc(arr)
     # NOTE: Numpy 1.9 returns readonly arrays for multidimensional
     # arrays.  Workaround this by copying the results.
     expected = [a.copy() for a in expected]
     self.assertPreciseEqual(cres.entry_point(arr), expected)
Пример #21
0
    def test_array_flat_3d(self):
        arr = np.arange(50).reshape(5, 2, 5)

        arrty = typeof(arr)
        self.assertEqual(arrty.ndim, 3)

        out = np.zeros(arr.size, dtype=arr.dtype)
        nb_out = out.copy()

        cres = compile_isolated(array_flat, [arrty, typeof(out)])
        cfunc = cres.entry_point

        array_flat(arr, out)
        cfunc(arr, nb_out)

        self.assertTrue(np.all(out == nb_out))
Пример #22
0
    def test_inspect_cfg(self):
        # Exercise the .inspect_cfg(). These are minimal tests and do not fully
        # check the correctness of the function.
        @jit
        def foo(the_array):
            return the_array.sum()

        # Generate 3 overloads
        a1 = np.ones(1)
        a2 = np.ones((1, 1))
        a3 = np.ones((1, 1, 1))
        foo(a1)
        foo(a2)
        foo(a3)

        # Call inspect_cfg() without arguments
        cfgs = foo.inspect_cfg()

        # Correct count of overloads
        self.assertEqual(len(cfgs), 3)

        # Makes sure all the signatures are correct
        [s1, s2, s3] = cfgs.keys()
        self.assertEqual(set([s1, s2, s3]),
                         set(map(lambda x: (typeof(x),), [a1, a2, a3])))

        for cfg in cfgs.values():
            self._check_cfg_display(cfg)
        self.assertEqual(len(list(cfgs.values())), 3)

        # Call inspect_cfg(signature)
        cfg = foo.inspect_cfg(signature=foo.signatures[0])
        self._check_cfg_display(cfg)
Пример #23
0
def run_comparative(compare_func, test_array):
    arrty = typeof(test_array)
    cres = compile_isolated(compare_func, [arrty])
    numpy_result = compare_func(test_array)
    numba_result = cres.entry_point(test_array)

    return numpy_result, numba_result
Пример #24
0
 def check_arr(arr):
     cres = compile_isolated(pyfunc, (typeof(arr),))
     expected = pyfunc(arr)
     got = cres.entry_point(arr)
     self.assertPreciseEqual(expected, got)
     if check_sameness:
         self.assertEqual(is_same(expected, arr), is_same(got, arr))
Пример #25
0
    def test_c04(self):
        def bar(x):
            f = x
            f[0][0] = 10
            return f

        r = [[np.arange(3)]]
        with self.assertRaises(errors.TypingError) as raises:
            self.compile_and_test(bar, r)
        self.assertIn(
            "invalid setitem with value of {} to element of {}".format(
                typeof(10),
                typeof(r[0][0]),
                ),
            str(raises.exception),
            )
Пример #26
0
    def test_simple_expr(self):
        '''
        Using a simple array expression, verify that rewriting is taking
        place, and is fusing loops.
        '''
        A = np.linspace(0,1,10)
        X = np.linspace(2,1,10)
        Y = np.linspace(1,2,10)
        arg_tys = [typeof(arg) for arg in (A, X, Y)]

        control_pipeline, nb_axy_0, test_pipeline, nb_axy_1 = \
            self._compile_function(axy, arg_tys)

        control_pipeline2 = RewritesTester.mk_no_rw_pipeline(arg_tys)
        cres_2 = control_pipeline2.compile_extra(ax2)
        nb_ctl = cres_2.entry_point

        expected = nb_axy_0(A, X, Y)
        actual = nb_axy_1(A, X, Y)
        control = nb_ctl(A, X, Y)
        np.testing.assert_array_equal(expected, actual)
        np.testing.assert_array_equal(control, actual)

        ir0 = control_pipeline.interp.blocks
        ir1 = test_pipeline.interp.blocks
        ir2 = control_pipeline2.interp.blocks
        self.assertEqual(len(ir0), len(ir1))
        self.assertEqual(len(ir0), len(ir2))
        # The rewritten IR should be smaller than the original.
        self.assertGreater(len(ir0[0].body), len(ir1[0].body))
        self.assertEqual(len(ir0[0].body), len(ir2[0].body))
Пример #27
0
    def test_ufunc_and_dufunc_calls(self):
        '''
        Verify that ufunc and DUFunc calls are being properly included in
        array expressions.
        '''
        A = np.random.random(10)
        B = np.random.random(10)
        arg_tys = [typeof(arg) for arg in (A, B)]

        vaxy_descr = vaxy._dispatcher.targetdescr
        control_pipeline = RewritesTester.mk_no_rw_pipeline(
            arg_tys,
            typing_context=vaxy_descr.typing_context,
            target_context=vaxy_descr.target_context)
        cres_0 = control_pipeline.compile_extra(call_stuff)
        nb_call_stuff_0 = cres_0.entry_point

        test_pipeline = RewritesTester.mk_pipeline(
            arg_tys,
            typing_context=vaxy_descr.typing_context,
            target_context=vaxy_descr.target_context)
        cres_1 = test_pipeline.compile_extra(call_stuff)
        nb_call_stuff_1 = cres_1.entry_point

        expected = call_stuff(A, B)
        control = nb_call_stuff_0(A, B)
        actual = nb_call_stuff_1(A, B)
        np.testing.assert_array_almost_equal(expected, control)
        np.testing.assert_array_almost_equal(expected, actual)

        self._assert_total_rewrite(control_pipeline.interp.blocks,
                                   test_pipeline.interp.blocks)
Пример #28
0
    def test_alias_ctypes(self):
        # use xxnrm2 to test call a C function with ctypes
        from numba.targets.linalg import _BLAS
        xxnrm2 = _BLAS().numba_xxnrm2(types.float64)

        def remove_dead_xxnrm2(rhs, lives, call_list):
            if call_list == [xxnrm2]:
                return rhs.args[4].name not in lives
            return False

        # adding this handler has no-op effect since this function won't match
        # anything else but it's a bit cleaner to save the state and recover
        old_remove_handlers = remove_call_handlers[:]
        remove_call_handlers.append(remove_dead_xxnrm2)

        def func(ret):
            a = np.ones(4)
            xxnrm2(100, 4, a.ctypes, 1, ret.ctypes)

        A1 = np.zeros(1)
        A2 = A1.copy()

        try:
            pfunc = self.compile_parallel(func, (numba.typeof(A1),))
            numba.njit(func)(A1)
            pfunc(A2)
        finally:
            # recover global state
            remove_call_handlers[:] = old_remove_handlers

        self.assertEqual(A1[0], A2[0])
Пример #29
0
 def test_a_is_not_b_array(self):
     pyfunc = a_is_not_b
     ary = numpy.arange(2)
     aryty = typeof(ary)
     cres = compile_isolated(pyfunc, [aryty, aryty])
     cfunc = cres.entry_point
     self.assertTrue(cfunc(ary, ary))
Пример #30
0
    def compile(self, func, *args, **kwargs):
        assert not kwargs
        sig = tuple([numba.typeof(x) for x in args])

        std = compile_isolated(func, sig, flags=self.flags)
        fast = compile_isolated(func, sig, flags=self.fastflags)

        return std, fast
Пример #31
0
    def get(cls, device: Device, targets: List[Element],
            bg_gases: Optional[List[BackgroundGas]] = None,
            options: ModelOptions = DEFAULT_MODEL_OPTIONS) -> AdvancedModel:

        # Types needed by numba
        _T_BG_GAS = numba.typeof(BackgroundGas.get("He", 1e-8))
        _T_F8_ARRAY = numba.float64[:]

        bg_gases = bg_gases or []
        if not bg_gases:
            bg_gases_nblist = numba.typed.List.empty_list(_T_BG_GAS)
        else:
            bg_gases_nblist = numba.typed.List(bg_gases)

        # Determine array bounds for different targets in state vector
        lb = np.zeros(len(targets), dtype=np.int32)
        ub = np.zeros(len(targets), dtype=np.int32)
        offset = 0
        for i, trgt in enumerate(targets):
            lb[i] = offset
            ub[i] = lb[i] + trgt.z + 1
            offset = ub[i]

        # Compute total number of charge states for all targets (len of "n" or "kT" state vector)
        nq = int(ub[-1])

        # Define vectors listing the charge state and mass for each state
        q = np.zeros(nq, dtype=np.int32)
        a = np.zeros(nq, dtype=np.int32)
        for i, trgt in enumerate(targets):
            q[lb[i]:ub[i]] = np.arange(trgt.z + 1, dtype=np.int32)
            a[lb[i]:ub[i]] = np.full(trgt.z + 1, trgt.a, dtype=np.int32)

        # Initialise cross section vectors
        _eixs = np.zeros(nq)
        _rrxs = np.zeros(nq)
        _drxs = np.zeros(nq)
        for i, trgt in enumerate(targets):
            _eixs[lb[i]:ub[i]] = xs.eixs_vec(trgt, device.e_kin)
            _rrxs[lb[i]:ub[i]] = xs.rrxs_vec(trgt, device.e_kin)
            _drxs[lb[i]:ub[i]] = xs.drxs_vec(trgt, device.e_kin, device.fwhm)

        # Precompute CX cross sections (invariant)
        _cxxs_bggas = numba.typed.List.empty_list(_T_F8_ARRAY)
        _cxxs_trgts = numba.typed.List.empty_list(_T_F8_ARRAY)
        for gas in bg_gases:
            _cxxs_bggas.append(xs.cxxs(q, gas.ip))
        for trgt in targets:
            _cxxs_trgts.append(xs.cxxs(q, trgt.ip))
        return cls(
            device=device,
            targets=numba.typed.List(targets),
            bg_gases=bg_gases_nblist,
            options=options,
            lb=lb,
            ub=ub,
            nq=nq,
            q=q,
            a=a,
            eixs=_eixs,
            rrxs=_rrxs,
            drxs=_drxs,
            cxxs_bggas=_cxxs_bggas,
            cxxs_trgts=_cxxs_trgts
        )
Пример #32
0
        traces (np.ndarray): 2d array (Ntrials x Ntime) of evidence traces
    """

    # generate storage objects for data/traces
    data, rProb, traces = gen_ddm_storage_objects(parameters, ntrials,
                                                  deadline)

    # simulate ntrials w/ DDM and fill data & traces array
    _sim_ddm_trials_(parameters, data, rProb, traces)

    # filter data/traces and return as pd.DataFrame
    df, traces = clean_output(data, traces, deadline=deadline)
    return df, traces


@jit(nb.typeof((1.0, 1.0))(float64[:], float64[:], float64[:]), nopython=True)
def sim_ddm(parameters, rProb, trace):
    """ single trial simulation of the DDM (discrete time / random walk)

    ::Arguments::
        parameters: 1d array (Nparams) of DDM parameters
        rProb: 1d array (Ntimesteps) of random floats between 0 and 1
        trace: 1d array (Ntimesteps) for storing the evidence trace

    ::Returns::
        RT (float): the time that evidence crossed one of the boundaries
        choice: 1 if evidence terminated at upper bound, 0 if lower bound
    """

    # extract parameters
    a, tr, v, z, si, dx, dt = parameters
Пример #33
0
 def assert_matches(arr, val, exact):
     expect = conv(arr, val)
     got = jit_conv(arr, val)
     self.assertPreciseEqual(expect, exact)
     self.assertPreciseEqual(typeof(expect), typeof(got))
     self.assertPreciseEqual(expect, got)
Пример #34
0
ufc_form00 = dolfinx.jit.ffcx_jit(a00)
kernel00 = ufc_form00.create_cell_integral(-1).tabulate_tensor

ufc_form01 = dolfinx.jit.ffcx_jit(a01)
kernel01 = ufc_form01.create_cell_integral(-1).tabulate_tensor

ufc_form10 = dolfinx.jit.ffcx_jit(a10)
kernel10 = ufc_form10.create_cell_integral(-1).tabulate_tensor

ffi = cffi.FFI()

cffi_support.register_type(ffi.typeof('double _Complex'),
                           numba.types.complex128)

c_signature = numba.types.void(
    numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
    numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
    numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
    numba.types.CPointer(numba.types.double),
    numba.types.CPointer(numba.types.int32),
    numba.types.CPointer(numba.types.uint8), numba.types.uint32)


@numba.cfunc(c_signature, nopython=True)
def tabulate_condensed_tensor_A(A_,
                                w_,
                                c_,
                                coords_,
                                entity_local_index,
                                permutation=ffi.NULL,
                                cell_permutation_info=0):
Пример #35
0
def typeof(val, c):
    return RegularArrayType(numba.typeof(val.content),
                            numba.typeof(val.identities),
                            util.dict2parameters(val.parameters))
Пример #36
0
 def check_arr(arr):
     cres = compile_isolated(pyfunc, (typeof(arr), ))
     expected = pyfunc(arr)
     expected = [a.copy() for a in expected]
     self.assertPreciseEqual(cres.entry_point(arr), expected)
Пример #37
0
 def _initialise_list(self, item):
     lsttype = types.ListType(typeof(item))
     self._list_type, self._opaque = self._parse_arg(lsttype)
Пример #38
0
 def run(shape):
     cres = self.ccache.compile(pyfunc, (typeof(shape), ))
     return cres.entry_point(shape)
Пример #39
0
 def run(buf):
     cres = self.ccache.compile(pyfunc, (typeof(buf), ))
     return cres.entry_point(buf)
Пример #40
0
import numba


def foo(x):
    for k in x:
        print("k:", k)
        for a, b in x[k]:
            print(a, b)


if sys.argv[-1] == "-c":
    # numba compile
    print("compiling")
    from numba.pycc import CC
    cc = CC('my_module')
    cc.export(
        'foo', 'void(DictType(int64,ListType(UniTuple(int64,2))))')(foo)
    cc.compile()
    exit()
else:
    x = numba.typed.Dict()
    x[1] = numba.typed.List([(1, 2), (3, 4)])
    x[100] = numba.typed.List([(100, 200)])

    if sys.argv[-1] == "-p":
        print(numba.typeof(x))
        # => DictType[int64,ListType[UniTuple(int64 x 2)]]
    else:
        from my_module import foo
        foo(x)
Пример #41
0
 def create_my_class(value):
     cls = jitclass([('value', typeof(value))])(MyClass)
     return cls(value)
Пример #42
0
 def _initialise_dict(self, key, value):
     dcttype = types.DictType(typeof(key), typeof(value))
     self._dict_type, self._opaque = self._parse_arg(dcttype)
Пример #43
0
 def __init__(self, size):
     self.arr = np.zeros(size, dtype=float)
     self.type = nb.typeof(self.arr)
Пример #44
0
def interpolate_compiled(compiled_expression, target_func):
    """Compiled interpolation

    Interpolates UFL expression into target function using FFCx
    code generation and compilation.


    Note
    ----
    Works only for affine-mapped point-evaluation finite elements, e.g.
    lagrange/discontinuous lagrange of arbitrary order.

    """
    kernel = compiled_expression.module[0].tabulate_tensor_float64

    # Register complex types
    cffi_support.register_type(ffi.typeof('double _Complex'),
                               numba.types.complex128)
    cffi_support.register_type(ffi.typeof('float _Complex'),
                               numba.types.complex64)

    # Unpack mesh and dofmap data
    mesh = target_func.function_space.mesh
    geom_dofmap = mesh.geometry.dofmap.array
    geom_pos = mesh.geometry.dofmap.offsets
    geom = mesh.geometry.x
    gdim = mesh.geometry.dim

    dofmap = target_func.function_space.dofmap.list.array

    # Prepare coefficients and their dofmaps
    # Global vectors and dofmaps are prepared here, local are
    # fetched inside hot cell-loop

    # Number of coefficients in ffcx-processed ufl form
    num_coeffs = compiled_expression.module[0].num_coefficients
    # Positions of ffcx-preprocessed coefficients in original form
    cpos = compiled_expression.module[0].original_coefficient_positions

    coeffs = ufl.algorithms.analysis.extract_coefficients(compiled_expression.expr)
    coeffs_dofmaps = List.empty_list(numba.types.Array(numba.typeof(dofmap[0]), 1, "C", readonly=True))
    coeffs_vectors = List.empty_list(numba.types.Array(numba.typeof(PETSc.ScalarType()), 1, "C", readonly=True))
    coeffs_bs = List.empty_list(numba.types.int_)

    for i in range(num_coeffs):
        coeffs_dofmaps.append(coeffs[cpos[i]].function_space.dofmap.list.array)
        coeffs_vectors.append(np.asarray(coeffs[cpos[i]].vector))
        coeffs_bs.append(coeffs[cpos[i]].function_space.dofmap.bs)

    coeffs_sizes = np.asarray([coeff.function_space.element.space_dimension
                               for coeff in coeffs], dtype=np.int_)

    # Prepare and pack constants
    constants = ufl.algorithms.analysis.extract_constants(compiled_expression.expr)
    constants_vector = np.array([], dtype=PETSc.ScalarType())
    if len(constants) > 0:
        constants_vector = np.hstack([c.value.flatten() for c in constants])

    value_size = int(np.product(compiled_expression.expr.ufl_shape))
    basix_space_dim = compiled_expression.ffcx_element.dim
    space_dim = target_func.function_space.element.space_dimension

    dofmap_bs = target_func.function_space.dofmap.bs
    element_bs = target_func.function_space.dofmap.dof_layout.block_size

    # Prepare mapping of subelements into the parent finite element
    # This mapping stores also how dofs are collapsed when symmetry to a TensorElement
    # is applied
    if hasattr(compiled_expression.target_el, "flattened_sub_element_mapping"):
        subel_map = np.array(compiled_expression.target_el.flattened_sub_element_mapping())
    else:
        subel_map = np.array(range(value_size))

    num_coeffs = len(coeffs_vectors)

    with target_func.vector.localForm() as b:
        b.set(0.0)
        assemble_vector_ufc(np.asarray(b), kernel, (geom_dofmap, geom_pos, geom), dofmap,
                            coeffs_vectors, coeffs_dofmaps, coeffs_bs, constants_vector,
                            coeffs_sizes, gdim, basix_space_dim, space_dim,
                            value_size, subel_map, dofmap_bs, element_bs)
Пример #45
0
    for x in range(0, row):
        for y in range(0, col):
            if (img[x, y] == 0):
                xVal += x
                yVal += y
                n += 1.0

    xVal /= n
    yVal /= n

    return [np.int64(np.round(xVal)), np.int64(np.round(yVal))]


@nb.jit(
    nb.typeof(np.matrix([[], []],
                        np.uint8))(nb.typeof(np.matrix([[], []], np.uint8)),
                                   nb.typeof([1, 1]), nb.float64))
def createLine(img, centroid, alpha):
    img2 = np.copy(img)
    row, col = img.shape

    xVal = np.float64(centroid[0])
    yVal = np.float64(centroid[1])

    distance = -1
    distanceTemp = 0

    while ((xVal >= 0 and xVal < row) and (yVal >= 0 and yVal < col)):
        #print(xVal,yVal)
        img2[np.int64(np.floor(xVal)), np.int64(np.floor(yVal))] = 100
        if (img[np.int64(np.floor(xVal)), np.int64(np.floor(yVal))] == 0):
Пример #46
0
import numba
import numpy as np
from numba import float64, int64
from numba import generated_jit, njit
import ast

from numba.extending import overload
from numba.types.containers import Tuple, UniTuple

# from math import max, min

####################
# Dimension helper #
####################

t_coord = numba.typeof((2.3,2.4,1))           # type of an evenly spaced dimension
t_array = numba.typeof(np.array([4.0, 3.9]))  # type of an unevenly spaced dimension

@njit
def clamp(x,a,b):
    return min(b,max(a,x))




# returns the index of a 1d point along a 1d dimension
@generated_jit(nopython=True)
def get_index(gc, x):
    if gc == t_coord:
        # regular coordinate
        def fun(gc,x):
Пример #47
0
            T_inf = 8.2934
            T_sup = 36.0729
        elif self.stage == 'pupa':
            a = 0.0003102
            T_inf = 11.9433
            T_sup = 40
        else:
            return
        mean_rate = a * self.T * (self.T - T_inf) * np.sqrt(T_sup - self.T)
        mean = 0.2789 * density**0.2789 / mean_rate
        self.stage_length = np.random.gamma(mean * 10, 0.1)


# In[22]:

mosquito_type = typeof(Mosquito('egg', 25, 0))
mosquito_list_type = typeof([Mosquito('egg', 25, 0)])

specs = [('egg_numbers', types.ListType(int64)),
         ('larva_numbers', types.ListType(int64)),
         ('pupa_numbers', types.ListType(int64)),
         ('naive_numbers', types.ListType(int64)),
         ('adult_numbers', types.ListType(int64)),
         ('total_numbers', types.ListType(int64)),
         ('Temps', types.ListType(float64)), ('T', float64),
         ('mosquitos', mosquito_list_type)]


@jitclass(specs)
class Population:
    def __init__(self, egg_no, larva_no, pupa_no, naive_no, adult_no, Temps):
Пример #48
0
def lower_getitem_next(context, builder, arraytpe, wheretpe, arrayval,
                       whereval, advanced):
    if len(wheretpe.types) == 0:
        return arrayval

    headtpe = wheretpe.types[0]
    tailtpe = numba.types.Tuple(wheretpe.types[1:])
    headval = numba.cgutils.unpack_tuple(builder, whereval)[0]
    tailval = context.make_tuple(
        builder, tailtpe,
        numba.cgutils.unpack_tuple(builder, whereval)[1:])

    proxyin = numba.cgutils.create_struct_proxy(arraytpe)(context,
                                                          builder,
                                                          value=arrayval)
    leng = util.arraylen(context,
                         builder,
                         arraytpe,
                         arrayval,
                         totpe=numba.int64)

    if isinstance(headtpe, numba.types.Integer):
        assert advanced is None
        nextcarry = util.newindex64(context, builder, numba.int64, leng)
        util.call(context, builder,
                  cpu.kernels.awkward_regulararray_getitem_next_at_64,
                  (util.arrayptr(context, builder, util.index64tpe, nextcarry),
                   util.cast(context, builder, headtpe, numba.int64,
                             headval), leng, proxyin.size),
                  "in {0}, indexing error".format(arraytpe.shortname))
        nextcontenttpe = arraytpe.contenttpe.carry()
        nextcontentval = arraytpe.contenttpe.lower_carry(
            context, builder, arraytpe.contenttpe, util.index64tpe,
            proxyin.content, nextcarry)
        return nextcontenttpe.lower_getitem_next(context, builder,
                                                 nextcontenttpe, tailtpe,
                                                 nextcontentval, tailval,
                                                 advanced)

    elif isinstance(headtpe, numba.types.SliceType):
        proxyslicein = context.make_helper(builder, headtpe, value=headval)
        numba.targets.slicing.guard_invalid_slice(context, builder, headtpe,
                                                  proxyslicein)
        numba.targets.slicing.fix_slice(
            builder, proxyslicein,
            util.cast(context, builder, numba.int64, numba.intp, proxyin.size))
        nextsize = util.cast(
            context, builder, numba.intp, numba.int64,
            numba.targets.slicing.get_slice_length(builder, proxyslicein))

        nextcarry = util.newindex64(context, builder, numba.int64,
                                    builder.mul(leng, nextsize))
        util.call(context, builder,
                  cpu.kernels.awkward_regulararray_getitem_next_range_64,
                  (util.arrayptr(context, builder, util.index64tpe, nextcarry),
                   util.cast(context, builder, numba.intp, numba.int64,
                             proxyslicein.start),
                   util.cast(context, builder, numba.intp, numba.int64,
                             proxyslicein.step), leng, proxyin.size, nextsize),
                  "in {0}, indexing error".format(arraytpe.shortname))

        nextcontenttpe = arraytpe.contenttpe.carry()
        nextcontentval = arraytpe.contenttpe.lower_carry(
            context, builder, arraytpe.contenttpe, util.index64tpe,
            proxyin.content, nextcarry)

        if advanced is None:
            outcontenttpe = nextcontenttpe.getitem_next(tailtpe, False)
            outcontentval = nextcontenttpe.lower_getitem_next(
                context, builder, nextcontenttpe, tailtpe, nextcontentval,
                tailval, advanced)

        else:
            nextadvanced = util.newindex64(context, builder, numba.int64,
                                           builder.mul(leng, nextsize))
            util.call(
                context, builder, cpu.kernels.
                awkward_regulararray_getitem_next_range_spreadadvanced_64,
                (util.arrayptr(context, builder, util.index64tpe,
                               nextadvanced),
                 util.arrayptr(context, builder, util.index64tpe,
                               advanced), leng, nextsize),
                "in {0}, indexing error".format(arraytpe.shortname))

            outcontenttpe = nextcontenttpe.getitem_next(tailtpe, True)
            outcontentval = nextcontenttpe.lower_getitem_next(
                context, builder, nextcontenttpe, tailtpe, nextcontentval,
                tailval, nextadvanced)

        outtpe = RegularArrayType(outcontenttpe, arraytpe.identitiestpe,
                                  arraytpe.parameters)
        proxyout = numba.cgutils.create_struct_proxy(outtpe)(context, builder)
        proxyout.content = outcontentval
        proxyout.size = nextsize
        if arraytpe.identitiestpe != numba.none:
            proxyout.identities = proxyin.identities
        return proxyout._getvalue()

    elif isinstance(headtpe, numba.types.StringLiteral):
        nexttpe = arraytpe.getitem_str(headtpe.literal_value)
        nextval = lower_getitem_str(context, builder,
                                    nexttpe(arraytpe,
                                            headtpe), (arrayval, headval))
        return lower_getitem_next(context, builder, nexttpe, tailtpe, nextval,
                                  tailval, advanced)

    elif isinstance(headtpe, numba.types.EllipsisType):
        raise NotImplementedError("RegularArray.getitem_next(ellipsis)")

    elif isinstance(headtpe, type(numba.typeof(numpy.newaxis))):
        raise NotImplementedError("RegularArray.getitem_next(newaxis)")

    elif isinstance(headtpe, numba.types.Array):
        if headtpe.ndim != 1:
            raise NotImplementedError("array.ndim != 1")

        flathead = numba.targets.arrayobj.array_ravel(context, builder,
                                                      util.index64tpe(headtpe),
                                                      (headval, ))
        lenflathead = util.arraylen(context,
                                    builder,
                                    util.index64tpe,
                                    flathead,
                                    totpe=numba.int64)
        regular_flathead = util.newindex64(context, builder, numba.int64,
                                           lenflathead)

        util.call(
            context, builder,
            cpu.kernels.awkward_regulararray_getitem_next_array_regularize_64,
            (util.arrayptr(context, builder, util.index64tpe,
                           regular_flathead),
             util.arrayptr(context, builder, util.index64tpe,
                           flathead), lenflathead, proxyin.size),
            "in {0}, indexing error".format(arraytpe.shortname))

        if advanced is None:
            lencarry = builder.mul(leng, lenflathead)
            nextcarry = util.newindex64(context, builder, numba.int64,
                                        lencarry)
            nextadvanced = util.newindex64(context, builder, numba.int64,
                                           lencarry)

            util.call(
                context, builder,
                cpu.kernels.awkward_regulararray_getitem_next_array_64,
                (util.arrayptr(context, builder, util.index64tpe, nextcarry),
                 util.arrayptr(context, builder, util.index64tpe,
                               nextadvanced),
                 util.arrayptr(
                     context, builder, util.index64tpe,
                     regular_flathead), leng, lenflathead, proxyin.size),
                "in {0}, indexing error".format(arraytpe.shortname))

            nexttpe = arraytpe.contenttpe.carry()
            nextval = arraytpe.contenttpe.lower_carry(context, builder,
                                                      arraytpe.contenttpe,
                                                      util.index64tpe,
                                                      proxyin.content,
                                                      nextcarry)

            contenttpe = nexttpe.getitem_next(tailtpe, True)
            contentval = nexttpe.lower_getitem_next(context, builder, nexttpe,
                                                    tailtpe, nextval, tailval,
                                                    nextadvanced)

            outtpe = RegularArrayType(contenttpe, arraytpe.identitiestpe,
                                      arraytpe.parameters)
            proxyout = numba.cgutils.create_struct_proxy(outtpe)(context,
                                                                 builder)
            proxyout.content = contentval
            proxyout.size = lenflathead
            if outtpe.identitiestpe != numba.none:
                proxyout.identities = awkward1._numba.identities.lower_getitem_any(
                    context, builder, outtpe.identitiestpe, util.index64tpe,
                    proxyin.identities, flathead)
            return proxyout._getvalue()

        else:
            nextcarry = util.newindex64(context, builder, numba.int64, leng)
            nextadvanced = util.newindex64(context, builder, numba.int64, leng)

            util.call(
                context, builder, cpu.kernels.
                awkward_regulararray_getitem_next_array_advanced_64,
                (util.arrayptr(context, builder, util.index64tpe, nextcarry),
                 util.arrayptr(context, builder, util.index64tpe,
                               nextadvanced),
                 util.arrayptr(context, builder, util.index64tpe, advanced),
                 util.arrayptr(
                     context, builder, util.index64tpe,
                     regular_flathead), leng, lenflathead, proxyin.size),
                "in {0}, indexing error".format(arraytpe.shortname))

            nexttpe = arraytpe.contenttpe.carry()
            nextval = arraytpe.contenttpe.lower_carry(context, builder,
                                                      arraytpe.contenttpe,
                                                      util.index64tpe,
                                                      proxyin.content,
                                                      nextcarry)

            outtpe = nexttpe.getitem_next(tailtpe, True)
            return nexttpe.lower_getitem_next(context, builder, nexttpe,
                                              tailtpe, nextval, tailval,
                                              nextadvanced)

    else:
        raise AssertionError(headtpe)
Пример #49
0
locale.setlocale(locale.LC_NUMERIC, "C")

# Used for a floating point "nearly zero" comparison
EPS = 1e-8
INT32_MIN = np.iinfo(np.int32).min + 1
INT32_MAX = np.iinfo(np.int32).max - 1

FlatTree = namedtuple(
    "FlatTree", ["hyperplanes", "offsets", "children", "indices", "leaf_size"]
)

dense_hyperplane_type = numba.float32[::1]
sparse_hyperplane_type = numba.float64[:, ::1]
offset_type = numba.float64
children_type = numba.typeof((np.int32(-1), np.int32(-1)))
point_indices_type = numba.int32[::1]


@numba.njit(
    numba.types.Tuple(
        (numba.int32[::1], numba.int32[::1], dense_hyperplane_type, offset_type)
    )(numba.float32[:, ::1], numba.int32[::1], numba.int64[::1]),
    locals={
        "n_left": numba.uint32,
        "n_right": numba.uint32,
        "hyperplane_vector": numba.float32[::1],
        "hyperplane_offset": numba.float32,
        "margin": numba.float32,
        "d": numba.uint32,
        "i": numba.uint32,
Пример #50
0
 def check(a, b, expected):
     cres = compile_isolated(pyfunc, (typeof(a), typeof(b)))
     self.assertPreciseEqual(cres.entry_point(a, b),
                             (expected, not expected))
Пример #51
0
    def get_conn_flattened(self, x, sections, pad=False):
        batch_size = x.shape[0]
        N = x.shape[1] // 2
        n_jops = len(self.jump_operators)
        assert sections.shape[0] == batch_size

        # Separate row and column inputs
        xr, xc = x[:, 0:N], x[:, N:2 * N]

        # Compute all flattened connections of each term
        sections_r = np.empty(batch_size, dtype=np.int64)
        sections_c = np.empty(batch_size, dtype=np.int64)
        xr_prime, mels_r = self._Hnh.get_conn_flattened(xr, sections_r)
        xc_prime, mels_c = self._Hnh.get_conn_flattened(xc, sections_c)

        if pad:
            # if else to accomodate for batches of 1 element, because
            # sections don't start from 0-index...
            # TODO: if we ever switch to 0-indexing, remove this.
            if batch_size > 1:
                max_conns_r = np.max(np.diff(sections_r))
                max_conns_c = np.max(np.diff(sections_c))
            else:
                max_conns_r = sections_r[0]
                max_conns_c = sections_c[0]
            max_conns_Lrc = 0

        #  Must type those lists otherwise, if they are empty, numba
        # cannot infer their type
        L_xrps = List.empty_list(numba.typeof(x.dtype)[:, :])
        L_xcps = List.empty_list(numba.typeof(x.dtype)[:, :])
        L_mel_rs = List.empty_list(numba.typeof(self.dtype())[:])
        L_mel_cs = List.empty_list(numba.typeof(self.dtype())[:])

        sections_Lr = np.empty(batch_size * n_jops, dtype=np.int32)
        sections_Lc = np.empty(batch_size * n_jops, dtype=np.int32)
        for (i, L) in enumerate(self._jump_ops):
            L_xrp, L_mel_r = L.get_conn_flattened(
                xr, sections_Lr[i * batch_size:(i + 1) * batch_size])
            L_xcp, L_mel_c = L.get_conn_flattened(
                xc, sections_Lc[i * batch_size:(i + 1) * batch_size])

            L_xrps.append(L_xrp)
            L_xcps.append(L_xcp)
            L_mel_rs.append(L_mel_r)
            L_mel_cs.append(L_mel_c)

            if pad:
                if batch_size > 1:
                    max_lr = np.max(
                        np.diff(sections_Lr[i * batch_size:(i + 1) *
                                            batch_size]))
                    max_lc = np.max(
                        np.diff(sections_Lc[i * batch_size:(i + 1) *
                                            batch_size]))
                else:
                    max_lr = sections_Lr[i * batch_size]
                    max_lc = sections_Lc[i * batch_size]

                max_conns_Lrc += max_lr * max_lc

        # compose everything again
        if self._xprime_f.shape[0] < self._max_conn_size * batch_size:
            # refcheck=False because otherwise this errors when testing
            self._xprime_f.resize(self._max_conn_size * batch_size,
                                  self.hilbert.size,
                                  refcheck=False)
            self._mels_f.resize(self._max_conn_size * batch_size,
                                refcheck=False)

        if pad:
            pad = max_conns_Lrc + max_conns_r + max_conns_c
        else:
            pad = 0

        self._xprime_f[:] = 0
        self._mels_f[:] = 0

        return self._get_conn_flattened_kernel(
            self._xprime_f,
            self._mels_f,
            sections,
            np.asarray(xr),
            np.asarray(xc),
            sections_r,
            sections_c,
            xr_prime,
            mels_r,
            xc_prime,
            mels_c,
            L_xrps,
            L_xcps,
            L_mel_rs,
            L_mel_cs,
            sections_Lr,
            sections_Lc,
            n_jops,
            batch_size,
            N,
            pad,
        )
Пример #52
0
 def check_arr(arr):
     cres = compile_isolated(pyfunc, (typeof(arr), ))
     expected = pyfunc(arr)
     got = cres.entry_point(arr)
     self.assertPreciseEqual(expected, got)
     self.assertEqual(is_same(expected, arr), is_same(got, arr))
Пример #53
0
def test_typeof_type(arg):
    """
    >>> test_typeof_type(int_)
    meta(int)
    """
    return numba.typeof(arg)
Пример #54
0
using_numba = True
try:
    from numba import b1, f8, i2, i4, njit, typeof, u2
except ImportError:
    using_numba = False
    # replace numba functionality with "transparent" implementations
    from timezonefinder._numba_replacements import b1, f8, i2, i4, njit, typeof, u2

from timezonefinder.configs import (
    COORD2INT_FACTOR,
    INT2COORD_FACTOR,
    OCEAN_TIMEZONE_PREFIX,
)

dtype_3float_tuple = typeof((1.0, 1.0, 1.0))
dtype_2float_tuple = typeof((1.0, 1.0))
dtype_2int_tuple = typeof((1, 1))


# @cc.export('inside_polygon', 'b1(i4, i4, i4[:, :])')
@njit(b1(i4, i4, i4[:, :]), cache=True)
def inside_polygon(x, y, coordinates):
    """
    Implementing the ray casting point in polygon test algorithm
    cf. https://en.wikipedia.org/wiki/Point_in_polygon#Ray_casting_algorithm
    :param x:
    :param y:
    :param coordinates: a polygon represented by a list containing two lists (x and y coordinates):
        [ [x1,x2,x3...], [y1,y2,y3...]]
        those lists are actually numpy arrays which are being read directly from a binary file
Пример #55
0
@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               numba.types.BaseTuple)
def lower_getitem_tuple(context, builder, sig, args):
    return content.lower_getitem_tuple(context, builder, sig, args)


@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               numba.types.Array)
@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               numba.types.List)
@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               numba.types.ArrayCompatible)
@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               numba.types.EllipsisType)
@numba.extending.lower_builtin(operator.getitem, ListArrayType,
                               type(numba.typeof(numpy.newaxis)))
def lower_getitem_other(context, builder, sig, args):
    return content.lower_getitem_other(context, builder, sig, args)


def lower_getitem_next(context, builder, arraytpe, wheretpe, arrayval,
                       whereval, advanced):
    import awkward1._numba.array.listoffsetarray
    import awkward1._numba.array.regulararray

    if len(wheretpe.types) == 0:
        return arrayval

    headtpe = wheretpe.types[0]
    tailtpe = numba.types.Tuple(wheretpe.types[1:])
    headval = numba.cgutils.unpack_tuple(builder, whereval)[0]
Пример #56
0
 def run(arr, dtype):
     pyfunc = make_array_astype(dtype)
     cres = self.ccache.compile(pyfunc, (typeof(arr), ))
     return cres.entry_point(arr)
Пример #57
0
def typeof(val, c):
    return ListArrayType(numba.typeof(numpy.asarray(val.starts)),
                         numba.typeof(numpy.asarray(val.stops)),
                         numba.typeof(val.content),
                         numba.typeof(val.identities),
                         util.dict2parameters(val.parameters))
Пример #58
0

def is_model(agents, model):
    """Test if agent if type same type as model name

    Args:
        agents (numpy.ndarray):
        model (str):

    Returns:
        bool:
    """
    return hash(agents.dtype) == hash(AgentModelToType[model])


@numba.jit(void(typeof(agent_type_three_circle)[:]),
           nopython=True,
           nogil=True,
           cache=True)
def shoulders(agents):
    """Positions of the center of mass, left- and right shoulders.

    Args:
        agents (ndarray):
            Numpy array of datatype ``dtype=agent_type_three_circle``.
    """
    for agent in agents:
        tangent = rotate270(unit_vector(agent['orientation']))
        offset = tangent * agent['r_ts']
        agent['position_ls'][:] = agent['position'] - offset
        agent['position_rs'][:] = agent['position'] + offset
Пример #59
0
 def bar(x):
     if isinstance(typeof(x), types.Float):
         return x + 1234
     else:
         return x + 1
Пример #60
0
 def create_my_class(value):
     cls = jitclass(MyClass, [("value", typeof(value))])
     return cls(value)