Struct TaylorExponent

pub struct TaylorExponent {
    pub taylor_terms: u64,
    pub fixed_precision_points: u64,
}

A structure that defines the custom operation TaylorExponent that computes an approximate exp(x / (2 ** fixed_precision)) * (2 ** fixed_precision) using Taylor expansion.

Note that Taylor expansion correcly approximates exp(x) only for positive x, so we have to do A2B to get the MSB. Since we’re doing A2B anyway, we can compute exp(integer_part(x)) and exp(fractional_part(x)) separately, computing the former directly from bits, and using Taylor expansion for the latter, getting better precision. See the Keller-Sun paper, Algorithm 2 for more details.

So far this operation supports only INT64 scalar type.

Custom operation arguments

• Node containing a signed 64-bit array or scalar to compute the exponent

Custom operation returns

New TaylorExponent node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t = array_type(vec![2, 3], INT64);
let x = g.input(t.clone()).unwrap();
let n2 = g.custom_op(CustomOperation::new(TaylorExponent {taylor_terms: 5, fixed_precision_points: 4}), vec![x]).unwrap();

Fields

taylor_terms: u64

Number of terms from the Taylor expansion to consider (5 is typically enough).

fixed_precision_points: u64

Assume that we’re operating in fixed precision arithmetic with denominator 2 ** fixed_precision_points.

Trait Implementations

impl CustomOperationBody for TaylorExponent

fn instantiate( &self, context: Context, arguments_types: Vec<Type>, ) -> Result<Graph>

Defines the logic of a custom operation.

fn get_name(&self) -> String

Specifies and returns the name of this custom operation.

impl Debug for TaylorExponent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaylorExponent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for TaylorExponent

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TaylorExponent

fn eq(&self, other: &TaylorExponent) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TaylorExponent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TaylorExponent

impl StructuralPartialEq for TaylorExponent