def test_inheritence():
with kb_context("test_inheritence") as context:
spec1 = {"A": "string", "B": "number"}
BOOP1, BOOP1Type = define_fact("BOOP1",
spec1,
context="test_inheritence")
spec2 = {"inherit_from": BOOP1, "C": "number"}
BOOP2, BOOP2Type = define_fact("BOOP2",
spec2,
context="test_inheritence")
spec3 = {"inherit_from": BOOP2, "D": "number"}
BOOP3, BOOP3Type = define_fact("BOOP3",
spec3,
context="test_inheritence")
assert context.parents_of["BOOP3"] == ["BOOP1", "BOOP2"]
assert context.children_of["BOOP3"] == []
assert context.parents_of["BOOP2"] == ["BOOP1"]
assert context.children_of["BOOP2"] == ["BOOP3"]
assert context.parents_of["BOOP1"] == []
assert context.children_of["BOOP1"] == ["BOOP2", "BOOP3"]
b1 = BOOP1("A", 7)
@njit
def check_has_base(b):
return b.idrec
assert check_has_base(b1) == u8(-1)
assert check_has_base.py_func(b1) == u8(-1)
def solve(x0, A, b, omega, tol):
'''Wrapper function to use SOR algorithm to solve Ax = b
Parameters
===========
x0: numpy array
First guess for solution
A: numpy array
matrix describing linear system
b: numpy array
vector of constants
omega: float
relaxation factor
tol: float
error tolerancd for stopping iteration (error for convergence)
'''
# Format dtype of all parameters to numba double precision float
# this helps @njit work correctly
x0 = f8(x0)
A = f8(A)
b = f8(b)
omega = f8(omega)
M = u8(10**6)
tol = f8(tol)
# call actual SOR algorithm (need the numba dtypes to allow njit compile)
x = solve_body(x0, A, b, omega, M, tol)
return x
def get_u64(buf, offset, length):
if length < 8:
return (0, offset, length)
a = nb.u8(buf[offset + 7]) << 54
b = nb.u8(buf[offset + 6]) << 48
c = nb.u8(buf[offset + 5]) << 40
d = nb.u8(buf[offset + 4]) << 32
e = nb.u8(buf[offset + 3]) << 24
f = nb.u8(buf[offset + 2]) << 16
g = nb.u8(buf[offset + 1]) << 8
h = nb.u8(buf[offset + 0]) << 0
return a | b | c | d | e | f | g | h, offset + 8, length - 8
def solve(v0, b, g, omega, tol, theta, lamb):
'''Wrapper function to use SOR algorithm to solve Ax = b
Parameters
===========
xv: numpy array
First guess for solution
b: numpy array
vector to represent A * w
g: numpy array
vector representing early excercise values
omega: float
relaxation factor
tol: float
error tolerancd for stopping iteration (error for convergence)
theta: float
parameter controlling what discretization method is being used
lamb: float
lambda parameter from option pricing model
'''
# Format dtype of all parameters to numba double precision float
# this helps @njit work correctly
v0 = f8(v0)
b = f8(b)
g = f8(g)
omega = f8(omega)
M = u8(10**6)
tol = f8(tol)
theta = f8(theta)
lamb = f8(lamb)
# call actual SOR algorithm (need the numba dtypes to allow njit compile)
x = solve_body(v0, b, g, omega, tol, theta, lamb, M)
return x
# #last field
# # check if actually all fields already taken
# if running_index < 57 and running_index_map >= 0:
# barray_map[end_field_count-1:0] = barray[running_index+7:running_index+8-end_field_count]
# signal_number = barray_map[signalsize-1:0]
if isValuetypeiSigned and barray_msb:
signal_number = twosComplement(signal_number, signalsize)
return signal_number*factor_number+offset_number
# big endian assumption
@njit(numba.u8(numba.u1[:],numba.u1,numba.u1, numba.u4))
def getBigEndiNumberFromBitNpArr(blist, idx, size, id):
signal_number = 0
for i in range (0,size):
signal_number = signal_number | (blist[idx+i] << (size - i - 1))
return signal_number
@njit(numba.u1(numba.u1[:],numba.u1))
def getIsNegativeBigEndianNumberFormBitNpArr(blist, idx):
return blist[idx]
@njit(numba.i4(numba.u1[:], numba.u1, numba.u1[:], numba.u1[:], numba.u1[:], numba.u1[:], numba.f8[:], numba.f8[:], numba.u4))
# @njit((numba.u1[:], numba.u1, numba.u1[:], numba.u1[:], numba.u1[:], numba.u1[:], numba.f8[:], numba.f8[:], numba.u4))
def ppParseSignal(barray_unpacked, signal_no, signal_is_signed_types ,signal_start_bits ,signal_is_integers ,signal_sizes ,signal_offsets ,signal_factors , id):
start_bit_idx = getArrayIdxFromStartBit(signal_start_bits[signal_no])
this_signal_number = getBigEndiNumberFromBitNpArr(barray_unpacked, start_bit_idx, signal_sizes[signal_no], id)
from numba.extending import intrinsic
from numba.core import cgutils
from llvmlite.ir import types as ll_types
#### idrec encoding ####
@njit(Tuple([u2, u8, u1])(u8), cache=True)
def decode_idrec(idrec):
t_id = idrec >> 48
f_id = (idrec >> 8) & 0x000FFFFF
a_id = idrec & 0xF
return (t_id, f_id, a_id)
@njit(u8(u2, u8, u1), cache=True)
def encode_idrec(t_id, f_id, a_id):
return (t_id << 48) | (f_id << 8) | a_id
meminfo_type = types.MemInfoPointer(types.voidptr)
@intrinsic
def lower_setattr(typingctx, inst_type, attr_type, val_type):
if (isinstance(attr_type, types.Literal)
and isinstance(inst_type, types.StructRef)):
attr = attr_type.literal_value
def codegen(context, builder, sig, args):
Algorithms currently implemented:
* xoroshiro128+
References:
* Wikipedia (https://en.wikipedia.org/wiki/Xorshift)
* http://xoroshiro.di.unimi.it/
author: Chase Coleman
date: 21 June 2016
"""
import numpy as np
from numba import jit, f8, u8
_PRNGSTATE = np.array([u8(125), u8(234523)])
@jit("u8(u8, u8)", nopython=True, locals={"sf": u8})
def rotl(x, k):
sf = 64
return (x<<k) | (x >> (sf - k))
@jit("u8(u8[:])", nopython=True, locals={"result": u8, "s0": u8, "s1": u8, "ff": u8, "ft": u8, "ts": u8})
def next(prngstate):
# Pull out the states
s0 = prngstate[0]
s1 = prngstate[1]
# Return their sum
def impl(self, identifier):
return retract_by_idrec(self, u8(identifier))
