Enum FeeModel 

pub enum FeeModel {
    Zero,
    Flat(f64),
    MakerTaker {
        maker: f64,
        taker: f64,
    },
}

Pluggable fee schedule.

Example

use rustrade_backtest::FeeModel;

// 5 bps flat fee.
let f = FeeModel::Flat(0.0005);
assert!((f.fee_for(100.0, 10.0, true) - 0.5).abs() < 1e-9);

// Different maker / taker rates.
let mt = FeeModel::MakerTaker { maker: 0.0002, taker: 0.0006 };
assert!((mt.fee_for(100.0, 1.0, true) - 0.06).abs() < 1e-9);
assert!((mt.fee_for(100.0, 1.0, false) - 0.02).abs() < 1e-9);

Variants

Zero

Zero fees — useful for sanity-checking PnL against a pure price-difference benchmark.

Flat(f64)

Flat rate applied to every fill, as a fraction of notional. 0.001 = 10 bps = 0.1%.

MakerTaker

Different rates for maker vs taker fills. The engine charges the taker rate for market / IOC / FOK orders and closes, and the maker rate for limit / post-only orders that rest before filling.

Fields

maker: f64

Fraction-of-notional rate when the fill is a maker.

taker: f64

Fraction-of-notional rate when the fill is a taker.

Implementations

impl FeeModel

pub fn fee_for(self, fill_price: f64, size: f64, is_taker: bool) -> f64

Compute the fee in quote currency for a fill of size units at fill_price. The boolean is_taker is ignored unless the model is MakerTaker.

Trait Implementations

impl Clone for FeeModel

fn clone(&self) -> FeeModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FeeModel

impl Debug for FeeModel

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

Formats the value using the given formatter.

impl Default for FeeModel

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FeeModel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FeeModel

fn eq(&self, other: &FeeModel) -> 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 FeeModel

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FeeModel