def light_test_from_number_rounding(number, low, high, ndigits, experimental=False):
"""
This fucntion ...
:param number:
:param low:
:param high:
:param ndigits:
:param experimental:
:return:
"""
# Detrmine number of bits
if experimental: nbits = numbers.nbits_for_ndigits_experimental(ndigits, low, high)
else: nbits = numbers.binary_digits_for_significant_figures(ndigits)
number_back = number_to_binary_and_back(number, low, high, nbits)
largest_error = 0.5 * (high - low) / numbers.nintegers_for_nbits(nbits)
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
number_back_rounded = numbers.round_to_n_significant_digits(number_back, ndigits)
if number_back_rounded != number_rounded:
print(str(number_rounded) + " != " + str(number_back_rounded))
abserror = abs(number_back_rounded - number_rounded)
rel = abserror / number_rounded
print("rel error:", rel * 100, "%")
print("abs error:", abserror)
print("largest error:", largest_error)
else: print(str(number_rounded) + " == " + str(number_back_rounded))
# Check
return number_back_rounded == number_rounded
def light_test_from_number_no_rounding(number, low, high, ndigits):
"""
This function ...
:param number:
:param low:
:param high:
:param ndigits:
:return:
"""
# ACTUALLY THIS FUNCTION CAN BE EXPECTED TO FAIL!!
# Detrmine number of bits
nbits = numbers.binary_digits_for_significant_figures(ndigits)
number_back = number_to_binary_and_back(number, low, high, nbits)
largest_error = 0.5 * (high - low) / numbers.nintegers_for_nbits(nbits)
if number_back != number:
print(str(number) + " != " + str(number_back))
abserror = abs(number_back - number)
rel = abs((number_back - number) / number)
print("rel error:", rel * 100, "%")
print("abs error:", abserror)
print("largest error:", largest_error)
else:
print(str(number) + " == " + str(number_back))
return number_back == number
def light_test_from_number_no_rounding(number, low, high, ndigits):
"""
This function ...
:param number:
:param low:
:param high:
:param ndigits:
:return:
"""
# ACTUALLY THIS FUNCTION CAN BE EXPECTED TO FAIL!!
# Detrmine number of bits
nbits = numbers.binary_digits_for_significant_figures(ndigits)
number_back = number_to_binary_and_back(number, low, high, nbits)
largest_error = 0.5 * (high - low) / numbers.nintegers_for_nbits(nbits)
if number_back != number:
print(str(number) + " != " + str(number_back))
abserror = abs(number_back - number)
rel = abs((number_back - number) / number)
print("rel error:", rel * 100, "%")
print("abs error:", abserror)
print("largest error:", largest_error)
else: print(str(number) + " == " + str(number_back))
return number_back == number
def test_dust_mass(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Testing the dust mass ...")
ndigits = 4
nbits = numbers.binary_digits_for_significant_figures(ndigits)
print(str(nbits) + " bits for " + str(ndigits) + " digits")
mass_range = parsing.quantity_range("1500000.0 Msun > 300000000.0 Msun")
unit = "Msun"
minimum = mass_range.min
maximum = mass_range.max
low = minimum.to(unit).value
high = maximum.to(unit).value
value = parse_quantity("1.5e7 Msun").to(unit).value
# Test : ROUNDING IN TEST BUT NOT IN BETWEEN CONVERSION!!
if light_test_from_number_rounding(value, low, high, ndigits): log.success("Test succeeded")
else: log.error("Test failed")
def test_dust_mass_with_rounding(self):
"""
This fucntion ...
:return:
"""
# Inform the user
log.info("Testing dust mass with rounding ...")
ndigits = 4
nbits = numbers.binary_digits_for_significant_figures(ndigits)
#print(str(nbits) + " bits for " + str(ndigits) + " digits")
mass_range = parsing.quantity_range(
"1500000.0 Msun > 300000000.0 Msun")
unit = "Msun"
minimum = mass_range.min
maximum = mass_range.max
low = minimum.to(unit).value
high = maximum.to(unit).value
# (FROM ERROR RESULTS IN MODELING:)
# WITH ROUNDING:
binary_string_a = [1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
binary_string_b = [1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0]
if test_from_binary_string_rounding(binary_string_a, low, high,
ndigits):
log.success("Test succeeded")
else:
log.error("Test failed")
if test_from_binary_string_rounding(binary_string_b, low, high,
ndigits):
log.success("Test succeeded")
else:
log.error("Test failed")
# Convert to numbers
number_a = numbers.binary_string_to_float(binary_string_a, low, high,
nbits)
number_b = numbers.binary_string_to_float(binary_string_b, low, high,
nbits)
if test_from_number_rounding(number_a, low, high, ndigits):
log.success("Test succeeded")
else:
log.error("Test failed")
if test_from_number_rounding(number_b, low, high, ndigits):
log.success("Test succeeded")
else:
log.error("Test failed")
def test_dust_mass(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Testing the dust mass ...")
ndigits = 4
nbits = numbers.binary_digits_for_significant_figures(ndigits)
print(str(nbits) + " bits for " + str(ndigits) + " digits")
mass_range = parsing.quantity_range(
"1500000.0 Msun > 300000000.0 Msun")
unit = "Msun"
minimum = mass_range.min
maximum = mass_range.max
low = minimum.to(unit).value
high = maximum.to(unit).value
value = parse_quantity("1.5e7 Msun").to(unit).value
# Test : ROUNDING IN TEST BUT NOT IN BETWEEN CONVERSION!!
if light_test_from_number_rounding(value, low, high, ndigits):
log.success("Test succeeded")
else:
log.error("Test failed")
def test_from_number_rounding(number, low, high, ndigits, experimental=False):
"""
This function ...
:param number:
:param low:
:param high:
:param ndigits:
:param experimental:
:return:
"""
# Detrmine number of bits
if experimental:
nbits = numbers.nbits_for_ndigits_experimental(ndigits, low, high)
else:
nbits = numbers.binary_digits_for_significant_figures(ndigits)
# Number a to binary
number_binary_string = numbers.float_to_binary_string(
number, low, high, nbits)
# back to number
number_back = numbers.binary_string_to_float(number_binary_string, low,
high, nbits)
#print("")
#print("SHOULD BE OK:")
#print(number)
#print(number_back)
#print("")
# NOW ROUND TO THE NUMBER OF DIGITS
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
#print("FAILS?")
#print(number)
##print(number_rounded)
# NOW CONVERT
number_rounded_binary_string = numbers.float_to_binary_string(
number_rounded, low, high, nbits)
# Back to number
number_rounded_back = numbers.binary_string_to_float(
number_rounded_binary_string, low, high, nbits)
#print(number_rounded_back)
#print("")
# Round
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
number_rounded_back_rounded = numbers.round_to_n_significant_digits(
number_rounded_back, ndigits)
# Check
#return number_rounded_back == number
return number_rounded == number_rounded_back_rounded
def test_from_number_rounding(number, low, high, ndigits, experimental=False):
"""
This function ...
:param number:
:param low:
:param high:
:param ndigits:
:param experimental:
:return:
"""
# Detrmine number of bits
if experimental: nbits = numbers.nbits_for_ndigits_experimental(ndigits, low, high)
else: nbits = numbers.binary_digits_for_significant_figures(ndigits)
# Number a to binary
number_binary_string = numbers.float_to_binary_string(number, low, high, nbits)
# back to number
number_back = numbers.binary_string_to_float(number_binary_string, low, high, nbits)
#print("")
#print("SHOULD BE OK:")
#print(number)
#print(number_back)
#print("")
# NOW ROUND TO THE NUMBER OF DIGITS
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
#print("FAILS?")
#print(number)
##print(number_rounded)
# NOW CONVERT
number_rounded_binary_string = numbers.float_to_binary_string(number_rounded, low, high, nbits)
# Back to number
number_rounded_back = numbers.binary_string_to_float(number_rounded_binary_string, low, high, nbits)
#print(number_rounded_back)
#print("")
# Round
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
number_rounded_back_rounded = numbers.round_to_n_significant_digits(number_rounded_back, ndigits)
# Check
#return number_rounded_back == number
return number_rounded == number_rounded_back_rounded
def test_from_binary_rounding(binary, low, high, ndigits):
"""
This function ...
:return:
"""
# Detrmine number of bits
nbits = numbers.binary_digits_for_significant_figures(ndigits)
# To number
number = numbers.binary_to_float(binary, low, high, nbits)
# Test from number
return test_from_number_rounding(number, low, high, ndigits)
def test_from_binary_rounding(binary, low, high, ndigits):
"""
This function ...
:return:
"""
# Detrmine number of bits
nbits = numbers.binary_digits_for_significant_figures(ndigits)
# To number
number = numbers.binary_to_float(binary, low, high, nbits)
# Test from number
return test_from_number_rounding(number, low, high, ndigits)
def test_dust_mass_with_rounding(self):
"""
This fucntion ...
:return:
"""
# Inform the user
log.info("Testing dust mass with rounding ...")
ndigits = 4
nbits = numbers.binary_digits_for_significant_figures(ndigits)
#print(str(nbits) + " bits for " + str(ndigits) + " digits")
mass_range = parsing.quantity_range("1500000.0 Msun > 300000000.0 Msun")
unit = "Msun"
minimum = mass_range.min
maximum = mass_range.max
low = minimum.to(unit).value
high = maximum.to(unit).value
# (FROM ERROR RESULTS IN MODELING:)
# WITH ROUNDING:
binary_string_a = [1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
binary_string_b = [1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0]
if test_from_binary_string_rounding(binary_string_a, low, high, ndigits): log.success("Test succeeded")
else: log.error("Test failed")
if test_from_binary_string_rounding(binary_string_b, low, high, ndigits): log.success("Test succeeded")
else: log.error("Test failed")
# Convert to numbers
number_a = numbers.binary_string_to_float(binary_string_a, low, high, nbits)
number_b = numbers.binary_string_to_float(binary_string_b, low, high, nbits)
if test_from_number_rounding(number_a, low, high, ndigits): log.success("Test succeeded")
else: log.error("Test failed")
if test_from_number_rounding(number_b, low, high, ndigits): log.success("Test succeeded")
else: log.error("Test failed")
def light_test_from_number_rounding(number,
low,
high,
ndigits,
experimental=False):
"""
This fucntion ...
:param number:
:param low:
:param high:
:param ndigits:
:param experimental:
:return:
"""
# Detrmine number of bits
if experimental:
nbits = numbers.nbits_for_ndigits_experimental(ndigits, low, high)
else:
nbits = numbers.binary_digits_for_significant_figures(ndigits)
number_back = number_to_binary_and_back(number, low, high, nbits)
largest_error = 0.5 * (high - low) / numbers.nintegers_for_nbits(nbits)
number_rounded = numbers.round_to_n_significant_digits(number, ndigits)
number_back_rounded = numbers.round_to_n_significant_digits(
number_back, ndigits)
if number_back_rounded != number_rounded:
print(str(number_rounded) + " != " + str(number_back_rounded))
abserror = abs(number_back_rounded - number_rounded)
rel = abserror / number_rounded
print("rel error:", rel * 100, "%")
print("abs error:", abserror)
print("largest error:", largest_error)
else:
print(str(number_rounded) + " == " + str(number_back_rounded))
# Check
return number_back_rounded == number_rounded