use super::contract::UnaryOp;
use crate::domain::RealScalar;
use eunomia::NumericElement;
macro_rules! define_unary_op {
($(#[$meta:meta])* $name:ident => $method:ident) => {
define_unary_op!($(#[$meta])* $name => $method, true);
};
($(#[$meta:meta])* $name:ident => $method:ident, $compute_bound:expr) => {
$(#[$meta])*
#[derive(Clone, Copy, Debug, Default)]
pub struct $name;
impl<T: RealScalar> UnaryOp<T> for $name {
const COMPUTE_BOUND: bool = $compute_bound;
#[inline(always)]
fn apply(&self, x: T) -> T {
x.$method()
}
}
};
}
define_unary_op!( ExpOp => exp);
define_unary_op!( LnOp => ln);
define_unary_op!( ErfOp => erf);
define_unary_op!( ErfcOp => erfc);
define_unary_op!( LgammaOp => lgamma);
define_unary_op!( SinOp => sin);
define_unary_op!( CosOp => cos);
define_unary_op!( SqrtOp => sqrt);
define_unary_op!( AbsOp => abs, false);
define_unary_op!( NegOp => neg, false);
define_unary_op!( RecipOp => recip);
define_unary_op!( TanOp => tan);
define_unary_op!( AsinOp => asin);
define_unary_op!( AcosOp => acos);
define_unary_op!( AtanOp => atan);
define_unary_op!( SinhOp => sinh);
define_unary_op!( CoshOp => cosh);
define_unary_op!( TanhOp => tanh);
define_unary_op!( Log2Op => log2);
define_unary_op!( Log10Op => log10);
define_unary_op!( Exp2Op => exp2);
define_unary_op!( AtanhOp => atanh);
define_unary_op!( AsinhOp => asinh);
define_unary_op!( AcoshOp => acosh);
define_unary_op!( Expm1Op => exp_m1);
define_unary_op!( Log1pOp => ln_1p);
define_unary_op!( FloorOp => floor, false);
define_unary_op!( CeilOp => ceil, false);
define_unary_op!( RoundOp => round, false);
define_unary_op!( TruncOp => trunc, false);
#[derive(Clone, Copy, Debug, Default)]
pub struct ExpNegOp;
impl<T: RealScalar> UnaryOp<T> for ExpNegOp {
#[inline(always)]
fn apply(&self, x: T) -> T {
(-x).exp()
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct SignOp;
impl<T: RealScalar> UnaryOp<T> for SignOp {
const COMPUTE_BOUND: bool = false;
#[inline(always)]
fn apply(&self, x: T) -> T {
if x.is_nan() {
<T as NumericElement>::ZERO
} else if x > <T as NumericElement>::ZERO {
<T as NumericElement>::ONE
} else if x < <T as NumericElement>::ZERO {
-<T as NumericElement>::ONE
} else {
<T as NumericElement>::ZERO
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct PowfOp<T: RealScalar> {
pub exponent: T,
}
impl<T: RealScalar> UnaryOp<T> for PowfOp<T> {
#[inline(always)]
fn apply(&self, x: T) -> T {
x.powf(self.exponent)
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct SincOp;
impl<T: RealScalar> UnaryOp<T> for SincOp {
#[inline(always)]
fn apply(&self, x: T) -> T {
if x == <T as NumericElement>::ZERO {
<T as NumericElement>::ONE
} else {
x.sin() / x
}
}
}