use super::kernel::{elementwise_unary, elementwise_unary_assign};
use crate::backend_ops::{BackendOps, UnaryOp};
use coeus_core::{Float, Scalar};
use coeus_tensor::Tensor;
#[inline]
pub fn sin<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Sin).expect("sin")
}
#[inline]
pub fn cos<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Cos).expect("cos")
}
#[inline]
pub fn exp<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Exp).expect("exp")
}
#[inline]
pub fn log<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Log).expect("log")
}
#[inline]
pub fn erf<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Erf).expect("erf")
}
#[inline]
pub fn erfc<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Erfc).expect("erfc")
}
#[inline]
pub fn lgamma<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Lgamma).expect("lgamma")
}
#[inline]
pub fn tan<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Tan).expect("tan")
}
#[inline]
pub fn asin<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Asin).expect("asin")
}
#[inline]
pub fn acos<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Acos).expect("acos")
}
#[inline]
pub fn atan<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Atan).expect("atan")
}
#[inline]
pub fn sinh<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Sinh).expect("sinh")
}
#[inline]
pub fn cosh<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Cosh).expect("cosh")
}
#[inline]
pub fn log2<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Log2).expect("log2")
}
#[inline]
pub fn log10<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Log10).expect("log10")
}
#[inline]
pub fn exp2<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Exp2).expect("exp2")
}
#[inline]
pub fn atanh<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Atanh).expect("atanh")
}
#[inline]
pub fn asinh<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Asinh).expect("asinh")
}
#[inline]
pub fn acosh<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Acosh).expect("acosh")
}
#[inline]
pub fn expm1<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Expm1).expect("expm1")
}
#[inline]
pub fn log1p<T: Float, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Log1p).expect("log1p")
}
#[inline]
pub fn neg<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Neg).expect("neg")
}
#[inline]
pub fn abs<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Abs).expect("abs")
}
#[inline]
pub fn sqrt<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Sqrt).expect("sqrt")
}
#[inline]
pub fn sin_assign<T: Float, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Sin)?;
Ok(())
}
#[inline]
pub fn cos_assign<T: Float, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Cos)?;
Ok(())
}
#[inline]
pub fn exp_assign<T: Float, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Exp)?;
Ok(())
}
#[inline]
pub fn log_assign<T: Float, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Log)?;
Ok(())
}
#[inline]
pub fn neg_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Neg)?;
Ok(())
}
#[inline]
pub fn abs_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Abs)?;
Ok(())
}
#[inline]
pub fn sqrt_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Sqrt)?;
Ok(())
}
#[inline]
pub fn recip<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Recip).expect("recip")
}
#[inline]
pub fn sign<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Sign).expect("sign")
}
#[inline]
pub fn floor<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Floor).expect("floor")
}
#[inline]
pub fn ceil<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Ceil).expect("ceil")
}
#[inline]
pub fn round<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Round).expect("round")
}
#[inline]
pub fn trunc<T: Scalar, B: BackendOps<T>>(input: &Tensor<T, B>, backend: &B) -> Tensor<T, B> {
elementwise_unary(input, backend, UnaryOp::Trunc).expect("trunc")
}
#[inline]
pub fn recip_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Recip)?;
Ok(())
}
#[inline]
pub fn sign_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Sign)?;
Ok(())
}
#[inline]
pub fn floor_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Floor)?;
Ok(())
}
#[inline]
pub fn ceil_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Ceil)?;
Ok(())
}
#[inline]
pub fn round_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Round)?;
Ok(())
}
#[inline]
pub fn trunc_assign<T: Scalar, B: BackendOps<T>>(
input: &mut Tensor<T, B>,
backend: &B,
) -> Result<(), B::Error> {
elementwise_unary_assign(input, backend, UnaryOp::Trunc)?;
Ok(())
}