def test_ldexp():
rng = np.random.RandomState(seed=42)
x = rng.randn(3, 7).astype(bfloat16)
y = rng.randint(-50, 50, (1, 7))
numpy_assert_allclose(
np.ldexp(x, y).astype(np.float32), np.ldexp(x.astype(np.float32), y),
rtol=1e-2, atol=1e-6)
def test_ldexp_invalid(self):
with pytest.raises(TypeError) as exc:
np.ldexp(3. * u.m, 4.)
# built-in TypeError, so can't check content of exception
with pytest.raises(TypeError) as exc:
np.ldexp(3., 4 * u.m)
assert "Cannot use ldexp" in exc.value.args[0]
def test_ldexp_1(self):
a = np.ldexp(5, np.arange(4))
print(a)
b = np.ldexp(np.arange(4), 5)
print(b)
def test_ldexp_invalid(self):
with pytest.raises(TypeError) as exc:
np.ldexp(3. * u.m, 4.)
# built-in TypeError, so can't check content of exception
with pytest.raises(TypeError) as exc:
np.ldexp(3., 4 * u.m)
assert "Cannot use ldexp" in exc.value.args[0]
def _hdr_read(filename, use_imageio=False):
"""Read hdr file.
.. TODO:
* Support axis other than -Y +X
"""
if use_imageio:
return imageio.imread(filename, **kwargs)
with open(filename, "rb") as f:
MAGIC = f.readline().strip()
assert MAGIC == b'#?RADIANCE', "Wrong header found in {}".format(
filename)
comments = b""
while comments[:6] != b"FORMAT":
comments = f.readline().strip()
assert comments[:3] != b"-Y ", "Could not find data format"
assert comments == b'FORMAT=32-bit_rle_rgbe', "Format not supported"
while comments[:3] != b"-Y ":
comments = f.readline().strip()
_, height, _, width = comments.decode("ascii").split(" ")
height, width = int(height), int(width)
rgbe = np.fromfile(f, dtype=np.uint8).reshape((height, width, 4))
rgb = np.empty((height, width, 3), dtype=np.float)
rgb[..., 0] = np.ldexp(rgbe[..., 0], rgbe[..., 3].astype('int') - 128)
rgb[..., 1] = np.ldexp(rgbe[..., 1], rgbe[..., 3].astype('int') - 128)
rgb[..., 2] = np.ldexp(rgbe[..., 2], rgbe[..., 3].astype('int') - 128)
# TODO: This will rescale all the values to be in [0, 1]. Find a way to retrieve the original values.
rgb /= rgb.max()
return rgb
def _make_stateful_computation_error_model(self):
b = self.parameters.b.astype(float)
a = self.parameters.a.astype(float)
if hasattr(self.parameters, 'k'):
b = np.ldexp(b, self.parameters.k)
a[1:] = np.ldexp(a[1:], self.parameters.k)
n_s = self.states[0][0]
b = np.pad(b, (0, n_s + 1 - len(b)))
a = np.pad(a, (0, n_s + 1 - len(a)))
if n_s > 1:
A = np.zeros((n_s, n_s))
A[0, :] = -a[1:n_s + 1]
A[1:, :-1] = np.eye(n_s - 1)
C = np.array([
-b[0] * a[i] + b[i]
for i in range(1, n_s + 1)
])
else:
A = -a[1]
C = -b[0] * a[1] + b[1]
B = np.zeros((n_s, 2))
B[0, 0] = 1
D = np.array([b[0], 1])
return signal.dlti(A, B, C, D)
def test(n, bits):
print(np.log2(n))
s1 = computeScale(n, bits)
s2 = getScale(n, bits)
v1 = int(np.ldexp(n, -s1))
v2 = int(np.ldexp(n, -s2))
print("%f scale = %d int = %d" % (n, s1, v1))
print("%f scale = %d int = %d" % (n, s2, v2))
def test_ldexp(self):
dtype = np.float64
nvec = 5000
xr, std = generate_random_xr(dtype, nvec=nvec, max_bin_exp=200)
exp = np.asarray(xr["exp"])
out = np.empty(std.shape, dtype)
numba_test_ldexp(std, exp, out)
np.testing.assert_array_equal(out, np.ldexp(std, exp))
numba_test_ldexp(std, -exp, out)
np.testing.assert_array_equal(out, np.ldexp(std, -exp))
def testLdexp(self, float_type):
rng = np.random.RandomState(seed=42)
x = rng.randn(3, 7).astype(float_type)
y = rng.randint(-50, 50, (1, 7)).astype(np.int32)
self.assertEqual(np.ldexp(x, y).dtype, x.dtype)
numpy_assert_allclose(np.ldexp(x, y).astype(np.float32),
truncate(np.ldexp(x.astype(np.float32), y),
float_type=float_type),
rtol=1e-2,
atol=1e-6,
float_type=float_type)
def generate_bound4less1(inp):
a = np.frexp(inp)
if inp==0:
return [-pow(2 ,-1022) ,pow(2 ,-1022)]
if inp < 0:
tmp_i = np.ldexp(-0.5, a[1])
tmp_j = np.ldexp(-0.5, a[1] + 1)
return [tmp_j, tmp_i]
else:
tmp_i = np.ldexp(0.5, a[1])
tmp_j = np.ldexp(0.5, a[1] + 1)
return [tmp_i, tmp_j]
def printModelParamsWithBitwidth(self):
if config.vbwEnabled and forFixed():
for var in self.globalVars:
if var + "idx" in self.globalVars and var + "val" in self.globalVars:
continue
bw = self.varsForBitwidth[var]
typ_str = "int%d_t" % bw
size = self.decls[var].shape
sizestr = ''.join(["[%d]" % (i) for i in size])
Xindexstr = ''
Xintstar = ''.join(["*" for i in size])
if var != 'X':
self.out.printf(typ_str + " " + var + sizestr + ";\n", indent = True)
else:
self.out.printf(typ_str + Xintstar + " " + var + ";\n", indent = True)
for i in range(len(size)):
Xindexstr += ("[i" + str(i-1) + "]" if i > 0 else "")
if var == 'X':
Xintstar = Xintstar[:-1]
self.out.printf("X%s = new %s%s[%d];\n" % (Xindexstr, typ_str, Xintstar, size[i]), indent=True)
self.out.printf("for (int i%d = 0; i%d < %d; i%d ++) {\n" % (i,i,size[i], i), indent = True)
self.out.increaseIndent()
indexstr = ''.join("[i" + str(i) + "]" for i in range(len(size)))
divide = int(round(np.ldexp(1, config.wordLength - self.varsForBitwidth[var] + (self.demotedVarsOffsets.get(var, 0) if self.varsForBitwidth[var] != config.wordLength else 0) ))) if var[-3:] != "idx" and var != "X" else 1
self.out.printf(var + indexstr + " = " + var + "_temp" + indexstr + "/" + str(divide) + ";\n", indent = True)
for i in range(len(size)):
self.out.decreaseIndent()
self.out.printf("}\n", indent = True)
def test_half_ufuncs(self):
"""Test the various ufuncs"""
a = np.array([0, 1, 2, 4, 2], dtype=float16)
b = np.array([-2, 5, 1, 4, 3], dtype=float16)
c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16)
assert_equal(np.add(a, b), [-2, 6, 3, 8, 5])
assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1])
assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6])
assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625])
assert_equal(np.equal(a, b), [False, False, False, True, False])
assert_equal(np.not_equal(a, b), [True, True, True, False, True])
assert_equal(np.less(a, b), [False, True, False, False, True])
assert_equal(np.less_equal(a, b), [False, True, False, True, True])
assert_equal(np.greater(a, b), [True, False, True, False, False])
assert_equal(np.greater_equal(a, b), [True, False, True, True, False])
assert_equal(np.logical_and(a, b), [False, True, True, True, True])
assert_equal(np.logical_or(a, b), [True, True, True, True, True])
assert_equal(np.logical_xor(a, b), [True, False, False, False, False])
assert_equal(np.logical_not(a), [True, False, False, False, False])
assert_equal(np.isnan(c), [False, False, False, True, False])
assert_equal(np.isinf(c), [False, False, True, False, False])
assert_equal(np.isfinite(c), [True, True, False, False, True])
assert_equal(np.signbit(b), [True, False, False, False, False])
assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3])
assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3])
x = np.maximum(b, c)
assert_(np.isnan(x[3]))
x[3] = 0
assert_equal(x, [0, 5, 1, 0, 6])
assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2])
x = np.minimum(b, c)
assert_(np.isnan(x[3]))
x[3] = 0
assert_equal(x, [-2, -1, -np.inf, 0, 3])
assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3])
assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6])
assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2])
assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3])
assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0])
assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2])
assert_equal(np.square(b), [4, 25, 1, 16, 9])
assert_equal(np.reciprocal(b),
[-0.5, 0.199951171875, 1, 0.25, 0.333251953125])
assert_equal(np.ones_like(b), [1, 1, 1, 1, 1])
assert_equal(np.conjugate(b), b)
assert_equal(np.absolute(b), [2, 5, 1, 4, 3])
assert_equal(np.negative(b), [2, -5, -1, -4, -3])
assert_equal(np.positive(b), b)
assert_equal(np.sign(b), [-1, 1, 1, 1, 1])
assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b))
assert_equal(np.frexp(b),
([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2]))
assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
def _expm_product_helper(A, mu, iteration_stash, t, B):
# Estimate expm(t*M).dot(B).
# A = M - mu*I
# mu = mean(trace(M))
# The iteration stash helps to compute numbers of iterations to use.
# t is a scaling factor.
# B is the input matrix for the linear operator.
# Compute some input-dependent constants.
tol = np.ldexp(1, -53)
n0 = B.shape[1]
m, s = iteration_stash.fragment_3_1(n0, t)
#print('1-norm:', A.one_norm(), 't:', t, 'mu:', mu, 'n0:', n0, 'm:', m, 's:', s)
# Get the lapack function for computing matrix norms.
lange, = get_lapack_funcs(('lange', ), (B, ))
F = B
eta = np.exp(t * mu / float(s))
for i in range(s):
c1 = lange('i', B)
for j in range(m):
coeff = t / float(s * (j + 1))
B = coeff * A.dot(B)
c2 = lange('i', B)
F = F + B
if c1 + c2 <= tol * lange('i', F):
break
c1 = c2
F = eta * F
B = F
return F
def convertIntToFloat_array( x, n_bytes ):
int_na = getIntNA( n_bytes )
y = np.zeros( len( x ) )
y[ x == int_na ] = np.nan
y[ x != int_na ] = np.ldexp( x[ x != int_na ], -1 * ( 8 * n_bytes - 2 ) )
return y
def _roots(p):
"""Modified version of NumPy's roots function.
NumPy's roots uses the companion matrix method, which divides by
p[0]. This can causes overflows/underflows. Instead form a
modified companion matrix that is scaled by 2^c * p[0], where the
exponent c is chosen to balance the magnitudes of the
coefficients. Since scaling the matrix just scales the
eigenvalues, we can remove the scaling at the end.
Scaling by a power of 2 is chosen to avoid rounding errors.
"""
_, e = np.frexp(p)
# Balance the most extreme exponents e_max and e_min by solving
# the equation
#
# |c + e_max| = |c + e_min|.
#
# Round the exponent to an integer to avoid rounding errors.
c = int(-0.5 * (np.max(e) + np.min(e)))
p = np.ldexp(p, c)
A = np.diag(np.full(p.size - 2, p[0]), k=-1)
A[0,:] = -p[1:]
eigenvalues = np.linalg.eigvals(A)
return eigenvalues / p[0]
def _expm_product_helper(A, mu, iteration_stash, t, B):
# Estimate expm(t*M).dot(B).
# A = M - mu*I
# mu = mean(trace(M))
# The iteration stash helps to compute numbers of iterations to use.
# t is a scaling factor.
# B is the input matrix for the linear operator.
# Compute some input-dependent constants.
tol = np.ldexp(1, -53)
n0 = B.shape[1]
m, s = iteration_stash.fragment_3_1(n0, t)
#print('1-norm:', A.one_norm(), 't:', t, 'mu:', mu, 'n0:', n0, 'm:', m, 's:', s)
# Get the lapack function for computing matrix norms.
lange, = get_lapack_funcs(('lange',), (B,))
F = B
eta = np.exp(t*mu / float(s))
for i in range(s):
c1 = lange('i', B)
for j in range(m):
coeff = t / float(s*(j+1))
B = coeff * A.dot(B)
c2 = lange('i', B)
F = F + B
if c1 + c2 <= tol * lange('i', F):
break
c1 = c2
F = eta * F
B = F
return F
def _make_stateful_computation_error_model(self):
a = self.parameters.a.astype(float)
if hasattr(self.parameters, 'k'):
a[1:] = np.ldexp(a[1:], self.parameters.k)
n_s = self.states[0][0]
a = np.pad(a, (0, n_s + 1 - len(a)))
if n_s > 1:
A = np.zeros((n_s, n_s))
A[:, 0] = -a[1:n_s + 1]
A[:-1, 1:] = np.eye(n_s - 1)
C = np.zeros((1, n_s))
C[0, 0] = 1
else:
A = -a[1]
C = 1
B = np.zeros((n_s, n_s + 1))
B[:, 0] = -a[1:n_s + 1]
B[:, 1:] = np.eye(n_s)
D = np.zeros((1, n_s + 1))
D[0, 0] = 1
return signal.dlti(A, B, C, D)
def __init__(self,
Q_primary, primary_distn, primary_to_part,
rate_on, rate_off):
"""
"""
# Store the inputs.
self.Q_primary = Q_primary
self.primary_distn = primary_distn
self.primary_to_part = primary_to_part
self.rate_on = rate_on
self.rate_off = rate_off
# Precompute some summaries which can be computed quickly
# and do not use much memory.
# Summaries that are slow or complicated to compute or which may use
# too much memory are computed on demand
# through an explicit function call.
self.nprimary = len(primary_to_part)
self.nparts = len(set(primary_to_part.values()))
self.ncompound = int(np.ldexp(self.nprimary, self.nparts))
self.tolerance_distn = get_tolerance_distn(rate_off, rate_on)
# Mark some attributes as un-initialized.
# These attributes are related to the compound distribution,
# and may be initialized later using init_compound().
self.Q_compound = None
self.compound_distn = None
self.compound_to_primary = None
self.compound_to_tolerances = None
def _pretty(self, printer):
z = sympy.UnevaluatedExpr(sympy.Symbol('z'))
k = getattr(self.parameters, 'k', 0)
num = None
for i, c in enumerate(self.parameters.b):
if c:
term = printer._print(
np.ldexp(float(c), k) * z**-i)
num = num + term if num else term
if num is None:
num = 0
den = printer._print(float(self.parameters.a[0]))
for i, c in enumerate(self.parameters.a[1:], start=1):
if c:
den += printer._print(np.ldexp(float(c), k) * z**-i)
return printer._print(num) / printer._print(den)
def _uniform_sampler(self):
"""
Uniformly sample the full domain of floating-point numbers between (0, 1), rather than only multiples of 2^-53.
A uniform distribution over D ∩ (0, 1) can be generated by independently sampling an exponent
from the geometric distribution with parameter .5 and a significand by drawing a uniform string from
{0, 1}^52 [Mir12]_
Based on code recipe in Python standard library documentation [Py21]_.
Returns
-------
float
A value sampled from float in (0, 1) with probability proportional to the size of the infinite-precision
real interval each float represents
References
----------
.. [Py21] The Python Standard Library. "random — Generate pseudo-random numbers", 2021
https://docs.python.org/3/library/random.html#recipes
"""
mantissa_size = np.finfo(float).nmant
mantissa = 1 << mantissa_size | self._rng.getrandbits(mantissa_size)
exponent = -(mantissa_size + 1)
x = 0
while not x:
x = self._rng.getrandbits(32)
exponent += x.bit_length() - 32
return np.ldexp(mantissa, exponent)
def test_half_ufuncs(self):
"""Test the various ufuncs"""
a = np.array([0, 1, 2, 4, 2], dtype=float16)
b = np.array([-2, 5, 1, 4, 3], dtype=float16)
c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16)
assert_equal(np.add(a, b), [-2, 6, 3, 8, 5])
assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1])
assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6])
assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625])
assert_equal(np.equal(a, b), [False, False, False, True, False])
assert_equal(np.not_equal(a, b), [True, True, True, False, True])
assert_equal(np.less(a, b), [False, True, False, False, True])
assert_equal(np.less_equal(a, b), [False, True, False, True, True])
assert_equal(np.greater(a, b), [True, False, True, False, False])
assert_equal(np.greater_equal(a, b), [True, False, True, True, False])
assert_equal(np.logical_and(a, b), [False, True, True, True, True])
assert_equal(np.logical_or(a, b), [True, True, True, True, True])
assert_equal(np.logical_xor(a, b), [True, False, False, False, False])
assert_equal(np.logical_not(a), [True, False, False, False, False])
assert_equal(np.isnan(c), [False, False, False, True, False])
assert_equal(np.isinf(c), [False, False, True, False, False])
assert_equal(np.isfinite(c), [True, True, False, False, True])
assert_equal(np.signbit(b), [True, False, False, False, False])
assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3])
assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3])
x = np.maximum(b, c)
assert_(np.isnan(x[3]))
x[3] = 0
assert_equal(x, [0, 5, 1, 0, 6])
assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2])
x = np.minimum(b, c)
assert_(np.isnan(x[3]))
x[3] = 0
assert_equal(x, [-2, -1, -np.inf, 0, 3])
assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3])
assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6])
assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2])
assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3])
assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0])
assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2])
assert_equal(np.divmod(a, b), ([0, 0, 2, 1, 0], [0, 1, 0, 0, 2]))
assert_equal(np.square(b), [4, 25, 1, 16, 9])
assert_equal(np.reciprocal(b), [-0.5, 0.199951171875, 1, 0.25, 0.333251953125])
assert_equal(np.ones_like(b), [1, 1, 1, 1, 1])
assert_equal(np.conjugate(b), b)
assert_equal(np.absolute(b), [2, 5, 1, 4, 3])
assert_equal(np.negative(b), [2, -5, -1, -4, -3])
assert_equal(np.positive(b), b)
assert_equal(np.sign(b), [-1, 1, 1, 1, 1])
assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b))
assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2]))
assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
def unpack_bmp_bgra_to_float(bmp):
b = bmp[:, :, 0].astype(np.int32)
g = bmp[:, :, 1].astype(np.int32) << 16
r = bmp[:, :, 2].astype(np.int32) << 8
a = bmp[:, :, 3].astype(np.int32)
depth = np.ldexp(1.0, b -
(128 + 24)) * (g + r + a + 0.5).astype(np.float32)
return depth
def _make_state_observer_models(self):
b = self.parameters.b.astype(float)
a = self.parameters.a.astype(float)
if hasattr(self.parameters, 'k'):
b = np.ldexp(b, self.parameters.k)
a[1:] = np.ldexp(a[1:], self.parameters.k)
n_s = self.states[0][0]
a = np.pad(a, (0, n_s + 1 - len(a)))
b = np.pad(b, (0, n_s + 1 - len(b)))
A = np.zeros((n_s, n_s))
A[:, 0] = -a[1:n_s + 1]
A[:-1, 1:] = np.eye(n_s - 1)
B = np.c_[b[1:n_s + 1] - a[1:n_s + 1] * b[0]]
C = np.eye(n_s)
D = np.zeros((n_s, 1))
return signal.dlti(A, B, C, D),
def nextfloat(fin):
"""Return (approximately) next float value (for f>0)."""
d = 2**-52
split = N.frexp(fin)
while True:
fout = N.ldexp(split[0] + d, split[1])
if fin != fout:
return fout
d *= 2
def nextfloat(fin):
"""Return (approximately) next float value (for f>0)."""
d = 2**-52
split = N.frexp(fin)
while True:
fout = N.ldexp(split[0] + d, split[1])
if fin != fout:
return fout
d *= 2
def visitFloat(self, node:AST.Float, args=None):
r = node.value
p = self.get_expnt(abs(r))
k = IR.DataType.getInt(np.ldexp(r, p))
expr = self.getTempVar()
prog = IR.Prog([IR.Comment('Float to int : {0} to {1}, isSecret = {2}.'.format(str(r), str(k), node.isSecret))])
prog = IRUtil.prog_merge(IR.Prog([IR.Decl(expr.idf, node.type, -1, node.isSecret, [k])]), prog)
if (not(Util.Config.disableTruncOpti)):
self.scaleFacMapping[expr.idf] = self.scaleFac
return (prog, expr)
def decode(self, i):
i = np.array(i)
i = 255 - i
sgn = i > 127
e = np.array(np.floor(i / 16.0) - 8 * sgn + 1, dtype=np.uint8)
f = i % 16
data = np.ldexp(f, e + 2)
e = MuLaw.etab[e-1]
data = MuLaw.iscale * (1 - 2 * sgn) * (e + data)
return data
def _make_model(self):
b = self.parameters.b.astype(float)
a = self.parameters.a.astype(float)
if not self.states:
# Handle degenerate model
return signal.dlti(b[0], a[0])
# From negative to positive powers
pad_width = len(a) - len(b)
if pad_width > 0:
b = np.pad(b, (0, pad_width))
elif pad_width < 0:
a = np.pad(a, (0, -pad_width))
num = np.trim_zeros(b, 'f')
if num.size == 0:
num = b[0:1]
den = np.trim_zeros(a, 'f')
if hasattr(self.parameters, 'k'):
num = np.ldexp(num, self.parameters.k)
den[1:] = np.ldexp(den[1:], self.parameters.k)
return signal.dlti(num, den)
def _make_state_observer_models(self):
a = self.parameters.a.astype(float)
if hasattr(self.parameters, 'k'):
a[1:] = np.ldexp(a[1:], self.parameters.k)
n_s = self.states[0][0]
A = np.zeros((n_s, n_s))
A[0, :len(a) - 1] = -a[1:]
A[1:, :-1] = np.eye(n_s - 1)
B = np.zeros((n_s, 1))
B[0, 0] = 1
C = np.eye(n_s)
D = np.zeros((n_s, 1))
return signal.dlti(A, B, C, D),
def visitFloat(self, node: AST.Float, args=None):
r = node.value
p = self.get_expnt(abs(r))
k = IR.DataType.getInt(np.ldexp(r, p))
comment = IR.Comment('Float to int : ' + str(r) + ' to ' + str(k))
expr = None
if not (node.isSecret):
expr = IR.Int(k)
else:
expr = self.getTempVar()
self.decls[expr.idf] = [node.type]
prog = IRUtil.prog_merge(IR.Prog([IR.Decl(expr.idf, node.type)]), prog)
return (IR.Prog([comment]), expr)
def visitFloat(self, node:AST.Float, args=None):
r = node.value
p = self.get_expnt(abs(r))
k = IR.DataType.getInt(np.ldexp(r, p))
expr = None
prog = IR.Prog([IR.Comment('Float to int : {0} to {1}, isSecret = {2}.'.format(str(r), str(k), node.isSecret))])
if not(node.isSecret):
expr = IR.Int(k)
else:
expr = self.getTempVar()
self.decls[expr.idf] = [node.type]
prog = IRUtil.prog_merge(IR.Prog([IR.Decl(expr.idf, node.type)]), prog)
return (prog, expr)
def populateExpTable(self, p):
[table_m, table_n] = self.expTableShape
b = np.log2(table_n)
# Currently looking at only 2D arrays
assert table_m == 2
[m, M] = self.expRange
max = int(np.ldexp(M - m, -p))
shl = self.getShl(max)
#alpha_count = self.getAlphaCount(max, shl)
alpha_count = table_n
beta_count = table_n
table = [[0 for _ in range(alpha_count)],
[0 for _ in range(beta_count)]]
alpha = Common.wordLength - shl - b
pRes = self.getScale(1)
for i in range(alpha_count):
num = i * 2**(alpha + p)
exp = np.exp(-num)
table[0][i] = int(np.ldexp(exp, -pRes))
beta = alpha - b
pRes = self.getScale(abs(np.exp(-m)))
for i in range(beta_count):
num = m + i * 2**(beta + p)
exp = np.exp(-num)
table[1][i] = int(np.ldexp(exp, -pRes))
tableVar = [
IR.Var('EXP' + str(abs(p)) + 'A', inputVar=True),
IR.Var('EXP' + str(abs(p)) + 'B', inputVar=True)
]
return [table, tableVar]
def from_npfloat(x, prec=113, rnd=round_fast):
"""Create a raw mpf from a numpy float, rounding if necessary.
If prec >= 113, the result is guaranteed to represent exactly the
same number as the input. If prec is not specified, use prec=113."""
y = float(x)
if x == y: # ldexp overflows for float16
return from_float(y, prec, rnd)
import numpy as np
if np.isfinite(x):
m, e = np.frexp(x)
return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd)
if np.isposinf(x): return finf
if np.isneginf(x): return fninf
return fnan
def from_npfloat(x, prec=113, rnd=round_fast):
"""Create a raw mpf from a numpy float, rounding if necessary.
If prec >= 113, the result is guaranteed to represent exactly the
same number as the input. If prec is not specified, use prec=113."""
y = float(x)
if x == y: # ldexp overflows for float16
return from_float(y, prec, rnd)
import numpy as np
if np.isfinite(x):
m, e = np.frexp(x)
return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd)
if np.isposinf(x): return finf
if np.isneginf(x): return fninf
return fnan
def test_roundtrip(self, ftype, frac_vals, exp_vals):
for frac, exp in zip(frac_vals, exp_vals):
f = np.ldexp(frac, exp, dtype=ftype)
n, d = f.as_integer_ratio()
try:
# workaround for gh-9968
nf = np.longdouble(str(n))
df = np.longdouble(str(d))
except (OverflowError, RuntimeWarning):
# the values may not fit in any float type
pytest.skip("longdouble too small on this platform")
assert_equal(nf / df, f, "{}/{}".format(n, d))
def test_roundtrip(self, ftype, frac_vals, exp_vals):
for frac, exp in zip(frac_vals, exp_vals):
f = np.ldexp(frac, exp, dtype=ftype)
n, d = f.as_integer_ratio()
try:
# workaround for gh-9968
nf = np.longdouble(str(n))
df = np.longdouble(str(d))
except (OverflowError, RuntimeWarning):
# the values may not fit in any float type
pytest.skip("longdouble too small on this platform")
assert_equal(nf / df, f, "{}/{}".format(n, d))
def visitFloat(self, node: AST.Float):
val = node.value
scale = self.getScale(abs(val))
intv = self.getInterval(scale, val, val)
val_int = IR.DataType.getInt(np.ldexp(val, -scale))
prog = IR.Prog([])
expr = self.getTempVar()
self.decls[expr.idf] = node.type
self.scales[expr.idf] = scale
self.intvs[expr.idf] = intv
self.cnsts[expr.idf] = val_int
return (prog, expr)
def _cubic_exp2_approx(self, value):
""" Derived from Cardano's formula """
exponent = math.floor(value)
delta_0 = self.B * self.B - 3 * self.A * self.C
delta_1 = (2 * self.B * self.B * self.B -
9 * self.A * self.B * self.C - 27 * self.A * self.A *
(value - exponent))
cardano = np.cbrt(
(delta_1 -
np.sqrt(delta_1 * delta_1 - 4 * delta_0 * delta_0 * delta_0)) / 2)
significand_plus_one = (-(self.B + cardano + delta_0 / cardano) /
(3 * self.A) + 1)
mantissa = significand_plus_one / 2
return np.ldexp(mantissa, exponent + 1)
def tiny_perturbation(arr): fr = numpy.frexp(arr) perturb = numpy.random.random(fr[0].shape) * 1e-12 return numpy.ldexp(fr[0]+perturb, fr[1])
def math():
global a, b, c, z, r
print '###########################'
print '#'
print '# 数学相关'
print '#'
print '###########################'
### 三角函数 ###
print '三角形斜边：\n', np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
print '弧度转角度1：\n', np.degrees(np.arange(12.)*np.pi/6)
print '弧度转角度2：\n', np.rad2deg(np.pi/2)
print '角度转弧度1：\n', np.radians(np.arange(12.)*30)
print '角度转弧度2：\n', np.deg2rad(180)
print '最大距离截断：\n', np.unwrap(np.linspace(0, np.pi, num=5))
### 取整 ###
print '根据位数取整：\n', np.around([0.37, 1.64], decimals=1)
print '四舍五入取整：\n', np.rint([0.37, 1.64])
print '向零取整1：\n', np.fix([-1.5, -0.8, 0.37, 1.64])
print '向零取整2：\n', np.trunc([-1.5, -0.8, 0.37, 1.64])
print '向下取整：\n', np.floor([0.37, 1.64])
print '向上取整：\n', np.ceil([0.37, 1.64])
### 四则运算 ###
print '乘积：\n', np.prod([[1.,2.],[3.,4.]], axis=1)
print '求和：\n', np.sum([[0, 1], [0, 5]], axis=0)
print '累计乘积：\n', np.cumprod([[1, 2], [3, 4]])
print '累计求和：\n', np.cumsum([[1, 2], [3, 4]])
print '求差：\n', np.diff([[1, 2], [3, 4]])
print '一维求差：\n', np.ediff1d([[1, 2], [3, 4]])
print '梯度：\n', np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=np.float))
print '向量积（叉积）：\n', np.cross([1, 2, 3], [4, 5, 6])
print '加法：\n', np.add(np.arange(9).reshape(3, 3), np.arange(3))
print '倒数：\n', np.reciprocal([1, 2., 3.33])
print '负数：\n', np.negative([1.,-1.])
print '乘法：\n', np.multiply(2.0, 4.0)
print '除法：\n', np.divide(5.0, 4.0)
print '除法带小数：\n', np.true_divide(5.0, 4.0)
print '除法向下取整：\n', np.floor_divide(5.0, 4.0)
print '指数：\n', np.power(np.arange(6), 3)
print '减法：\n', np.subtract(1.0, 4.0)
print '求余1：\n', np.mod([-3, -2, -1, 1, 2, 3], 2)
print '求余2：\n', np.fmod([-3, -2, -1, 1, 2, 3], 2)
print '求余3：\n', np.remainder([-3, -2, -1, 1, 2, 3], 2)
print '小数+整数：\n', np.modf([0, 3.5])
### 正负符号 ###
print '负数返回True：\n', np.signbit(np.array([1, -2.3, 2.1]))
# 小于0返回-1, 等于0返回0, 大于0返回1
print '正负符号：\n', np.sign([-5., 0, 4.5])
# 将x2的符号应用到x1上。
print '符号拷贝：\n', np.copysign([-1, 0, 1], -1.1)
# 分解公式：y = x1 * 2**x2
x1, x2 = np.frexp(np.arange(9))
print '指数分解：\n', x1, x2
# 构建公式：y = x1 * 2**x2，是分解公式的逆向操作
print '指数构建：\n', np.ldexp(x1, x2)
### 复数 ###
print '复数转角度：\n', np.angle([1.0, 1.0j, 1+1j])
print '返回实数部分：\n', np.real(np.array([1+2j, 3+4j, 5+6j]))
print '返回实数部分（虚数接近0）：\n', np.real_if_close([2.1 + 4e-14j], tol=1000)
print '返回虚数部分：\n', np.imag(np.array([1+2j, 3+4j, 5+6j]))
print '返回复数共轭矩阵：\n', np.conj(np.eye(2) + 1j * np.eye(2))
### 杂项 ###
print '卷积：\n', np.convolve([1, 2, 3], [0, 1, 0.5])
# 根据指定的区间，小于区间最小值的赋值为最小值，大于区间最大值的赋值为最大值
print '截断：\n', np.clip(np.arange(10), 3, 6)
print '平方根：\n', np.sqrt([4, -1, -3+4J])
print '平方：\n', np.square([-1j, 1])
print '绝对值（含复数）：\n', np.absolute([-1, -2])
print '绝对值2：\n', np.fabs([-1, -2])
print '最大值（含nan）：\n', np.maximum([2, 3, np.nan], [1, 5, 2])
print '最小值（含nan）：\n', np.minimum([2, 3, np.nan], [1, 5, 2])
print '最大值（忽略nan）：\n', np.fmax([2, 3, np.nan], [1, 5, 2])
print '最小值（忽略nan）：\n', np.fmin([2, 3, np.nan], [1, 5, 2])
# 在由xp和fp组成的坐标点中插值
print '线性插值：\n', np.interp([0, 1, 1.5, 2.72, 3.14], xp=[1, 2, 3], fp=[3, 2, 0])
def test_ldexp_invalid(self):
with pytest.raises(TypeError):
np.ldexp(3. * u.m, 4.)
with pytest.raises(TypeError):
np.ldexp(3., u.Quantity(4, u.m, dtype=int))
def test_ldexp_array(self):
assert np.all(np.ldexp(np.array([1., 2., 3.]) * u.m, [3, 2, 1])
== np.array([8., 8., 6.]) * u.m)
def test_ldexp_scalar(self):
assert np.ldexp(4. * u.m, 2) == 16. * u.m
def init_compound(self):
"""
"""
if self.Q_compound is not None:
raise Exception(
'compound attributes should be initialized only once')
if self.ncompound > 1e6:
raise Exception(
'the compound state space is too big')
# Define a compound state space.
self.compound_to_primary = []
self.compound_to_tolerances = []
for primary, tolerances in itertools.product(
range(self.nprimary),
itertools.product((0, 1), repeat=self.nparts)):
self.compound_to_primary.append(primary)
self.compound_to_tolerances.append(tolerances)
# Define the sparse distribution over compound states.
self.compound_distn = {}
for i, (primary, tolerances) in enumerate(
zip(self.compound_to_primary, self.compound_to_tolerances)):
part = self.primary_to_part[primary]
if tolerances[part] == 1:
p_primary = self.primary_distn[primary]
p_tolerances = 1.0
for tolerance_class, tolerance_state in enumerate(tolerances):
if tolerance_class != part:
p_tolerances *= self.tolerance_distn[tolerance_state]
self.compound_distn[i] = p_primary * p_tolerances
# Check the number of entries in the compound state distribution.
if len(self.compound_distn) != np.ldexp(self.nprimary, self.nparts-1):
raise Exception('internal error')
# Check that the distributions have the correct normalization.
# The loop is unrolled to better isolate errors.
if not np.allclose(sum(self.primary_distn.values()), 1):
raise Exception('internal error')
if not np.allclose(sum(self.tolerance_distn.values()), 1):
raise Exception('internal error')
if not np.allclose(sum(self.compound_distn.values()), 1):
raise Exception('internal error')
# Define the compound transition rate matrix.
# Use compound_distn to avoid formal states with zero probability.
# This is slow, but we do not need to be fast.
self.Q_compound = nx.DiGraph()
for i in self.compound_distn:
for j in self.compound_distn:
if i == j:
continue
i_prim = self.compound_to_primary[i]
j_prim = self.compound_to_primary[j]
i_tols = self.compound_to_tolerances[i]
j_tols = self.compound_to_tolerances[j]
tol_pairs = list(enumerate(zip(i_tols, j_tols)))
tol_diffs = [(k, x, y) for k, (x, y) in tol_pairs if x != y]
tol_hdist = len(tol_diffs)
# Look for a tolerance state change.
# Do not allow simultaneous primary and tolerance changes.
# Do not allow more than one simultaneous tolerance change.
# Do not allow changes to the primary tolerance class.
if tol_hdist > 0:
if i_prim != j_prim:
continue
if tol_hdist > 1:
continue
part, i_tol, j_tol = tol_diffs[0]
if part == self.primary_to_part[i_prim]:
continue
# Add the transition rate.
if j_tol:
weight = self.rate_on
else:
weight = self.rate_off
self.Q_compound.add_edge(i, j, weight=weight)
# Look for a primary state change.
# Do not allow simultaneous primary and tolerance changes.
# Do not allow a change to a non-tolerated primary class.
# Do not allow transitions that have zero rate
# in the primary process.
if i_prim != j_prim:
if tol_hdist > 0:
continue
if not i_tols[self.primary_to_part[j_prim]]:
continue
if not self.Q_primary.has_edge(i_prim, j_prim):
continue
# Add the primary state transition rate.
weight = self.Q_primary[i_prim][j_prim]['weight']
self.Q_compound.add_edge(i, j, weight=weight)
import numpy as np np.ldexp(5, np.arange(4)) x = np.arange(6) np.ldexp(*np.frexp(x))
def test_ldexp_array(self):
assert np.all(np.ldexp(np.array([1.0, 2.0, 3.0]) * u.m, [3, 2, 1]) == np.array([8.0, 8.0, 6.0]) * u.m)
def n_ldexp(a, b):
"""safe ldexp"""
return np.ldexp(a, intify(b))
def ldexp_usecase(x, y, result):
np.ldexp(x, y, result)
