Struct pyth_client::PriceConf

pub struct PriceConf {
    pub price: i64,
    pub conf: u64,
    pub expo: i32,
}

A price with a degree of uncertainty, represented as a price +- a confidence interval. The confidence interval roughly corresponds to the standard error of a normal distribution. Both the price and confidence are stored in a fixed-point numeric representation, x * 10^expo, where expo is the exponent. For example:

use pyth_client::PriceConf;
PriceConf { price: 12345, conf: 267, expo: -2 }; // represents 123.45 +- 2.67
PriceConf { price: 123, conf: 1, expo: 2 }; // represents 12300 +- 100

PriceConf supports a limited set of mathematical operations. All of these operations will propagate any uncertainty in the arguments into the result. However, the uncertainty in the result may overestimate the true uncertainty (by at most a factor of sqrt(2)) due to computational limitations. Furthermore, all of these operations may return None if their result cannot be represented within the numeric representation (e.g., the exponent is so small that the price does not fit into an i64). Users of these methods should (1) select their exponents to avoid this problem, and (2) handle the None case gracefully.

Fields

price: i64

conf: u64

expo: i32

Implementations

impl PriceConf

pub fn div(&self, other: &PriceConf) -> Option<PriceConf>

Divide this price by other while propagating the uncertainty in both prices into the result.

This method will automatically select a reasonable exponent for the result. If both self and other are normalized, the exponent is self.expo + PD_EXPO - other.expo (i.e., the fraction has PD_EXPO digits of additional precision). If they are not normalized, this method will normalize them, resulting in an unpredictable result exponent. If the result is used in a context that requires a specific exponent, please call scale_to_exponent on it.

pub fn add(&self, other: &PriceConf) -> Option<PriceConf>

Add other to this, propagating uncertainty in both prices. Requires both PriceConfs to have the same exponent – use scale_to_exponent on the arguments if necessary.

TODO: could generalize this method to support different exponents.

pub fn cmul(&self, c: i64, e: i32) -> Option<PriceConf>

Multiply this PriceConf by a constant c * 10^e.

pub fn mul(&self, other: &PriceConf) -> Option<PriceConf>

Multiply this PriceConf by other, propagating any uncertainty.

pub fn normalize(&self) -> Option<PriceConf>

Get a copy of this struct where the price and confidence have been normalized to be between MIN_PD_V_I64 and MAX_PD_V_I64.

pub fn scale_to_exponent(&self, target_expo: i32) -> Option<PriceConf>

Scale this price/confidence so that its exponent is target_expo. Return None if this number is outside the range of numbers representable in target_expo, which will happen if target_expo is too small.

Warning: if target_expo is significantly larger than the current exponent, this function will return 0 +- 0.

Trait Implementations

impl BorshDeserialize for PriceConf where
    i64: BorshDeserialize,
    u64: BorshDeserialize,
    i32: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for PriceConf where
    i64: BorshSerialize,
    u64: BorshSerialize,
    i32: BorshSerialize, 

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl Clone for PriceConf

fn clone(&self) -> PriceConf

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PriceConf

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

Formats the value using the given formatter.

impl PartialEq<PriceConf> for PriceConf

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for PriceConf