> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/dhir1007/nanoARB/llms.txt > Use this file to discover all available pages before exploring further. # Core Types > Fundamental data types for high-frequency trading operations ## Overview NanoARB uses fixed-point arithmetic and zero-copy serialization for maximum performance in HFT applications. All core types are optimized for nanosecond-level precision and deterministic behavior. ## Price Fixed-point price representation that avoids floating-point errors. ### Definition ```rust theme={null} pub struct Price(i64); ``` Uses `i64` internally to represent prices in the smallest tick unit. This ensures deterministic arithmetic and avoids floating-point precision issues. Zero price constant Maximum price constant (i64::MAX) Minimum price constant (i64::MIN) ### Constructors Create a price from raw tick value ```rust theme={null} let price = Price::from_raw(50025); assert_eq!(price.raw(), 50025); ``` Create a price from ticks and decimal places ```rust theme={null} // Create a price of $500.25 with 2 decimal places let price = Price::from_ticks(50025, 2); ``` Create a price from a floating-point value with specified tick size ```rust theme={null} let price = Price::from_f64(500.25, 0.01); assert_eq!(price.raw(), 50025); ``` ### Methods Get the raw tick value ```rust theme={null} let price = Price::from_raw(50025); assert_eq!(price.raw(), 50025); ``` Convert to f64 (assumes tick size of 0.01) ```rust theme={null} let price = Price::from_raw(50025); assert_eq!(price.as_f64(), 500.25); ``` Convert to f64 with specified tick size ```rust theme={null} let price = Price::from_raw(50025); assert_eq!(price.as_f64_with_tick(0.01), 500.25); ``` Check if the price is zero Check if the price is positive Check if the price is negative Get the absolute value ### Arithmetic Operations ```rust theme={null} let p1 = Price::from_raw(100); let p2 = Price::from_raw(50); // Addition assert_eq!((p1 + p2).raw(), 150); // Subtraction assert_eq!((p1 - p2).raw(), 50); // Multiplication by scalar assert_eq!((p1 * 2).raw(), 200); // Division by scalar assert_eq!((p1 / 2).raw(), 50); // Saturating operations (prevent overflow) let max = Price::MAX; assert_eq!(max.saturating_add(p1), Price::MAX); // Checked operations (return Option) if let Some(result) = p1.checked_add(p2) { println!("Sum: {}", result.raw()); } ``` *** ## Quantity Represents order and position sizes using unsigned integers. ### Definition ```rust theme={null} pub struct Quantity(u32); ``` Zero quantity constant Maximum quantity constant (u32::MAX) ### Constructors Create a new quantity ```rust theme={null} let qty = Quantity::new(100); assert_eq!(qty.value(), 100); ``` ### Methods Get the raw value Check if quantity is zero Convert to i64 for position calculations Convert to f64 for calculations ### Example Usage ```rust theme={null} let q1 = Quantity::new(100); let q2 = Quantity::new(50); // Arithmetic assert_eq!((q1 + q2).value(), 150); assert_eq!((q1 - q2).value(), 50); assert_eq!((q1 * 2).value(), 200); // Saturating operations let result = q1.saturating_add(q2); ``` *** ## SignedQuantity Signed quantity for positions (positive = long, negative = short). ### Definition ```rust theme={null} pub struct SignedQuantity(i64); ``` ### Methods Create a new signed quantity Get the raw value Get the absolute value as unsigned quantity Check if the position is long (positive) Check if the position is short (negative) Check if the position is flat (zero) ### Example Usage ```rust theme={null} let long = SignedQuantity::new(100); let short = SignedQuantity::new(-50); assert!(long.is_long()); assert!(short.is_short()); assert_eq!((long + short).value(), 50); assert_eq!(short.abs().value(), 50); ``` *** ## Side Order/Trade side enumeration. ### Definition ```rust theme={null} #[repr(u8)] pub enum Side { Buy = 0, Sell = 1, } ``` ### Methods Check if this is a buy side Check if this is a sell side Get the opposite side ```rust theme={null} assert_eq!(Side::Buy.opposite(), Side::Sell); ``` Convert to a sign multiplier (1 for buy, -1 for sell) ```rust theme={null} assert_eq!(Side::Buy.sign(), 1); assert_eq!(Side::Sell.sign(), -1); ``` Convert to a sign multiplier as f64 ### Conversions ```rust theme={null} // From boolean let side = Side::from_is_buy(true); assert_eq!(side, Side::Buy); // From u8 let side = Side::from_u8(0); assert_eq!(side, Some(Side::Buy)); // To u8 let value: u8 = Side::Buy.as_u8(); assert_eq!(value, 0); // Using Not operator assert_eq!(!Side::Buy, Side::Sell); ``` *** ## Timestamp Nanosecond-precision timestamp since Unix epoch. ### Definition ```rust theme={null} pub struct Timestamp(i64); ``` Optimized for HFT applications where every nanosecond matters. Zero timestamp (Unix epoch) Maximum timestamp Minimum timestamp ### Constructors Create a timestamp from nanoseconds since epoch Create a timestamp from microseconds since epoch Create a timestamp from milliseconds since epoch Create a timestamp from seconds since epoch Get the current timestamp ```rust theme={null} let ts = Timestamp::now(); ``` ### Methods Get nanoseconds since epoch Get microseconds since epoch Get milliseconds since epoch Get seconds since epoch Get the nanosecond component (0-999,999,999) Calculate duration to another timestamp in nanoseconds ```rust theme={null} let t1 = Timestamp::from_nanos(1000); let t2 = Timestamp::from_nanos(500); assert_eq!(t1.duration_since(t2), 500); ``` ### Example Usage ```rust theme={null} let ts = Timestamp::now(); let later = ts.add_nanos(1000); assert!(later > ts); // Time arithmetic let t1 = Timestamp::from_nanos(1000); let t2 = t1.add_micros(1); // Add 1 microsecond let t3 = t1.add_millis(1); // Add 1 millisecond // Duration calculation let duration = t2.duration_since(t1); println!("Duration: {} ns", duration); // Convert to chrono DateTime let dt = ts.to_datetime(); println!("DateTime: {}", dt); ``` *** ## OrderId Unique order identifier. ### Definition ```rust theme={null} pub struct OrderId(u64); ``` ### Methods Create a new order ID ```rust theme={null} let id = OrderId::new(12345); ``` Get the raw value ```rust theme={null} let id = OrderId::new(12345); assert_eq!(id.value(), 12345); ``` ### Conversions ```rust theme={null} // From u64 let id: OrderId = 12345u64.into(); // To u64 let value: u64 = id.into(); ``` *** ## Order A trading order with full lifecycle tracking. ### Definition ```rust theme={null} pub struct Order { pub id: OrderId, pub instrument_id: u32, pub side: Side, pub order_type: OrderType, pub time_in_force: TimeInForce, pub status: OrderStatus, pub price: Price, pub stop_price: Price, pub quantity: Quantity, pub filled_quantity: Quantity, pub avg_fill_price: i64, pub created_at: Timestamp, pub updated_at: Timestamp, } ``` ### Order Types ```rust theme={null} pub enum OrderType { Limit, // Specify price and quantity Market, // Execute at best available price Stop, // Trigger at stop price, then execute as market StopLimit, // Trigger at stop price, then place limit order } ``` ### Time In Force ```rust theme={null} pub enum TimeInForce { GTC, // Good till cancelled IOC, // Immediate or cancel (partial fills allowed) FOK, // Fill or kill (no partial fills) Day, // Expires at end of trading session GTD, // Good till date } ``` ### Order Status ```rust theme={null} pub enum OrderStatus { Pending, // Order is pending submission Submitted, // Order has been submitted to exchange Open, // Order is open in the order book PartiallyFilled, // Order is partially filled Filled, // Order is completely filled Cancelled, // Order has been cancelled Rejected, // Order was rejected Expired, // Order has expired } ``` ### Constructors Create a new limit order ```rust theme={null} let order = Order::new_limit( OrderId::new(1), 100, // instrument_id Side::Buy, Price::from_raw(50000), Quantity::new(10), TimeInForce::GTC, ); ``` Create a new market order ```rust theme={null} let order = Order::new_market( OrderId::new(2), 100, Side::Sell, Quantity::new(5), ); ``` ### Methods Get remaining quantity to be filled ```rust theme={null} let remaining = order.remaining_quantity(); ``` Check if the order is completely filled Check if the order can be cancelled Get fill ratio (0.0 to 1.0) ```rust theme={null} let ratio = order.fill_ratio(); println!("Order is {}% filled", ratio * 100.0); ``` Update order with a fill ```rust theme={null} order.apply_fill( Price::from_raw(49990), Quantity::new(5), Timestamp::now(), ); ``` *** ## Quote Best Bid/Offer (BBO) representation. ### Definition ```rust theme={null} pub struct Quote { pub instrument_id: u32, pub bid_price: Price, pub bid_quantity: Quantity, pub ask_price: Price, pub ask_quantity: Quantity, pub timestamp: Timestamp, } ``` ### Methods Create a new quote Calculate the mid price ```rust theme={null} let mid = quote.mid_price(); ``` Calculate the spread in ticks ```rust theme={null} let spread = quote.spread(); ``` Check if the quote is valid (bid \< ask) *** ## Trade Trade execution information. ### Definition ```rust theme={null} pub struct Trade { pub id: u64, pub instrument_id: u32, pub price: Price, pub quantity: Quantity, pub aggressor_side: Side, pub timestamp: Timestamp, } ``` *** ## Fill Fill information for an executed order. ### Definition ```rust theme={null} pub struct Fill { pub order_id: OrderId, pub price: Price, pub quantity: Quantity, pub side: Side, pub is_maker: bool, pub timestamp: Timestamp, pub fee: f64, } ``` ### Methods Calculate the notional value of this fill ```rust theme={null} let value = fill.notional(); ``` Calculate the signed quantity (positive for buy, negative for sell) ```rust theme={null} let signed_qty = fill.signed_quantity(); ``` *** ## Level A price level in the order book. ### Definition ```rust theme={null} pub struct Level { pub price: Price, pub quantity: Quantity, pub order_count: u32, } ``` ### Methods Create a new level Create an empty level at a given price Check if the level is empty