Struct Dual 

pub struct Dual<L, R, IT, OT> { /* private fields */ }

Implementations

impl<L, R, T: Number> Dual<L, R, T, T>

pub fn add(left: L, right: R) -> Self

pub fn div(left: L, right: R) -> Self

pub fn mul(left: L, right: R) -> Self

pub fn pow(left: L, right: R) -> Self

pub fn rem(left: L, right: R) -> Self

where T: Real,

pub fn sub(left: L, right: R) -> Self

impl<L, R, T: Float> Dual<L, R, T, T>

pub fn log(left: L, right: R) -> Self

impl<L, R, T: Number> Dual<L, R, T, u8>

pub fn and(left: L, right: R) -> Self

pub fn or(left: L, right: R) -> Self

pub fn xor(left: L, right: R) -> Self

impl<L, R, T: Number> Dual<L, R, T, u8>

pub fn eq(left: L, right: R) -> Self

pub fn ne(left: L, right: R) -> Self

impl<L, R, T: Number + PartialOrd> Dual<L, R, T, u8>

pub fn ge(left: L, right: R) -> Self

pub fn gt(left: L, right: R) -> Self

pub fn le(left: L, right: R) -> Self

pub fn lt(left: L, right: R) -> Self

Trait Implementations

impl<L, R, IT, OT> Enqueue<Heap, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: Number, OT: Number,

type Buffer = Vec<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<L, R, IT, OT> Enqueue<Host, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: Number, OT: Number,

type Buffer = Buffer<OT>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<L, R, IT, OT> Enqueue<Stack, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: Number, OT: Number,

type Buffer = SmallVec<[OT; 64]>

fn enqueue(&self) -> Result<Self::Buffer, Error>

impl<L, R, IT, OT> From<Dual<L, R, IT, OT>> for Dual<L, R, IT, OT>

fn from(op: Dual<L, R, IT, OT>) -> Self

Converts to this type from the input type.

impl<L, R, IT, OT> Op for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: Number, OT: Number,

fn size(&self) -> usize

impl<L, R, IT, OT> ReadValue<Host, OT> for Dual<L, R, IT, OT>

where L: Access<IT>, R: Access<IT>, IT: Number, OT: Number,

fn read_value(&self, offset: usize) -> Result<OT, Error>