Struct Lsr 

pub struct Lsr {
    pub time: Timestamp,
    pub long: Percent,
}

Fields

time: Timestamp

long: Percent

Implementations

impl Lsr

pub fn ratio(&self) -> f64

pub fn short(&self) -> f64

Percentage of short positions

pub fn long(&self) -> f64

Percentage of long positions. // here only for consistency with short

Methods from Deref<Target = f64>

pub const RADIX: u32 = 2

pub const BITS: u32 = 64

pub const MANTISSA_DIGITS: u32 = 53

pub const DIGITS: u32 = 15

pub const EPSILON: f64 = 2.2204460492503131e-16_f64

pub const MIN: f64 = -1.7976931348623157e+308_f64

pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64

pub const MAX: f64 = 1.7976931348623157e+308_f64

pub const MIN_EXP: i32 = -1021

pub const MAX_EXP: i32 = 1024

pub const MIN_10_EXP: i32 = -307

pub const MAX_10_EXP: i32 = 308

pub const NAN: f64

pub const INFINITY: f64

pub const NEG_INFINITY: f64

pub const MAX_EXACT_INTEGER: i64

pub const MIN_EXACT_INTEGER: i64

pub const SIGN_MASK: u64 = 0x8000_0000_0000_0000

pub const EXPONENT_MASK: u64 = 0x7ff0_0000_0000_0000

pub const MANTISSA_MASK: u64 = 0x000f_ffff_ffff_ffff

pub fn total_cmp(&self, other: &f64) -> Ordering

Returns the ordering between self and other.

Unlike the standard partial comparison between floating point numbers, this comparison always produces an ordering in accordance to the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard. The values are ordered in the following sequence:

• negative quiet NaN
• negative signaling NaN
• negative infinity
• negative numbers
• negative subnormal numbers
• negative zero
• positive zero
• positive subnormal numbers
• positive numbers
• positive infinity
• positive signaling NaN
• positive quiet NaN.

The ordering established by this function does not always agree with the PartialOrd and PartialEq implementations of f64. For example, they consider negative and positive zero equal, while total_cmp doesn’t.

The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.

Example

struct GoodBoy {
    name: String,
    weight: f64,
}

let mut bois = vec![
    GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },
    GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },
    GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];

bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));

// `f64::NAN` could be positive or negative, which will affect the sort order.
if f64::NAN.is_sign_negative() {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([f64::NAN, -5.0, 0.1, 10.0, 99.0, f64::INFINITY].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
}

Trait Implementations

impl Clone for Lsr

fn clone(&self) -> Lsr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Lsr

impl Debug for Lsr

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

Formats the value using the given formatter.

impl Default for Lsr

fn default() -> Lsr

Returns the “default value” for a type.

impl Deref for Lsr

type Target = Percent

The resulting type after dereferencing.

fn deref(&self) -> &<Lsr as Deref>::Target

Dereferences the value.

impl DerefMut for Lsr

fn deref_mut(&mut self) -> &mut <Lsr as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Lsr

fn deserialize<__D>( __deserializer: __D, ) -> Result<Lsr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LsrResponse> for Lsr

fn from(r: LsrResponse) -> Lsr

Converts to this type from the input type.

impl From<f64> for Lsr

fn from(f: f64) -> Lsr

Converts to this type from the input type.

impl Serialize for Lsr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.