def __call__(args):
PRECISION = ML_Binary64
value_list = [
FP_PlusInfty(PRECISION),
FP_MinusInfty(PRECISION),
FP_PlusZero(PRECISION),
FP_MinusZero(PRECISION),
FP_QNaN(PRECISION),
FP_SNaN(PRECISION),
#FP_PlusOmega(PRECISION),
#FP_MinusOmega(PRECISION),
NumericValue(7.0),
NumericValue(-3.0),
]
op_map = {
"+": operator.__add__,
"-": operator.__sub__,
"*": operator.__mul__,
}
for op in op_map:
for lhs in value_list:
for rhs in value_list:
print("{} {} {} = {}".format(lhs, op, rhs,
op_map[op](lhs, rhs)))
return True
def generate_value(generator):
""" Generate a single value in the normal range """
field_size = generator.precision.get_field_size()
field = generator.random.randrange(2**field_size)
mantissa = 1.0 + field * S2**-generator.precision.get_field_size(
)
return NumericValue(mantissa)
def generate_normal_number(self):
""" Generate a single value in the normal range """
field_size = self.precision.get_field_size()
exp = self.random.randrange(self.precision.get_emin_normal(),
self.precision.get_emax() + 1)
sign = self.generate_sign()
field = self.random.randrange(2**field_size)
mantissa = 1.0 + field * S2**-self.precision.get_field_size()
return NumericValue(mantissa * sign * S2**exp)
def generate_subnormal_number(self):
""" Generate a single subnormal value """
field_size = self.precision.get_field_size()
# a subnormal has the same exponent as the minimal normal
# but without implicit 1.0 digit
exp = self.precision.get_emin_normal()
sign = self.generate_sign()
field = self.random.randrange(2**field_size)
mantissa = 0.0 + field * S2**-self.precision.get_field_size()
return NumericValue(mantissa * sign * S2**exp)
def generate_value(generator):
""" Generate a single value in the normal range """
field_size = generator.precision.get_field_size()
exp = generator.random.randrange(
generator.precision.get_emin_normal(),
generator.precision.get_emax() + 1)
sign = generator.generate_sign()
field = generator.random.randrange(2**field_size)
mantissa = 1.0 + field * S2**-generator.precision.get_field_size(
)
return NumericValue(mantissa * sign * S2**exp)
def generate_value(self, generator):
# TODO/FIXME random.uniform only generate a machine precision
# number (generally a double) which may not be suitable
# for larger format
field_size = generator.precision.get_field_size()
exp = generator.random.randrange(
generator.precision.get_emin_normal()
if self.min_exp is None else self.min_exp,
(generator.precision.get_emax() +
1) if self.max_exp is None else self.max_exp)
sign = generator.generate_sign()
field = generator.random.randrange(2**field_size)
mantissa = 1.0 + field * S2**-generator.precision.get_field_size(
)
random_value = mantissa * sign * S2**exp
return NumericValue(
min(max(self.inf_bound, random_value), self.sup_bound))