lfest 0.138.3

A leveraged perpetual futures exchange for simulated trading and backtesting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use const_decimal::Decimal;

use crate::prelude::*;

/// When no user specified order id is required.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
pub struct NoUserOrderId;

impl std::fmt::Display for NoUserOrderId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "NoUserId")
    }
}

/// Return the minimum of two values
#[inline(always)]
#[mutants::skip]
pub(crate) fn min<T>(v0: T, v1: T) -> T
where
    T: PartialOrd,
{
    if v0 < v1 { v0 } else { v1 }
}

/// Return the maximum of two values
#[inline(always)]
#[mutants::skip]
pub(crate) fn max<T>(v0: T, v1: T) -> T
where
    T: PartialOrd,
{
    if v0 > v1 { v0 } else { v1 }
}

/// Create a `Decimal` from an `f64` value.
// TODO: maybe upstream this impl to `const_decimal`
#[inline(always)]
pub fn decimal_from_f64<I: Mon<D>, const D: u8>(val: f64) -> Option<Decimal<I, D>> {
    let scaling_factor = 10_f64.powi(D as i32);
    let scaled: f64 = (val * scaling_factor).round();
    Decimal::try_from_scaled(I::from(scaled as i64)?, D)
}

/// Scales the value from one range into another
///
/// # Arguments:
/// `from_min`: The minimum value of the origin range
/// `from_max`: The maximum value of the origin range
/// `to_min`: The minimum value of the target range
/// `to_max`: The maximum value of the target range
/// `value`: The value to translate from one range into the other
///
/// # Returns:
/// The scaled value
///
/// Used in benchmarks
#[inline(always)]
pub fn scale<F: num::Float>(from_min: F, from_max: F, to_min: F, to_max: F, value: F) -> F {
    assert2::debug_assert!(from_min <= from_max);
    assert2::debug_assert!(to_min <= to_max);
    to_min + ((value - from_min) * (to_max - to_min)) / (from_max - from_min)
}

/// The margin requirement for all the tracked orders.
#[inline(always)]
pub(crate) fn order_margin<I, const D: u8, BaseOrQuote>(
    bids_notional: BaseOrQuote::PairedCurrency,
    asks_notional: BaseOrQuote::PairedCurrency,
    init_margin_req: Decimal<I, D>,
    position: &Position<I, D, BaseOrQuote>,
) -> BaseOrQuote::PairedCurrency
where
    I: Mon<D>,
    BaseOrQuote: Currency<I, D>,
    BaseOrQuote::PairedCurrency: MarginCurrency<I, D>,
{
    assert2::debug_assert!(init_margin_req > Decimal::zero());
    assert2::debug_assert!(init_margin_req <= Decimal::one());

    use std::cmp::Ordering::*;
    match position.quantity().cmp(&Zero::zero()) {
        Equal => max(bids_notional, asks_notional) * init_margin_req,
        Greater => max(bids_notional, asks_notional - position.notional()) * init_margin_req,
        Less => max(bids_notional - position.notional(), asks_notional) * init_margin_req,
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use const_decimal::Decimal;
    use proptest::prelude::*;

    use super::*;

    proptest! {
        #[test]
        fn scale_proptest(a in 0..100) {
            assert_eq!(scale(0.0, 1.0, 0.0, 100.0, a as f64), a as f64 * 100.0);
            assert_eq!(scale(0.0, 100.0, 0.0, 1.0, a as f64), a as f64 / 100.0);
        }

    }

    #[test]
    fn scale_test() {
        assert_eq!(scale(-1.0, 1.0, 0.0, 1.0, 0.5), 0.75);
        assert_eq!(scale(-1.0, 1.0, 0.0, 1.0, -0.5), 0.25);
        assert_eq!(scale(-1.0, 1.0, -1.0, 1.0, 0.5), 0.5);
    }

    #[test]
    fn test_convert_decimals() {
        assert_eq!(
            Decimal::<i32, 0>::try_from_scaled(10, 1)
                .expect("can convert")
                .0,
            1
        );
    }

    #[test]
    fn test_decimal_from_f64() {
        assert_eq!(
            decimal_from_f64(3.0).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(3, 0).unwrap()
        );
        assert_eq!(
            decimal_from_f64(3.1).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(31, 1).unwrap()
        );
        assert_eq!(
            decimal_from_f64(3.14).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(314, 2).unwrap()
        );
        assert_eq!(
            decimal_from_f64(3.141).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(3141, 3).unwrap()
        );
        assert_eq!(
            decimal_from_f64(3.1415).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(31415, 4).unwrap()
        );
        assert_eq!(
            decimal_from_f64(3.14159).unwrap(),
            Decimal::<i64, 5>::try_from_scaled(314159, 5).unwrap()
        );
    }

    #[test]
    fn no_user_order_id_display() {
        assert_eq!(&NoUserOrderId.to_string(), "NoUserId");
    }
}