Prices as integer ticks

Every exchange-traded instrument has a minimum price increment, its tick size: 0.25 index points for an equity index future, a cent or less for many shares, 1/64 or 1/128 of a point for some bond futures. Every valid price is a whole number of ticks. So store the price as that whole number, in a 64-bit integer:

using Ticks = std::int64_t;          // or a strong type, below

struct InstrumentSpec {
    std::int64_t tick_num, tick_den; // tick size as a fraction, e.g. 1/4 for 0.25
    std::int64_t multiplier;         // contract value per point
};

Ticks to_ticks(std::int64_t px_scaled, std::int64_t scale, const InstrumentSpec& s);  // at the edge

• Exact. 17285 ticks is exactly 4321.25; there is no rounding in storing or adding.
• Exact comparison. Equality and ordering are exact, so prices can be hash keys and array indices, and a computed price matches the book's level exactly.
• Fast. Integer arithmetic and comparison are single instructions, and tick offsets index arrays directly (Module 9).
• Matches the exchange. Exchange protocols send prices as scaled integers, so the conversion is often a multiplication or nothing at all.

An alternative seen in many codebases is a fixed number of implied decimal places for all instruments, for example prices stored as integers times 10⁹. It is also exact, simpler across instruments, and requires checking that every tick size divides evenly at that scale.

Only at the edges:

• In: from the exchange's scaled integer or decimal text into ticks, once, in the feed handler or the order decoder. Check that the price really is on a tick, and reject or flag it if not.
• Out: from ticks to the exchange's wire format when encoding an order.
• For people: to a decimal string for logs and screens, off the hot path.

A strategy that computes a fair value as a double must round it to a tick explicitly, and the rounding direction is a trading decision: a buy price rounds down to stay at or below the value, a sell price rounds up.

Ticks buy_price(double fair, double tick) { return static_cast<Ticks>(std::floor(fair / tick)); }
Ticks sell_price(double fair, double tick) { return static_cast<Ticks>(std::ceil(fair / tick)); }

(For values exactly on a tick, fair / tick may come out as 17284.999999999998; adding a small epsilon in the right direction, or computing fair values in ticks from the start, avoids an off-by-one tick.)

Overflow. Notional value is price times quantity times multiplier. In ticks, with 64-bit integers that is usually ample, but it is easy to compute it in 32 bits by accident, or to scale prices by 10⁹ and multiply by a large quantity and overflow 2⁶³. Size the intermediate type for the product, use 128-bit intermediates (__int128) where needed, and test with extreme values.

Mixing units. A price in ticks of one instrument added to a price in ticks of another, or compared with a price in implied decimals, is a silent bug. A strong type that carries its meaning prevents it at compile time:

struct Price { std::int64_t ticks; };
constexpr bool operator<(Price a, Price b) { return a.ticks < b.ticks; }
constexpr Price operator+(Price a, std::int64_t n) { return {a.ticks + n}; }   // move by n ticks
// no implicit conversion to or from double, no Price + Price

Division. Averages and ratios leave the integers. An average fill price is a total of price times quantity divided by total quantity; keep numerator and denominator as integers as long as possible, and convert to a double deliberately when a real number is what you want.

Tick size changes. Some venues have tick sizes that depend on the price level (tick-size regimes in European equities, for example) or that change by instrument over time. The specification must come from reference data per instrument, not a constant.

Negative prices. Spreads, some energy futures, and calendar spreads can trade at negative prices. A signed type handles it; code that assumes a price is positive does not.

Integers counting ticks, 64-bit, with the tick size and multiplier per instrument from reference data, converted once at the edges and wrapped in a strong type so units cannot be mixed. Everything internal is exact and fast. The pitfalls are overflow in notional calculations, division for averages, rounding computed fair values to a tick in the right direction, and instruments with variable tick sizes or negative prices.