Struct InverseSqrt 

pub struct InverseSqrt {
    pub iterations: u64,
    pub denominator_cap_2k: u64,
}

A structure that defines the custom operation InverseSqrt that computes an approximate inverse square root using Newton iterations.

In particular, this operation computes an approximation of 2^{denominator_cap_2k} / sqrt(input).

Input must be of the scalar type UINT64/INT64 and be in (0, 2^{2 * denominator_cap_2k - 1}) range. The input is also assumed to be small enough (less than 2²¹), otherwise integer overflows are possible, yielding incorrect results. In case of INT64 type, negative inputs yield undefined behavior.

Optionally, an initial approximation for the Newton iterations can be provided. In this case, the operation might be faster and of lower depth, however, it must be guaranteed that 2^{2 * denominator_cap_2k - 2} <= input * initial_approximation <= 2^{2 * denominator_cap_2k}.

The following formula for the Newton iterations is used: x_{i + 1} = x_i * (3 / 2 - d / 2 * x_i * x_i).

Custom operation arguments

• Node containing an unsigned 64-bit array or scalar to compute the inverse square root
• (optional) Node containing an array or scalar that serves as an initial approximation of the Newton iterations

Custom operation returns

New InverseSqrt node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t = array_type(vec![2, 3], UINT64);
let n1 = g.input(t.clone()).unwrap();
let guess_n = g.input(t.clone()).unwrap();
let n2 = g.custom_op(CustomOperation::new(InverseSqrt {iterations: 10, denominator_cap_2k: 4}), vec![n1, guess_n]).unwrap();

Fields

iterations: u64

Number of iterations of the Newton-Raphson algorithm

denominator_cap_2k: u64

Number of output bits that are approximated

Trait Implementations

impl CustomOperationBody for InverseSqrt

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 InverseSqrt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InverseSqrt

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for InverseSqrt

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 InverseSqrt

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

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

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 InverseSqrt

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 InverseSqrt

impl StructuralPartialEq for InverseSqrt