def __init__(self, default_arg=DefaultArrayFunctionArgTemplate):
ML_NewArgTemplate.__init__(self, default_arg)
self.parser.add_argument(
"--test-index-range",
dest="test_index_range",
action="store",
type=(lambda s: list(int(v) for v in s.split(","))),
default=default_arg.test_index_range,
help="interval for test arrays size")
return scheme
def numeric_emulate(self, io_map):
""" Meta-Function numeric emulation """
raise NotImplementedError
@staticmethod
def __call__(args):
# just ignore args here and trust default constructor?
# seems like a bad idea.
ut_num_simplification = UT_NumericalSimplification(args)
ut_num_simplification.gen_implementation()
return True
run_test = UT_NumericalSimplification.__call__
if __name__ == "__main__":
# auto-test
main_arg_template = ML_NewArgTemplate(
default_arg=UT_NumericalSimplification.get_default_args())
# argument extraction
args = main_arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
table_value = index >> 1
add_xx = sollya.round(x + x, self.precision.get_sollya_object(),
sollya.RN)
mult = sollya.round(add_xx * x, self.precision.get_sollya_object(),
sollya.RN)
cst = sollya.round(1.1, self.precision.get_sollya_object(), sollya.RN)
return sollya.round(
table_value * sollya.round(
sollya.round(cst * mult, self.precision.get_sollya_object(),
sollya.RN) - add_xx,
self.precision.get_sollya_object(), sollya.RN),
self.precision.get_sollya_object(), sollya.RN)
def run_test(args):
ml_ut_m128_debug = ML_UT_M128_Debug(args)
ml_ut_m128_debug.gen_implementation()
return True
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_UT_M128_Debug.get_default_args())
args = arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
d = specs[i]
if i == len(specs) - 1:
json_str = json.dumps(d, sort_keys=True, indent=4)
json_str = "spec: " + json_str.replace("\n", "\nspec: ")
print(json_str)
break
nd = specs[i + 1]
if d["epsilon"] == nd["epsilon"] and d["delta"] == nd["delta"]:
continue
json_str = json.dumps(d, sort_keys=True, indent=4)
json_str = "spec: " + json_str.replace("\n", "\nspec: ")
print(json_str)
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(
default_arg=ML2_Sinusodial.get_default_args())
arg_template.parser.add_argument("--slivers", type=int, default=4)
arg_template.parser.add_argument("--poly-degree", type=int, default=1)
arg_template.parser.add_argument("--skip-reduction",
default=False,
action="store_const",
const=True)
arg_template.parser.add_argument("--skip-analysis",
default=False,
action="store_const",
const=True)
args = arg_template.arg_extraction()
meta_function = ML2_Sinusodial(args)
meta_function.gen_implementation()
if not args.skip_analysis:
meta_function.determine_error()
self.precision, abs_vx)
medium_approx.set_attributes(tag="medium_approx", debug=debug_multi)
# approximation for positive values
scheme = ConditionBlock(
abs_vx < eps, Return(result),
ConditionBlock(
abs_vx < near_indexing.get_max_bound(), Return(near_approx),
ConditionBlock(abs_vx < medium_indexing.get_max_bound(),
Return(medium_approx),
Return(Constant(1.0,
precision=self.precision)))))
return scheme
def numeric_emulate(self, input_value):
return bigfloat.gamma(sollya.SollyaObject(input_value).bigfloat())
standard_test_cases = [
(1.0, None),
(sollya.parse("0x1.13b2c6p-2"), None),
]
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=ML_Gamma.get_default_args())
args = arg_template.arg_extraction()
ml_gamma = ML_Gamma(args)
ml_gamma.gen_implementation()
return scheme
def numeric_emulate(self, x):
""" numeric emulation """
# extracting mantissa from x
# abs_x = abs(x)
# mantissa = abs_x / S2**sollya.floor(sollya.log2(abs_x))
# index = sollya.floor((mantissa - 1.0) * 2**8)
# result = sollya.round(1/sollya.sqrt(1.0 + index * S2**-8), 9, sollya.RN)
result = sollya.round(1.0 / x, 9, sollya.RN)
return result
def run_test(args):
ml_ut_legalize_rcp = ML_UT_LegalizeReciprocalSeed(args)
ml_ut_legalize_rcp.gen_implementation()
return True
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_UT_LegalizeReciprocalSeed.get_default_args())
args = arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
sollya.parse("0x1.7fd01d4fe3196307a4e0008b48p-3")
),
(
sollya.parse("0x1.4c0ff9a97083c804f4db2002c8p-1"),
sollya.parse("0x1.7fd01d4fe3196307a4e0008b48p-3")
),
(
sollya.parse("0x1.4c0ff9a97083c804f4db2002c8p-1"),
sollya.parse("0x1.7fd01d4fe3196307a4e0008b48p-3")
),
(
sollya.parse("0x1.4c0ff9a97083c804f4db2002c8p-1"),
sollya.parse("0x1.7fd01d4fe3196307a4e0008b48p-3")
),
]
run_test = ML_UT_MultiPrecisionVectorization
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=ML_UT_MultiPrecisionVectorization.get_default_args())
args = arg_template.arg_extraction()
if ML_UT_MultiPrecisionVectorization.__call__(args):
exit(0)
else:
exit(1)
S2_u3_cos,
precision=
computation_precision # ML_Custom_FixedPoint_Format(5, 26, signed = True)
)
return scheme
def numeric_emulate(self, input_value):
if self.cos_output:
return cos(input_value)
else:
return sin(input_value)
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(
default_arg=ML_FastSinCos.get_default_args())
# argument extraction
arg_template.get_parser().add_argument(
"--sin",
dest="cos_output",
default=True,
const=False,
action="store_const",
help="select sine output (default is cosine)")
arg_template.get_parser().add_argument(
"--table-size-log",
dest="table_size_log",
default=8,
type=int,
action="store",
help="logarithm of the table size to be used")
n, m, p = random_sizes
# C is a (n x m) matrix in row-major
tC_desc = TensorDescriptor([m, n], [1, m], self.precision)
return [tC_desc]
def generate_innput_tensor_descriptors(self, random_sizes):
""" generate list of instance of input tensor descriptors for testing """
n, m, p = random_sizes
tA_desc = TensorDescriptor([p, n], [1, p], self.precision)
# B is a (p x m) matrix in row-major
tB_desc = TensorDescriptor([m, p], [1, m], self.precision)
return [tA_desc, tB_desc]
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(
default_arg=ShallowConvKernel.get_default_args())
# extra arguments
arg_template.get_parser().add_argument(
"--test-index-range",
dest="test_index_range",
default=[[16, 32], [16, 32], [16, 32]],
type=eval,
action="store",
help="random range for matrix sizes")
arg_template.get_parser().add_argument(
"--kernel-size",
dest="kernel_size",
default=(3, 3),
type=(lambda s: tuple(map(int, s.split(",")))),
action="store",
help="random range for matrix sizes")
(sollya.parse("-0x1.86c83abe0854ep+268"), FP_MinusInfty(self.precision)),
# bad sign of remainder
(sollya.parse("0x1.d3fb9968850a5p-960"), sollya.parse("-0x0.23c1ed19c45fp-1022")),
# bad sign of zero
(FP_MinusZero(self.precision), sollya.parse("0x1.85200a9235193p-450")),
# bad remainder
(sollya.parse("0x1.fffffffffffffp+1023"), sollya.parse("0x1.1f31bcd002a7ap-803")),
# bad sign
(sollya.parse("-0x1.4607d0c9fc1a7p-878"), sollya.parse("-0x1.9b666b840b1bp-1023")),
]
return fp64_list if self.precision.get_bit_size() >= 64 else []
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=MetaRemQuo.get_default_args()
)
arg_template.get_parser().add_argument(
"--quotient-size", dest="quotient_size", default=3, type=int,
action="store", help="number of bit to return for the quotient")
arg_template.get_parser().add_argument(
"--mode", dest="mode", default="quotient", choices=['quotient', 'remainder', 'full'],
action="store", help="number of bit to return for the quotient")
ARGS = arg_template.arg_extraction()
ml_remquo = MetaRemQuo(ARGS)
ml_remquo.gen_implementation()
scheme = Statement(
Return(
external_function(*tuple(inputs)),
precision=self.precision,
))
return scheme
def numeric_emulate(self, *args):
return self.emulate(*args)
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_ExternalBench.get_default_args())
def precision_list_parser(s):
return [precision_parser(p) for p in s.split(",")]
# argument extraction
arg_template.get_parser().add_argument(
"--function",
dest="bench_function_name",
default="expf",
action="store",
type=str,
help="name of the function to be benched")
arg_template.get_parser().add_argument(
"--headers",
dest="headers",
def __init__(self,arg_template = DefaultArgTemplate):
# initializing I/O precision
precision = ArgDefault.select_value([arg_template.precision, precision])
io_precisions = [precision] * 2
# initializing base class
ML_FunctionBasis.__init__(self,
arg_template=arg_template
)
self.precision = precision
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate()
arg_template.get_parser().add_argument(
"--test-gappa", dest="test_gappa", action="store_const", const=True,
default=False, help="test gappa install")
arg_template.get_parser().add_argument(
"--test-cgpe", dest="test_cgpe", action="store_const", const=True,
default=False, help="test cgpe install")
arg_template.get_parser().add_argument(
"--full-status", dest="full_status", action="store_const", const=True,
default=False, help="test full Metalibm status")
# argument extraction
args = arg_template.arg_extraction()
if args.test_cgpe or args.full_status:
print("CPGE available: {}".format(polynomials.is_cgpe_available()))
arg_map={
0: FO_Arg(0),
1: FO_Arg(1),
2: FO_Arg(2)
},
require_header=["mpfr.h"])
emulate_func = FunctionObject(emulate_func_name,
[ML_Mpfr_t, ML_Mpfr_t, ML_Int32],
ML_Int32, emulate_func_op)
mpfr_call = Statement(
ReferenceAssign(result_ternary,
emulate_func(result, mpfr_x, mpfr_rnd)))
return mpfr_call
def numeric_emulate(self, input_value):
""" Numeric emaluation of exponential """
return sollya.exp(input_value)
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_Exponential.get_default_args())
# argument extraction
args = parse_arg_index_list = arg_template.arg_extraction()
ml_exp = ML_Exponential(args)
ml_exp.gen_implementation()
for e in range(1, reduction_e):
d = generate_json(errors, sollya.Interval(2**(-e), 2**e))
specs.append(d)
for i in range(len(specs)):
d = specs[i]
if i == len(specs)-1:
json_str = json.dumps(d, sort_keys=True, indent=4)
json_str = "spec: " + json_str.replace("\n", "\nspec: ")
print(json_str)
break
nd = specs[i+1]
if d["epsilon"] == nd["epsilon"] and d["delta"] == nd["delta"]:
continue
json_str = json.dumps(d, sort_keys=True, indent=4)
json_str = "spec: " + json_str.replace("\n", "\nspec: ")
print(json_str)
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(default_arg=ML2_Logarithm.get_default_args())
arg_template.parser.add_argument("--slivers", type=int, default=4)
arg_template.parser.add_argument("--poly-degree", type=int, default=1)
arg_template.parser.add_argument("--skip-reduction", default=False,
action="store_const", const=True)
arg_template.parser.add_argument("--skip-analysis", default=False,
action="store_const", const=True)
args = arg_template.arg_extraction()
meta_function = ML2_Logarithm(args)
meta_function.gen_implementation()
if not args.skip_analysis:
meta_function.determine_error()
def numeric_emulate(self, x):
""" numeric emulation """
TABLE = [1.1**i for i in range(self.table_size)]
return TABLE[int(x)]
@staticmethod
def __call__(args):
""" Static method from TestRunner: main test function """
ut_bfloat16 = ML_UT_BFloat16(args)
ut_bfloat16.gen_implementation()
return True
run_test = ML_UT_BFloat16
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=ML_UT_BFloat16.get_default_args())
arg_template.get_parser().add_argument(
"--table-size", dest="table_size", default=10, type=int,
help="set internal table size")
args = arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
sollya.parse("-0x0.fffffffffffffp-1022 ")),
# ERROR: rootn: 1125899906842624.000000 ulp error at {-0x1.fffffffffffffp+1023, -1}: *-0x0.4000000000000p-1022 vs. -0x0.0000000000000p+0
(sollya.parse("-0x1.fffffffffffffp+1023"), -1,
sollya.parse("-0x0.4000000000000p-1022")),
(sollya.parse("0x1.fffffffffffffp+1023"), -1,
sollya.parse("0x0.4000000000000p-1022")),
]
return (fp_64_only if self.precision.get_bit_size() >= 64 else []) \
+ (fp_32_only if self.precision.get_bit_size() == 32 else []) \
+ general_list
if __name__ == "__main__":
# declaring standard argument structure
arg_template = ML_NewArgTemplate(default_arg=MetaRootN.get_default_args())
arg_template.get_parser().add_argument(
"--expand-div",
dest="expand_div",
default=False,
const=int,
action="store_const",
help="expand division to meta-division")
# filling arg_template structure with command line options
args = arg_template.arg_extraction()
# declaring meta-function instance
meta_function = MetaRootN(args)
return recp_eval_error, div_eval_error
standard_test_cases = [
(1.0, sollya.parse("0x1.fffffffffffffp+1023"),
sollya.parse("0x1p-1024")),
(sollya.parse("-0x1.34a246p-2"), sollya.parse("-0x1.26e2e2p-1")),
(sollya.parse("0x1.p0"), sollya.parse("0x1.e0ef5ep-49")),
(sollya.parse("0x1.7fddbp0"), sollya.parse("0x1.e0ef5ep-49")),
(sollya.parse("0x1.7fddbp-126"), sollya.parse("0x1.e0ef5ep-49")),
(1.0, sollya.parse("-0x1.fffffffffffffp+1023"),
sollya.parse("-0x1p-1024")),
]
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_Division.get_default_args())
arg_template.get_parser().add_argument(
"--num-iter",
dest="num_iter",
default=3,
type=int,
action="store",
help="number of newton-raphson iterations")
ARGS = arg_template.arg_extraction()
ml_div = ML_Division(ARGS)
ml_div.gen_implementation()
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
###############################################################################
# last-modified: Oct 21st, 2019
#
# wrapper for ML_SinCos to generate sine function
###############################################################################
from metalibm_core.utility.ml_template import ML_NewArgTemplate
from metalibm_functions.ml_sincos import ML_SinCos
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(default_arg=ML_SinCos.get_default_args(
output_file="my_sin.c", function_name="my_sin"))
args = arg_template.arg_extraction()
# overloading sin_output for force sine function generation
args.sin_output = True
ml_sincos = ML_SinCos(args)
ml_sincos.gen_implementation()
debug=debug_multi)
return scheme
def numeric_emulate(self, input_value):
return 2**input_value
@staticmethod
def get_default_args(**kw):
""" Return a structure containing the arguments for MetalibmSqrt,
builtin from a default argument mapping overloaded with @p kw """
default_args_fast_exp2i = {
"output_file": "fast_expi.c",
"function_name": "fast_expi",
"input_precisions": [ML_Int32],
"precision": ML_Binary32,
"accuracy": ML_Faithful,
"target": GenericProcessor.get_target_instance()
}
default_args_fast_exp2i.update(kw)
return DefaultArgTemplate(**default_args_fast_exp2i)
if __name__ == "__main__":
# auto-test
ARG_TEMPLATE = ML_NewArgTemplate(default_arg=FastExp2i.get_default_args())
ARGS = ARG_TEMPLATE.arg_extraction()
ML_FAST_EXP_I = FastExp2i(ARGS)
ML_FAST_EXP_I.gen_implementation()
ConditionBlock(test_zero, return_PosZero, return_NegZero)))
return_std = Return(result)
scheme = ConditionBlock(test_std, return_std, return_non_std)
return scheme
def numeric_emulate(self, vx):
""" Numeric emulation for square-root """
return sollya.sqrt(vx)
standard_test_cases = [
(1.651028399744791652636877188342623412609100341796875, )
] # [sollya.parse(x)] for x in ["+0.0", "-1*0.0", "2.0"]]
if __name__ == "__main__":
ARG_TEMPLATE = ML_NewArgTemplate(
default_arg=MetalibmSqrt.get_default_args())
# TODO: should not be a command line argument but rather determined during generation
ARG_TEMPLATE.parser.add_argument(
"--num-iter",
dest="num_iter",
action="store",
default=3,
help="number of Newton-Raphson iterations")
ARGS = ARG_TEMPLATE.arg_extraction()
ML_SQRT = MetalibmSqrt(ARGS)
ML_SQRT.gen_implementation()
test_ph_bound, lar_statement,
Statement(
ReferenceAssign(modk, modk_std),
ReferenceAssign(red_vx, red_vx_std),
)), result_1))
return scheme
def numeric_emulate(self, input_value):
if self.sin_output:
return sin(input_value)
else:
return cos(input_value)
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=ML_SinCos.get_default_args())
# argument extraction
arg_template.get_parser().add_argument(
"--sin",
dest="sin_output",
default=False,
const=True,
action="store_const",
help="select sine output (default is cosine)")
args = arg_template.arg_extraction()
ml_sincos = ML_SinCos(args)
ml_sincos.gen_implementation()
""" generate list of instance of output tensor descriptors for testing """
n, m, p = random_sizes
# C is a (n x m) matrix in row-major
tC_desc = TensorDescriptor([m, n], [1, m], self.precision)
return [tC_desc]
def generate_innput_tensor_descriptors(self, random_sizes):
""" generate list of instance of input tensor descriptors for testing """
n, m, p = random_sizes
tA_desc = TensorDescriptor([p, n], [1, p], self.precision)
# B is a (p x m) matrix in row-major
tB_desc = TensorDescriptor([m, p], [1, m], self.precision)
return [tA_desc, tB_desc]
if __name__ == "__main__":
arg_template = ML_NewArgTemplate(default_arg=MatrixMultiplyKernel.get_default_args())
# extra arguments
arg_template.get_parser().add_argument(
"--test-index-range", dest="test_index_range", default=[[16, 32], [16, 32], [16, 32]],
type=eval,
action="store", help="random range for matrix sizes")
arg_template.get_parser().add_argument(
"--vectorize", const=True, default=False, action="store_const",
help="enable matrix-multiply vectorization")
# argument extraction
args = arg_template.arg_extraction()
matrix_multiply_kernel = MatrixMultiplyKernel(args)
matrix_multiply_kernel.gen_implementation()
ov_value = round(asinh(self.precision.get_max_value()), self.precision.get_sollya_object(), sollya.RD)
ov_flag = Comparison(Abs(vx), Constant(ov_value, precision = self.precision), specifier = Comparison.Greater)
# main scheme
scheme = Statement(
Return(
Select(
ov_flag,
sign*FP_PlusInfty(self.precision),
sign*result
)))
return scheme
def numeric_emulate(self, input_value):
return sinh(input_value)
standard_test_cases =[[sollya.parse(x)] for x in [
"0x1.8d3694p-5", "0x1.efc2cp-6", "0x1.f55ddap-5"]
]
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=ML_HyperbolicSine.get_default_args())
# argument extraction
args = arg_template.arg_extraction()
ml_sinh = ML_HyperbolicSine(args)
ml_sinh.gen_implementation()
else:
Log.report(
Log.Warning,
"gappa was not installed: unable to check execute_gappa_script_extract"
)
# dummy scheme to make functionnal code generation
scheme = Statement(Return(vx))
return scheme
def run_test(args):
""" main function for test run """
ml_ut_gappa_code = ML_UT_GappaCode(args)
ml_ut_gappa_code.gen_implementation(display_after_gen=False,
display_after_opt=False)
return True
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_UT_GappaCode.get_default_args())
args = arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
return scheme
def numeric_emulate(self, x):
""" numeric emulation """
# extracting mantissa from x
# abs_x = abs(x)
# mantissa = abs_x / S2**sollya.floor(sollya.log2(abs_x))
# index = sollya.floor((mantissa - 1.0) * 2**8)
# result = sollya.round(1/sollya.sqrt(1.0 + index * S2**-8), 9, sollya.RN)
result = sollya.round(1 / sollya.sqrt(x), 9, sollya.RN)
return result
def run_test(args):
ml_ut_legalize_sqrt = ML_UT_LegalizeSqrt(args)
ml_ut_legalize_sqrt.gen_implementation()
return True
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_UT_LegalizeSqrt.get_default_args())
args = arg_template.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
raise NotImplementedError
result = approx
scheme = Return(result, precision=self.precision, debug=debug_multi)
return scheme
def numeric_emulate(self, x):
""" numeric emulation """
result = self.precision.round_sollya_object(1 / x)
return result
def run_test(args):
ml_ut_accuracies = ML_UT_Accuracies(args)
ml_ut_accuracies.gen_implementation()
return True
if __name__ == "__main__":
# auto-test
ARG_TEMPLATE = ML_NewArgTemplate(
default_arg=ML_UT_Accuracies.get_default_args())
args = ARG_TEMPLATE.arg_extraction()
if run_test(args):
exit(0)
else:
exit(1)
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
###############################################################################
# created: Mar 25th, 2020
# last-modified: Mar 25th, 2020
# Author(s): Nicolas Brunie <*****@*****.**>
###############################################################################
from metalibm_core.utility.ml_template import ML_NewArgTemplate
from metalibm_functions.ml_atan import MetaAtan2
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=MetaAtan2.get_default_args())
# extra options
arg_template.get_parser().add_argument(
"--method", dest="method", default="piecewise", choices=["piecewise", "single"],
action="store", help="select approximation method")
arg_template.get_parser().add_argument(
"--num-sub-intervals", default=8, type=int,
action="store", help="set the number of sub-intervals in piecewise method")
args = arg_template.arg_extraction()
ml_atan2 = MetaAtan2(args)
ml_atan2.gen_implementation()
for entry in level0_list:
formats, ops = entry.split(':')
formats = [precision_parser(f) for f in formats.split(',')]
ops = [operation_parser(o) for o in ops.split(',')]
for op in ops:
if not op in op_map:
op_map[op] = []
for f in formats:
op_map[op].append(f)
return op_map
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_function_name="main",
default_output_file="bench.c",
default_arg=UnitBench.get_default_args())
# argument extraction
arg_template.get_parser().add_argument("--test-num",
dest="test_num",
default=10000,
action="store",
type=int,
help="number of basic iteration")
arg_template.get_parser().add_argument("--unroll-factor",
dest="unroll_factor",
default=10,
action="store",
type=int,
help="number of basic iteration")
arg_map={
0: FO_Arg(0),
1: FO_Arg(1),
2: FO_Arg(2)
},
require_header=["mpfr.h"])
emulate_func = FunctionObject(emulate_func_name,
[ML_Mpfr_t, ML_Mpfr_t, ML_Int32],
ML_Int32, emulate_func_op)
mpfr_call = Statement(
ReferenceAssign(result_ternary,
emulate_func(result, mpfr_x, mpfr_rnd)))
return mpfr_call
def numeric_emulate(self, input_value):
""" Numeric emaluation of exponential """
return sollya.exp(input_value)
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(
default_arg=ML_Exponential.get_default_args())
# argument extraction
args = arg_template.arg_extraction()
ml_exp = ML_Exponential(args)
ml_exp.gen_implementation()
mult = Multiplication(var, var_z, precision=self.precision)
add = Addition(var_y, mult, precision=self.precision)
test_program = Statement(
add,
Return(add)
)
return test_program
@staticmethod
def __call__(args):
# just ignore args here and trust default constructor?
# seems like a bad idea.
ut_machine_insn_gen = UT_MachineInsnGeneration(args)
ut_machine_insn_gen.gen_implementation()
return True
# main runner for unit tests (called by valid.soft_unit_test)
run_test = UT_MachineInsnGeneration.__call__
if __name__ == "__main__":
# auto-test
arg_template = ML_NewArgTemplate(default_arg=UT_MachineInsnGeneration.get_default_args())
args = arg_template.arg_extraction()
ut_machine_insn_generation = UT_MachineInsnGeneration(args)
if run_test(args):
exit(0)
else:
exit(1)
