use super::kernel::{elementwise_unary, elementwise_unary_assign};
use crate::backend_ops::{BackendOps, ElementwiseOps, 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,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Sin)
}
#[inline]
pub fn cos<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Cos)
}
#[inline]
pub fn exp<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Exp)
}
#[inline]
pub fn log<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Log)
}
#[inline]
pub fn erf<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Erf)
}
#[inline]
pub fn erfc<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Erfc)
}
#[inline]
pub fn lgamma<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Lgamma)
}
#[inline]
pub fn tan<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Tan)
}
#[inline]
pub fn asin<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Asin)
}
#[inline]
pub fn acos<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Acos)
}
#[inline]
pub fn atan<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Atan)
}
#[inline]
pub fn sinh<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Sinh)
}
#[inline]
pub fn cosh<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Cosh)
}
#[inline]
pub fn log2<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Log2)
}
#[inline]
pub fn log10<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Log10)
}
#[inline]
pub fn exp2<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Exp2)
}
#[inline]
pub fn atanh<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Atanh)
}
#[inline]
pub fn asinh<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Asinh)
}
#[inline]
pub fn acosh<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Acosh)
}
#[inline]
pub fn expm1<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Expm1)
}
#[inline]
pub fn log1p<T: Float, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Log1p)
}
#[inline]
pub fn neg<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Neg)
}
#[inline]
pub fn abs<T: Scalar, B: ElementwiseOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Abs)
}
#[inline]
pub fn sqrt<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::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: ElementwiseOps<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,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Recip)
}
#[inline]
pub fn sign<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Sign)
}
#[inline]
pub fn floor<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Floor)
}
#[inline]
pub fn ceil<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Ceil)
}
#[inline]
pub fn round<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::Round)
}
#[inline]
pub fn trunc<T: Scalar, B: BackendOps<T>>(
input: &Tensor<T, B>,
backend: &B,
) -> Result<Tensor<T, B>, B::Error> {
elementwise_unary(input, backend, UnaryOp::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(())
}