Compare commits
5 Commits
86379c8b40
...
1927035cfc
Author | SHA1 | Date |
---|---|---|
David Mak | 1927035cfc | |
David Mak | 5f6f4e1a2c | |
David Mak | ca25ab4601 | |
David Mak | 7322a487e0 | |
David Mak | 44e4e0804b |
|
@ -137,4 +137,12 @@ int32_t __nac3_list_slice_assign_var_size(
|
|||
return dest_arr_len - (dest_end - dest_ind) - 1;
|
||||
}
|
||||
return dest_arr_len;
|
||||
}
|
||||
|
||||
int32_t __nac3_isinf(double x) {
|
||||
return __builtin_isinf(x);
|
||||
}
|
||||
|
||||
int32_t __nac3_isnan(double x) {
|
||||
return __builtin_isnan(x);
|
||||
}
|
|
@ -7,7 +7,7 @@ use inkwell::{
|
|||
memory_buffer::MemoryBuffer,
|
||||
module::Module,
|
||||
types::BasicTypeEnum,
|
||||
values::{IntValue, PointerValue},
|
||||
values::{FloatValue, IntValue, PointerValue},
|
||||
AddressSpace, IntPredicate,
|
||||
};
|
||||
use nac3parser::ast::Expr;
|
||||
|
@ -432,3 +432,53 @@ pub fn list_slice_assignment<'ctx, 'a>(
|
|||
ctx.builder.build_unconditional_branch(cont_bb);
|
||||
ctx.builder.position_at_end(cont_bb);
|
||||
}
|
||||
|
||||
/// Generates a call to `isinf` in IR. Returns either an `i32` or `i1` representing the result,
|
||||
/// depending on the value of `to_i1`.
|
||||
pub fn call_isinf<'ctx, 'a>(
|
||||
generator: &dyn CodeGenerator,
|
||||
ctx: &CodeGenContext<'ctx, 'a>,
|
||||
v: FloatValue<'ctx>,
|
||||
to_i1: bool,
|
||||
) -> IntValue<'ctx> {
|
||||
let intrinsic_fn = ctx.module.get_function("__nac3_isinf").unwrap_or_else(|| {
|
||||
let fn_type = ctx.ctx.i32_type().fn_type(&[ctx.ctx.f64_type().into()], false);
|
||||
ctx.module.add_function("__nac3_isinf", fn_type, None)
|
||||
});
|
||||
|
||||
let val = ctx.builder
|
||||
.build_call(intrinsic_fn, &[v.into()], "isinf")
|
||||
.try_as_basic_value()
|
||||
.unwrap_left()
|
||||
.into_int_value();
|
||||
if to_i1 {
|
||||
generator.bool_to_i1(ctx, val)
|
||||
} else {
|
||||
val
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates a call to `isnan` in IR. Returns either an `i32` or `i1` representing the result,
|
||||
/// depending on the value of `to_i1`.
|
||||
pub fn call_isnan<'ctx, 'a>(
|
||||
generator: &dyn CodeGenerator,
|
||||
ctx: &CodeGenContext<'ctx, 'a>,
|
||||
v: FloatValue<'ctx>,
|
||||
to_i1: bool,
|
||||
) -> IntValue<'ctx> {
|
||||
let intrinsic_fn = ctx.module.get_function("__nac3_isnan").unwrap_or_else(|| {
|
||||
let fn_type = ctx.ctx.i32_type().fn_type(&[ctx.ctx.f64_type().into()], false);
|
||||
ctx.module.add_function("__nac3_isnan", fn_type, None)
|
||||
});
|
||||
|
||||
let val = ctx.builder
|
||||
.build_call(intrinsic_fn, &[v.into()], "isnan")
|
||||
.try_as_basic_value()
|
||||
.unwrap_left()
|
||||
.into_int_value();
|
||||
if to_i1 {
|
||||
generator.bool_to_i1(ctx, val)
|
||||
} else {
|
||||
val
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
use super::*;
|
||||
use crate::{
|
||||
codegen::{
|
||||
expr::destructure_range, irrt::calculate_len_for_slice_range, stmt::exn_constructor,
|
||||
expr::destructure_range,
|
||||
irrt::{calculate_len_for_slice_range, call_isinf, call_isnan},
|
||||
stmt::exn_constructor,
|
||||
},
|
||||
symbol_resolver::SymbolValue,
|
||||
};
|
||||
|
@ -917,70 +919,22 @@ pub fn get_builtins(primitives: &mut (PrimitiveStore, Unifier)) -> BuiltinInfo {
|
|||
)))),
|
||||
loc: None,
|
||||
})),
|
||||
Arc::new(RwLock::new(TopLevelDef::Function {
|
||||
name: "floor".into(),
|
||||
simple_name: "floor".into(),
|
||||
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
|
||||
args: vec![FuncArg { name: "n".into(), ty: float, default_value: None }],
|
||||
ret: int32,
|
||||
vars: Default::default(),
|
||||
})),
|
||||
var_id: Default::default(),
|
||||
instance_to_symbol: Default::default(),
|
||||
instance_to_stmt: Default::default(),
|
||||
resolver: None,
|
||||
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|
||||
|ctx, _, _, args, generator| {
|
||||
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
|
||||
let floor_intrinsic =
|
||||
ctx.module.get_function("llvm.floor.f64").unwrap_or_else(|| {
|
||||
let float = ctx.ctx.f64_type();
|
||||
let fn_type = float.fn_type(&[float.into()], false);
|
||||
ctx.module.add_function("llvm.floor.f64", fn_type, None)
|
||||
});
|
||||
let val = ctx
|
||||
.builder
|
||||
.build_call(floor_intrinsic, &[arg.into()], "floor")
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap();
|
||||
Ok(val.into())
|
||||
},
|
||||
)))),
|
||||
loc: None,
|
||||
})),
|
||||
Arc::new(RwLock::new(TopLevelDef::Function {
|
||||
name: "ceil".into(),
|
||||
simple_name: "ceil".into(),
|
||||
signature: primitives.1.add_ty(TypeEnum::TFunc(FunSignature {
|
||||
args: vec![FuncArg { name: "n".into(), ty: float, default_value: None }],
|
||||
ret: int32,
|
||||
vars: Default::default(),
|
||||
})),
|
||||
var_id: Default::default(),
|
||||
instance_to_symbol: Default::default(),
|
||||
instance_to_stmt: Default::default(),
|
||||
resolver: None,
|
||||
codegen_callback: Some(Arc::new(GenCall::new(Box::new(
|
||||
|ctx, _, _, args, generator| {
|
||||
let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, ctx.primitives.float)?;
|
||||
let ceil_intrinsic =
|
||||
ctx.module.get_function("llvm.ceil.f64").unwrap_or_else(|| {
|
||||
let float = ctx.ctx.f64_type();
|
||||
let fn_type = float.fn_type(&[float.into()], false);
|
||||
ctx.module.add_function("llvm.ceil.f64", fn_type, None)
|
||||
});
|
||||
let val = ctx
|
||||
.builder
|
||||
.build_call(ceil_intrinsic, &[arg.into()], "ceil")
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap();
|
||||
Ok(val.into())
|
||||
},
|
||||
)))),
|
||||
loc: None,
|
||||
})),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"floor",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.floor.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"ceil",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.ceil.f64",
|
||||
),
|
||||
Arc::new(RwLock::new({
|
||||
let list_var = primitives.1.get_fresh_var(Some("L".into()), None);
|
||||
let list = primitives.1.add_ty(TypeEnum::TList { ty: list_var.0 });
|
||||
|
@ -1226,6 +1180,563 @@ pub fn get_builtins(primitives: &mut (PrimitiveStore, Unifier)) -> BuiltinInfo {
|
|||
)))),
|
||||
loc: None,
|
||||
})),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"isnan",
|
||||
boolean,
|
||||
&[(float, "x")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
|
||||
let x_ty = fun.0.args[0].ty;
|
||||
let x_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, x_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(x_ty, float));
|
||||
|
||||
let val = call_isnan(generator, ctx, x_val.into_float_value(), true);
|
||||
|
||||
Ok(Some(val.into()))
|
||||
}),
|
||||
),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"isinf",
|
||||
boolean,
|
||||
&[(float, "x")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
|
||||
let x_ty = fun.0.args[0].ty;
|
||||
let x_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, x_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(x_ty, float));
|
||||
|
||||
let val = call_isinf(generator, ctx, x_val.into_float_value(), true);
|
||||
|
||||
Ok(Some(val.into()))
|
||||
}),
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"sin",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.sin.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"cos",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.cos.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"exp",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.exp.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"exp2",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.exp2.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"log",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.log.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"log10",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.log10.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"log2",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.log2.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"fabs",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.fabs.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"trunc",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.trunc.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"sqrt",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"llvm.sqrt.f64",
|
||||
),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"rint",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
let llvm_f64 = ctx.ctx.f64_type();
|
||||
|
||||
let x_ty = fun.0.args[0].ty;
|
||||
let x_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, x_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(x_ty, float));
|
||||
|
||||
let intrinsic_fn = ctx.module.get_function("llvm.round.f64").unwrap_or_else(|| {
|
||||
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
|
||||
|
||||
ctx.module.add_function("llvm.round.f64", fn_type, None)
|
||||
});
|
||||
|
||||
// rint(x) == round(x * 0.5) * 2.0
|
||||
|
||||
// %0 = fmul f64 %x, 0.5
|
||||
let x_half = ctx.builder
|
||||
.build_float_mul(x_val.into_float_value(), llvm_f64.const_float(0.5), "");
|
||||
// %1 = call f64 @llvm.round.f64(f64 %0)
|
||||
let round = ctx.builder
|
||||
.build_call(
|
||||
intrinsic_fn,
|
||||
&vec![x_half.into()],
|
||||
"",
|
||||
)
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap();
|
||||
// %2 = fmul f64 %1, 2.0
|
||||
let val = ctx.builder
|
||||
.build_float_mul(round.into_float_value(), llvm_f64.const_float(2.0).into(), "rint");
|
||||
|
||||
Ok(Some(val.into()))
|
||||
}),
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"tan",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"tan",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arcsin",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"asin",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arccos",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"acos",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arctan",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"atan",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"sinh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"sinh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"cosh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"cosh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"tanh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"tanh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arcsinh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"asinh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arccosh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"acosh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arctanh",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"atanh",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"expm1",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"expm1",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"cbrt",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"cbrt",
|
||||
&["readnone", "willreturn"],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"erf",
|
||||
float,
|
||||
&[(float, "z")],
|
||||
"erf",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"erfc",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"erfc",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"gamma",
|
||||
float,
|
||||
&[(float, "z")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
let llvm_f64 = ctx.ctx.f64_type();
|
||||
|
||||
let z_ty = fun.0.args[0].ty;
|
||||
let z_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, z_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(z_ty, float));
|
||||
|
||||
let tgamma_fn = ctx.module.get_function("tgamma").unwrap_or_else(|| {
|
||||
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
|
||||
let func = ctx.module.add_function("tgamma", fn_type, None);
|
||||
func.add_attribute(
|
||||
AttributeLoc::Function,
|
||||
ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
|
||||
);
|
||||
|
||||
func
|
||||
});
|
||||
|
||||
// %0 = call f64 @tgamma(f64 %z)
|
||||
let call = ctx.builder
|
||||
.build_call(tgamma_fn, &[z_val.into()], "gamma")
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap()
|
||||
.into_float_value();
|
||||
|
||||
// Handling for denormals
|
||||
// | x | Python gamma(x) | C tgamma(x) |
|
||||
// --- | ----------------- | --------------- | ----------- |
|
||||
// (1) | nan | nan | nan |
|
||||
// (2) | -inf | -inf | inf |
|
||||
// (3) | inf | inf | inf |
|
||||
// (4) | 0.0 | inf | inf |
|
||||
// (5) | {-1.0, -2.0, ...} | inf | nan |
|
||||
//
|
||||
// Therefore, we remap to Python's denorm handling by:
|
||||
//
|
||||
// let v = tgamma(x);
|
||||
// v = if isinf(v) || isnan(v) { f64::INFINITY } else { v } // Handles (4)-(5)
|
||||
// v = if isinf(x) || isnan(x) { x } else { v } // Handles (1)-(3)
|
||||
|
||||
// %v.isinf = call i32 @__nac3_isinf(f64 %0)
|
||||
let v_isinf = call_isinf(generator, ctx, call.into(), false);
|
||||
// %v.isnan = call i32 @__nac3_isnan(f64 %0)
|
||||
let v_isnan = call_isnan(generator, ctx, call.into(), false);
|
||||
|
||||
// %or = or i32 %v.isinf, %v.isnan
|
||||
// %or.tobool = icmp ne i32 %or, 0
|
||||
// %3 = select i1 %or.tobool, f64 inf, f64 %0
|
||||
let v_is_nonnum = ctx.builder.build_or(v_isinf, v_isnan, "");
|
||||
let val = ctx.builder.build_select(
|
||||
generator.bool_to_i1(ctx, v_is_nonnum),
|
||||
llvm_f64.const_float(f64::INFINITY).into(),
|
||||
call,
|
||||
"",
|
||||
).into_float_value();
|
||||
|
||||
// %z.isinf = call i32 @__nac3_isinf(f64 %z)
|
||||
let z_isinf = call_isinf(generator, ctx, z_val.into_float_value(), false);
|
||||
// %z.isnan = call i32 @__nac3_isnan(f64 %z)
|
||||
let z_isnan = call_isnan(generator, ctx, z_val.into_float_value(), false);
|
||||
|
||||
// %or = or i32 %z.isinf, %z.isnan
|
||||
// %or.tobool = icmp ne i32 %or, 0
|
||||
// %val = select i1 %or.tobool, f64 %z, f64 %3
|
||||
let z_is_nonnum = ctx.builder.build_or(z_isinf, z_isnan, "");
|
||||
let val = ctx.builder.build_select(
|
||||
generator.bool_to_i1(ctx, z_is_nonnum),
|
||||
z_val.into_float_value(),
|
||||
val,
|
||||
"",
|
||||
);
|
||||
|
||||
Ok(val.into())
|
||||
}),
|
||||
),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"gammaln",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
let llvm_f64 = ctx.ctx.f64_type();
|
||||
|
||||
let x_ty = fun.0.args[0].ty;
|
||||
let x_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, x_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(x_ty, float));
|
||||
|
||||
let tgamma_fn = ctx.module.get_function("lgamma").unwrap_or_else(|| {
|
||||
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
|
||||
let func = ctx.module.add_function("lgamma", fn_type, None);
|
||||
func.add_attribute(
|
||||
AttributeLoc::Function,
|
||||
ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
|
||||
);
|
||||
|
||||
func
|
||||
});
|
||||
|
||||
// %0 = call f64 @gamma(f64 %x)
|
||||
let call = ctx.builder
|
||||
.build_call(tgamma_fn, &[x_val.into()], "gammaln")
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap()
|
||||
.into_float_value();
|
||||
|
||||
// libm's handling of value overflows differs from scipy:
|
||||
// - scipy: gammaln(-inf) -> -inf
|
||||
// - libm : lgamma(-inf) -> inf
|
||||
//
|
||||
// Therefore we remap it by:
|
||||
//
|
||||
// let v = lgamma(x);
|
||||
// v = if isinf(x) { x } else { v }
|
||||
|
||||
// %isinf = call i32 @__nac3_isinf(f64 %x)
|
||||
// %tobool = icmp ne i32 %isinf, 0
|
||||
// %val = select i1 %tobool, f64 %x, f64 %0
|
||||
let v = ctx.builder.build_select(
|
||||
call_isinf(generator, ctx, x_val.into_float_value(), true),
|
||||
x_val,
|
||||
call.into(),
|
||||
""
|
||||
);
|
||||
|
||||
Ok(v.into())
|
||||
}),
|
||||
),
|
||||
create_fn_by_codegen(
|
||||
primitives,
|
||||
&var_map,
|
||||
"j0",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
Box::new(|ctx, _, fun, args, generator| {
|
||||
let float = ctx.primitives.float;
|
||||
let llvm_f64 = ctx.ctx.f64_type();
|
||||
|
||||
let x_ty = fun.0.args[0].ty;
|
||||
let x_val = args[0].1.clone()
|
||||
.to_basic_value_enum(ctx, generator, x_ty)?;
|
||||
|
||||
assert!(ctx.unifier.unioned(x_ty, float));
|
||||
|
||||
let tgamma_fn = ctx.module.get_function("j0").unwrap_or_else(|| {
|
||||
let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
|
||||
let func = ctx.module.add_function("j0", fn_type, None);
|
||||
func.add_attribute(
|
||||
AttributeLoc::Function,
|
||||
ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
|
||||
);
|
||||
|
||||
func
|
||||
});
|
||||
|
||||
// %0 = call f64 @j0(f64 %x)
|
||||
let call = ctx.builder
|
||||
.build_call(tgamma_fn, &[x_val.into()], "j0")
|
||||
.try_as_basic_value()
|
||||
.left()
|
||||
.unwrap()
|
||||
.into_float_value();
|
||||
|
||||
// libm's handling of value overflows differs from scipy:
|
||||
// - scipy: j0(inf) -> nan
|
||||
// - libm : j0(inf) -> 0.0
|
||||
//
|
||||
// Therefore we remap it by:
|
||||
//
|
||||
// let v = j0(x);
|
||||
// v = if isinf(x) { f64::NAN } else { v }
|
||||
|
||||
// %1 = call i32 @__nac3_isinf(f64 %x)
|
||||
// %2 =
|
||||
let arg_isinf = call_isinf(generator, ctx, x_val.into_float_value(), true);
|
||||
|
||||
// %val = select i1 %1, f64 nan, f64 %0
|
||||
let val = ctx.builder
|
||||
.build_select(arg_isinf, llvm_f64.const_float(f64::NAN), call, "");
|
||||
|
||||
Ok(val.into())
|
||||
}),
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"j1",
|
||||
float,
|
||||
&[(float, "x")],
|
||||
"j1",
|
||||
&[],
|
||||
),
|
||||
// Not mapped: jv/yv, libm only supports integer orders.
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"arctan2",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"atan2",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"copysign",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"llvm.copysign.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"fmax",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"llvm.maxnum.f64",
|
||||
),
|
||||
create_fn_by_intrinsic(
|
||||
primitives,
|
||||
&var_map,
|
||||
"fmin",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"llvm.minnum.f64",
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"ldexp",
|
||||
float,
|
||||
&[(float, "x1"), (int32, "x2")],
|
||||
"ldexp",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"hypot",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"hypot",
|
||||
&[],
|
||||
),
|
||||
create_fn_by_extern(
|
||||
primitives,
|
||||
&var_map,
|
||||
"nextafter",
|
||||
float,
|
||||
&[(float, "x1"), (float, "x2")],
|
||||
"nextafter",
|
||||
&[],
|
||||
),
|
||||
Arc::new(RwLock::new(TopLevelDef::Function {
|
||||
name: "Some".into(),
|
||||
simple_name: "Some".into(),
|
||||
|
@ -1270,6 +1781,44 @@ pub fn get_builtins(primitives: &mut (PrimitiveStore, Unifier)) -> BuiltinInfo {
|
|||
"min",
|
||||
"max",
|
||||
"abs",
|
||||
"isnan",
|
||||
"isinf",
|
||||
"sin",
|
||||
"cos",
|
||||
"exp",
|
||||
"exp2",
|
||||
"log",
|
||||
"log10",
|
||||
"log2",
|
||||
"fabs",
|
||||
"trunc",
|
||||
"sqrt",
|
||||
"rint",
|
||||
"tan",
|
||||
"arcsin",
|
||||
"arccos",
|
||||
"arctan",
|
||||
"sinh",
|
||||
"cosh",
|
||||
"tanh",
|
||||
"arcsinh",
|
||||
"arccosh",
|
||||
"arctanh",
|
||||
"expm1",
|
||||
"cbrt",
|
||||
"erf",
|
||||
"erfc",
|
||||
"gamma",
|
||||
"gammaln",
|
||||
"j0",
|
||||
"j1",
|
||||
"arctan2",
|
||||
"copysign",
|
||||
"fmax",
|
||||
"fmin",
|
||||
"ldexp",
|
||||
"hypot",
|
||||
"nextafter",
|
||||
"Some",
|
||||
],
|
||||
)
|
||||
|
|
|
@ -82,51 +82,55 @@ pub struct FunInstance {
|
|||
#[derive(Debug, Clone)]
|
||||
pub enum TopLevelDef {
|
||||
Class {
|
||||
// name for error messages and symbols
|
||||
/// Name for error messages and symbols.
|
||||
name: StrRef,
|
||||
// object ID used for TypeEnum
|
||||
/// Object ID used for [TypeEnum].
|
||||
object_id: DefinitionId,
|
||||
/// type variables bounded to the class.
|
||||
type_vars: Vec<Type>,
|
||||
// class fields
|
||||
// name, type, is mutable
|
||||
/// Class fields.
|
||||
///
|
||||
/// Name and type is mutable.
|
||||
fields: Vec<(StrRef, Type, bool)>,
|
||||
// class methods, pointing to the corresponding function definition.
|
||||
/// Class methods, pointing to the corresponding function definition.
|
||||
methods: Vec<(StrRef, Type, DefinitionId)>,
|
||||
// ancestor classes, including itself.
|
||||
/// Ancestor classes, including itself.
|
||||
ancestors: Vec<TypeAnnotation>,
|
||||
// symbol resolver of the module defined the class, none if it is built-in type
|
||||
/// Symbol resolver of the module defined the class; [None] if it is built-in type.
|
||||
resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
|
||||
// constructor type
|
||||
/// Constructor type.
|
||||
constructor: Option<Type>,
|
||||
// definition location
|
||||
/// Definition location.
|
||||
loc: Option<Location>,
|
||||
},
|
||||
Function {
|
||||
// prefix for symbol, should be unique globally
|
||||
/// Prefix for symbol, should be unique globally.
|
||||
name: String,
|
||||
// simple name, the same as in method/function definition
|
||||
/// Simple name, the same as in method/function definition.
|
||||
simple_name: StrRef,
|
||||
// function signature.
|
||||
/// Function signature.
|
||||
signature: Type,
|
||||
// instantiated type variable IDs
|
||||
/// Instantiated type variable IDs.
|
||||
var_id: Vec<u32>,
|
||||
/// Function instance to symbol mapping
|
||||
/// Key: string representation of type variable values, sorted by variable ID in ascending
|
||||
///
|
||||
/// * Key: String representation of type variable values, sorted by variable ID in ascending
|
||||
/// order, including type variables associated with the class.
|
||||
/// Value: function symbol name.
|
||||
/// * Value: Function symbol name.
|
||||
instance_to_symbol: HashMap<String, String>,
|
||||
/// Function instances to annotated AST mapping
|
||||
/// Key: string representation of type variable values, sorted by variable ID in ascending
|
||||
///
|
||||
/// * Key: String representation of type variable values, sorted by variable ID in ascending
|
||||
/// order, including type variables associated with the class. Excluding rigid type
|
||||
/// variables.
|
||||
/// rigid type variables that would be substituted when the function is instantiated.
|
||||
///
|
||||
/// Rigid type variables that would be substituted when the function is instantiated.
|
||||
instance_to_stmt: HashMap<String, FunInstance>,
|
||||
// symbol resolver of the module defined the class
|
||||
/// Symbol resolver of the module defined the class.
|
||||
resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
|
||||
// custom codegen callback
|
||||
/// Custom code generation callback.
|
||||
codegen_callback: Option<Arc<GenCall>>,
|
||||
// definition location
|
||||
/// Definition location.
|
||||
loc: Option<Location>,
|
||||
},
|
||||
}
|
||||
|
|
|
@ -13,6 +13,14 @@
|
|||
#error "Unsupported platform - Platform is not 32-bit or 64-bit"
|
||||
#endif
|
||||
|
||||
double dbl_nan(void) {
|
||||
return NAN;
|
||||
}
|
||||
|
||||
double dbl_inf(void) {
|
||||
return INFINITY;
|
||||
}
|
||||
|
||||
void output_bool(bool x) {
|
||||
puts(x ? "True" : "False");
|
||||
}
|
||||
|
|
|
@ -3,7 +3,9 @@
|
|||
import sys
|
||||
import importlib.util
|
||||
import importlib.machinery
|
||||
import numpy as np
|
||||
import pathlib
|
||||
import scipy
|
||||
|
||||
from numpy import int32, int64, uint32, uint64
|
||||
from typing import TypeVar, Generic
|
||||
|
@ -42,6 +44,12 @@ def Some(v: T) -> Option[T]:
|
|||
none = Option(None)
|
||||
|
||||
def patch(module):
|
||||
def dbl_nan():
|
||||
return np.nan
|
||||
|
||||
def dbl_inf():
|
||||
return np.inf
|
||||
|
||||
def output_asciiart(x):
|
||||
if x < 0:
|
||||
sys.stdout.write("\n")
|
||||
|
@ -56,7 +64,11 @@ def patch(module):
|
|||
|
||||
def extern(fun):
|
||||
name = fun.__name__
|
||||
if name == "output_asciiart":
|
||||
if name == "dbl_nan":
|
||||
return dbl_nan
|
||||
elif name == "dbl_inf":
|
||||
return dbl_inf
|
||||
elif name == "output_asciiart":
|
||||
return output_asciiart
|
||||
elif name == "output_float64":
|
||||
return output_float
|
||||
|
@ -86,6 +98,50 @@ def patch(module):
|
|||
module.Some = Some
|
||||
module.none = none
|
||||
|
||||
# NumPy Math functions
|
||||
module.isnan = np.isnan
|
||||
module.isinf = np.isinf
|
||||
module.sin = np.sin
|
||||
module.cos = np.cos
|
||||
module.exp = np.exp
|
||||
module.exp2 = np.exp2
|
||||
module.log = np.log
|
||||
module.log10 = np.log10
|
||||
module.log2 = np.log2
|
||||
module.fabs = np.fabs
|
||||
module.floor = np.floor
|
||||
module.ceil = np.ceil
|
||||
module.trunc = np.trunc
|
||||
module.sqrt = np.sqrt
|
||||
module.rint = np.rint
|
||||
module.tan = np.tan
|
||||
module.arcsin = np.arcsin
|
||||
module.arccos = np.arccos
|
||||
module.arctan = np.arctan
|
||||
module.sinh = np.sinh
|
||||
module.cosh = np.cosh
|
||||
module.tanh = np.tanh
|
||||
module.arcsinh = np.arcsinh
|
||||
module.arccosh = np.arccosh
|
||||
module.arctanh = np.arctanh
|
||||
module.expm1 = np.expm1
|
||||
module.cbrt = np.cbrt
|
||||
module.arctan2 = np.arctan2
|
||||
module.copysign = np.copysign
|
||||
module.fmax = np.fmax
|
||||
module.fmin = np.fmin
|
||||
module.ldexp = np.ldexp
|
||||
module.hypot = np.hypot
|
||||
module.nextafter = np.nextafter
|
||||
|
||||
# SciPy Math Functions
|
||||
module.erf = scipy.special.erf
|
||||
module.erfc = scipy.special.erfc
|
||||
module.gamma = scipy.special.gamma
|
||||
module.gammaln = scipy.special.gammaln
|
||||
module.j0 = scipy.special.j0
|
||||
module.j1 = scipy.special.j1
|
||||
|
||||
|
||||
def file_import(filename, prefix="file_import_"):
|
||||
filename = pathlib.Path(filename)
|
||||
|
|
|
@ -0,0 +1,236 @@
|
|||
@extern
|
||||
def output_bool(x: bool):
|
||||
...
|
||||
|
||||
@extern
|
||||
def output_float64(x: float):
|
||||
...
|
||||
|
||||
@extern
|
||||
def dbl_nan() -> float:
|
||||
...
|
||||
|
||||
@extern
|
||||
def dbl_inf() -> float:
|
||||
...
|
||||
|
||||
def dbl_pi() -> float:
|
||||
return 3.1415926535897932384626433
|
||||
|
||||
def dbl_e() -> float:
|
||||
return 2.71828182845904523536028747135266249775724709369995
|
||||
|
||||
def test_isnan():
|
||||
for x in [dbl_nan(), 0.0, dbl_inf()]:
|
||||
output_bool(isnan(x))
|
||||
|
||||
def test_isinf():
|
||||
for x in [dbl_inf(), -dbl_inf(), 0.0, dbl_nan()]:
|
||||
output_bool(isinf(x))
|
||||
|
||||
def test_sin():
|
||||
pi = dbl_pi()
|
||||
for x in [-pi, -pi / 2.0, -pi / 4.0, 0.0, pi / 4.0, pi / 2.0, pi, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(sin(x))
|
||||
|
||||
def test_cos():
|
||||
pi = dbl_pi()
|
||||
for x in [-pi, -pi / 2.0, -pi / 4.0, 0.0, pi / 4.0, pi / 2.0, pi, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(cos(x))
|
||||
|
||||
def test_exp():
|
||||
for x in [0.0, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(exp(x))
|
||||
|
||||
def test_exp2():
|
||||
for x in [0.0, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(exp2(x))
|
||||
|
||||
def test_log():
|
||||
e = dbl_e()
|
||||
for x in [1.0, e, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(log(x))
|
||||
|
||||
def test_log10():
|
||||
for x in [1.0, 10.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(log10(x))
|
||||
|
||||
def test_log2():
|
||||
for x in [1.0, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(log2(x))
|
||||
|
||||
def test_fabs():
|
||||
for x in [-1.0, 0.0, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(fabs(x))
|
||||
|
||||
def test_floor():
|
||||
for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(floor(x))
|
||||
|
||||
def test_ceil():
|
||||
for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(ceil(x))
|
||||
|
||||
def test_trunc():
|
||||
for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(trunc(x))
|
||||
|
||||
def test_sqrt():
|
||||
for x in [1.0, 2.0, 4.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(sqrt(x))
|
||||
|
||||
def test_rint():
|
||||
for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(rint(x))
|
||||
|
||||
def test_tan():
|
||||
pi = dbl_pi()
|
||||
for x in [-pi, -pi / 2.0, -pi / 4.0, 0.0, pi / 4.0, pi / 2.0, pi, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(tan(x))
|
||||
|
||||
def test_arcsin():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arcsin(x))
|
||||
|
||||
def test_arccos():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arccos(x))
|
||||
|
||||
def test_arctan():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arctan(x))
|
||||
|
||||
def test_sinh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(sinh(x))
|
||||
|
||||
def test_cosh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(cosh(x))
|
||||
|
||||
def test_tanh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(tanh(x))
|
||||
|
||||
def test_arcsinh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arcsinh(x))
|
||||
|
||||
def test_arccosh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arccosh(x))
|
||||
|
||||
def test_arctanh():
|
||||
for x in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arctanh(x))
|
||||
|
||||
def test_expm1():
|
||||
for x in [0.0, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(expm1(x))
|
||||
|
||||
def test_cbrt():
|
||||
for x in [1.0, 8.0, 27.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(expm1(x))
|
||||
|
||||
def test_erf():
|
||||
for x in [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(erf(x))
|
||||
|
||||
def test_erfc():
|
||||
for x in [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(erfc(x))
|
||||
|
||||
def test_gamma():
|
||||
for x in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(gamma(x))
|
||||
|
||||
def test_gammaln():
|
||||
for x in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(gammaln(x))
|
||||
|
||||
def test_j0():
|
||||
for x in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(j0(x))
|
||||
|
||||
def test_j1():
|
||||
for x in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]:
|
||||
output_float64(j1(x))
|
||||
|
||||
def test_arctan2():
|
||||
for x1 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(arctan2(x1, x2))
|
||||
|
||||
def test_copysign():
|
||||
for x1 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(copysign(x1, x2))
|
||||
|
||||
def test_fmax():
|
||||
for x1 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(fmax(x1, x2))
|
||||
|
||||
def test_fmin():
|
||||
for x1 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-1.0, -0.5, 0.0, 0.5, 1.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(fmin(x1, x2))
|
||||
|
||||
def test_ldexp():
|
||||
for x1 in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-2, -1, 0, 1, 2]:
|
||||
output_float64(ldexp(x1, x2))
|
||||
|
||||
def test_hypot():
|
||||
for x1 in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(hypot(x1, x2))
|
||||
|
||||
def test_nextafter():
|
||||
for x1 in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
for x2 in [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
|
||||
output_float64(nextafter(x1, x2))
|
||||
|
||||
def run() -> int32:
|
||||
test_isnan()
|
||||
test_isinf()
|
||||
test_sin()
|
||||
test_cos()
|
||||
test_exp()
|
||||
test_exp2()
|
||||
test_log()
|
||||
test_log10()
|
||||
test_log2()
|
||||
test_fabs()
|
||||
test_floor()
|
||||
test_ceil()
|
||||
test_trunc()
|
||||
test_sqrt()
|
||||
test_rint()
|
||||
test_tan()
|
||||
test_arcsin()
|
||||
test_arccos()
|
||||
test_arctan()
|
||||
test_sinh()
|
||||
test_cosh()
|
||||
test_tanh()
|
||||
test_arcsinh()
|
||||
test_arccosh()
|
||||
test_arctanh()
|
||||
test_expm1()
|
||||
test_cbrt()
|
||||
test_erf()
|
||||
test_erfc()
|
||||
test_gamma()
|
||||
test_gammaln()
|
||||
test_j0()
|
||||
test_j1()
|
||||
test_arctan2()
|
||||
test_copysign()
|
||||
test_fmax()
|
||||
test_fmin()
|
||||
test_ldexp()
|
||||
test_hypot()
|
||||
test_nextafter()
|
||||
|
||||
return 0
|
Loading…
Reference in New Issue