diff --git a/di/simtick/README.md b/di/simtick/README.md new file mode 100644 index 00000000..142589ab --- /dev/null +++ b/di/simtick/README.md @@ -0,0 +1,235 @@ +# di.simtick + +Realistic intraday tick data simulator for KDB-X with configurable market microstructure. + +For a detailed explanation of the mathematical foundations, see the [Technical Paper](docs/IntradayTickSimulatorPaper.pdf). + +## About + +Realistic synthetic tick data is valuable for many quantitative finance workflows. This module generates trade and quote data that captures key statistical properties of real markets. + +The module is designed for **progressive complexity**: configure from simple to sophisticated scenarios by adjusting parameters: + +- **Baseline**: Set `alpha:0` and equal multipliers for basic Poisson arrivals with GBM prices +- **Add seasonality**: Vary `openmult`, `midmult`, `closemult` for U-shape or J-shape intraday patterns +- **Add clustering**: Increase `alpha` to enable Hawkes self-excitation for realistic trade bursts +- **Add jumps**: Switch to `pricemodel:jump` for discontinuous price moves +- **Add quotes**: Set `generatequotes:1b` for bid-ask spread dynamics + +This flexibility allows the same module to serve quick prototypes and sophisticated stress-testing scenarios. + +### Key Features + +- **Trade clustering** — real trades arrive in bursts, not uniformly. We use a Hawkes process to model this self-exciting behavior. +- **Intraday seasonality** — trading activity is high at open and close, low at midday. Configurable U-shape or J-shape patterns. +- **Price dynamics** — GBM with optional jump-diffusion captures continuous price movement and occasional discontinuities. +- **Microstructure** — bid-ask spreads that widen at open/close, quote updates between trades. + +### Use Cases + +**Stress testing and scenario analysis** — Generate data under severe but plausible conditions. Simulate liquidity shocks by lowering `baseintensity`, gap moves using the jump-diffusion model (`pricemodel:jump`), or extreme volatility regimes by increasing `vol`. Test how your systems behave when markets break from normal patterns. + +**Sensitivity and robustness testing** — Vary parameters systematically to understand how strategies respond to changes in volatility, trade frequency, or spread dynamics. Identify breaking points before they occur in production. + +**System development** — Stress-test data ingestion pipelines by adjusting trade arrival rates. Increase `baseintensity` (e.g., from 0.5 to 50) and `alpha` to simulate high-frequency bursts. This lets you verify that your database, message queues, and processing logic handle peak loads without data loss or latency spikes. + +**Real-time demos** — Feed simulated data to dashboards, visualization tools, or trading interfaces. Useful for demos, training sessions, or testing UI responsiveness without connecting to live markets. + +### Limitations + +This module emphasizes **trade generation** and derives quotes in a simplified manner. Quotes are constructed *after* trades to ensure consistency with executed prices. This approach is computationally efficient but inverts the true market causality where quotes exist first and trades result from order matching. + +**Not suitable for:** + +- **Advanced Market-making research** — no order book queue dynamics, no queue position modeling +- **Execution optimization** — no realistic fill probability or market impact simulation +- **HFT strategy development** — quote generation is not causally realistic + +For these advanced use cases, a full limit order book simulator with queue dynamics would be preferred. + +### Next Steps + +A future module will extend this simulator to support **multi-instrument generation with correlation**. Using KDB-X module hierarchy, a new `di.simmulti` module will build on `di.simtick` as the single-instrument foundation, adding: + +- Correlated processes +- Configurable correlation matrices +- Synchronized or independent arrival processes + +Correlated price paths across assets are essential for: + +- **Portfolio risk management** — stress testing diversified portfolios under correlated drawdowns +- **Value at Risk (VaR) and Expected Shortfall (ES)** — generating scenarios for tail risk estimation +- **Cross-asset strategy testing** — pairs trading, statistical arbitrage, index replication + + +### Configuration + +Simulations are driven by a configuration dictionary containing all model parameters (arrival rates, volatility, spread settings, etc.). Rather than building these manually, the module reads configurations from a **CSV file**. + +A ready-to-use file `presets.csv` is included with five market scenarios (default, liquid, illiquid, volatile, jumpy). You can: + +- Use presets directly: `cfg:cfgs`default` +- Modify values for specific runs: `cfg[`vol]:0.4` +- Add new rows to define custom scenarios +- Create your own CSV following the same schema + +To see all available parameters and their descriptions: +```q +q)simtick.describe[] +``` + + +## Overview + +A KDB-X module for simulating realistic intraday trade and quote data. Features: + +- **Hawkes process** for trade arrivals (self-exciting, captures trade clustering) +- **GBM / Jump-diffusion** for price dynamics +- **Configurable intraday patterns** (U-shape or J-shape intensity) +- **Quote generation** with realistic bid-ask spreads +- **CSV-based presets** for different market scenarios + +## Installation + +1. Add this repository to your `QPATH`: +```bash +export QPATH=$QPATH:/path/to/kdbx-modules +``` + +2. Load the module: +```q +q)simtick:use`di.simtick +``` + +## Usage + +### Basic usage +```q +q)simtick:use`di.simtick +q)cfgs:simtick.loadconfig`:di/simtick/presets.csv +q)cfg:cfgs`default +q)simtick.run[cfg] +time price qty +------------------------------------------ +2026.01.20D09:30:02.487640474 100 43 +2026.01.20D09:30:03.846514899 100.0011 32 +2026.01.20D09:30:04.444929571 100.0122 78 +... +``` + +### With quote generation +```q +q)cfg[`generatequotes]:1b +q)result:simtick.run[cfg] +q)result`trade +q)result`quote +``` + +## API + +| Function | Description | +|----------|-------------| +| `simtick.run[cfg]` | Full simulation - returns trades (or dict with quotes) | +| `simtick.arrivals[cfg]` | Generate arrival times only (seconds from open) | +| `simtick.price[cfg;times]` | Generate prices for given times | +| `simtick.loadconfig[filepath]` | Load presets from CSV | +| `simtick.describe[]` | Return configuration schema as table | + +## Presets + +| Preset | Description | +|--------|-------------| +| `default` | Standard trading day | +| `liquid` | High volume, tighter spreads | +| `illiquid` | Low volume | +| `volatile` | Higher price volatility | +| `jumpy` | Jump-diffusion price model | + +## Configuration Parameters + +| Parameter | Description | Example | +|-----------|-------------|---------| +| `baseintensity` | Base arrival rate (trades/sec) | 0.5 | +| `alpha` | Hawkes excitation (0 = Poisson) | 0.3 | +| `beta` | Hawkes decay (must be > alpha) | 1.0 | +| `vol` | Annualized volatility | 0.2 | +| `drift` | Annualized drift | 0.05 | +| `transitionpoint` | Intraday shape (0.3=J, 0.5=U) | 0.3 | +| `pricemodel` | `gbm` or `jump` | `gbm` | +| `qtymodel` | `lognormal` or `constant` | `lognormal` | +| `avgqty` | Average trade size | 100 | +| `basespread` | Base bid-ask spread (fraction) | 0.001 | +| `generatequotes` | Generate quotes flag | 0b | +| `openmult` | Opening intensity multiplier | 1.5 | +| `midmult` | Midday intensity multiplier | 0.5 | +| `closemult` | Closing intensity multiplier | 3.0 | + +## Testing + +```q +q)k4unit:use`di.k4unit +q)k4unit.moduletest`di.simtick +``` + +### Test Coverage + +| Group | Tests | Description | +|-------|-------|-------------| +| Validation | 3 | Bad configs throw correct errors (alpha >= beta, negative intensity, zero multipliers) | +| Arrivals | 5 | Output properties: non-empty, sorted, positive, within duration, correct type | +| Shape | 3 | Intraday pattern: open > mid, close > mid, J-shape verification | +| Price | 6 | Positive prices, startprice correct, realized vol within tolerance, jump model works | +| Trades | 8 | Correct schema, sorted times, positive prices/qty, integer qty, within session | +| Quotes | 8 | Correct schema, sorted times, bid < ask, positive sizes, quote before first trade | +| Config | 7 | Keyed table, correct column count, correct types (float, symbol, date) | +| Describe | 3 | Returns table, correct columns, correct parameter count | +| Constant Qty | 2 | All quantities equal, quantity equals avgqty | +| Reproducibility | 1 | Same seed produces same output | +| **Total** | **46** | | + +## Documentation + +The `docs/` folder contains: + +- **[IntradayTickSimulatorPaper.pdf](docs/IntradayTickSimulatorPaper.pdf)** — Technical paper detailing the mathematical foundations of this module (Hawkes process, GBM, jump-diffusion, quote generation) +- **[HawkesProcessesInFinance.pdf](docs/HawkesProcessesInFinance.pdf)** — Reference paper on Hawkes processes in finance (Bacry et al., 2015) + +## Notebooks + +An interactive **[example](notebooks/simtickDemo.ipynb)** using PyKX is available in `notebooks/`. + +### Setup + +```bash +cd di/simtick +python -m venv .venv +source .venv/bin/activate # Linux/Mac +pip install -r requirements.txt +jupyter lab +``` + +### Available Notebooks + +| Notebook | Description | +|----------|-------------| +| `simtickDemo.ipynb` | Load module, run simulation, visualize price and quantity | + +## Project Structure + +``` +di/simtick/ +├── init.q # Module code +├── presets.csv # Market scenario presets +├── test.csv # Unit tests (k4unit format) +├── README.md # This file +├── requirements.txt # Python dependencies +├── docs/ +│ ├── IntradayTickSimulatorPaper.pdf +│ └── HawkesProcessesInFinance.pdf +└── notebooks/ + └── simtickDemo.ipynb +``` + +## License + +MIT diff --git a/di/simtick/docs/HawkesProcessesInFinance.pdf b/di/simtick/docs/HawkesProcessesInFinance.pdf new file mode 100644 index 00000000..37edd4c9 Binary files /dev/null and b/di/simtick/docs/HawkesProcessesInFinance.pdf differ diff --git a/di/simtick/docs/IntradayTickSimulatorPaper.pdf b/di/simtick/docs/IntradayTickSimulatorPaper.pdf new file mode 100644 index 00000000..3dc6b152 Binary files /dev/null and b/di/simtick/docs/IntradayTickSimulatorPaper.pdf differ diff --git a/di/simtick/init.q b/di/simtick/init.q new file mode 100644 index 00000000..f8d62ed5 --- /dev/null +++ b/di/simtick/init.q @@ -0,0 +1,543 @@ +/ di.simtick - realistic intraday tick simulator + +/ Hawkes process: safety multiplier for lambda upper bound +/ ensures thinning algorithm acceptance rate stays reasonable +/ higher values = more conservative bound = slower but safer +excitebuffer:3 + +/ quote generation: maximum intermediate quote updates between trades +/ caps computation cost for large time gaps +maxquoteupdates:10 + +/ quote generation: random jitter range for initial quote offset (milliseconds) +/ adds realism by varying the pre-trade quote timing +initquotejitterms:100 + +/ price movement: fractional tick size for intermediate quote mid-price drift +/ controls how much the mid moves between trades (as fraction of price) +quoteticksize:0.0001 + +/ time unit conversions +nsperms:1000000 +nspersec:1000000000 + + +val.haskeys:{[cfg;reqkeys;fn] + / check config dictionary has all required keys + / cfg: configuration dictionary + / reqkeys: symbol list of required keys + / fn: function name string for error context + if[count missing:reqkeys where not reqkeys in key cfg; + '"(",fn,"): missing config keys - ",", " sv string missing]; + }; + +val.nonempty:{[x;name;fn] + / check list is non-empty + / x: list to check + / name: parameter name for error message + / fn: function name string for error context + if[not count x; '"(",fn,"): ",name," cannot be empty"]; + }; + +val.hascols:{[t;reqcols;fn] + / check table has required columns + / t: table to check + / reqcols: symbol list of required columns + / fn: function name string for error context + if[not all reqcols in cols t; + '"(",fn,"): table missing columns - ",", " sv string reqcols where not reqcols in cols t]; + }; + + +rng.boxmuller:{[n] + / Box-Muller transform for n standard normal random variates + / n: number of samples required + / returns: list of n standard normal floats + m:2*(n+1) div 2; / ensure even count + u:m?1.0; + u:2 0N#u; + r:sqrt -2f*log u 0; + theta:2f*acos[-1]*u 1; + n#(r*cos theta),r*sin theta + }; + +rng.normal:{[n;cfg] + / generate n standard normal random samples + / n: number of samples required + / cfg: config dict containing `rngmodel + / returns: list of n standard normal floats + model:cfg`rngmodel; + $[model=`pseudo; .z.m.rng.boxmuller[n]; + '"rng.normal: unknown rngmodel - ",string model] + }; + + +shape:{[cfg;progress] + / intraday intensity multiplier using cosine interpolation + / cfg: config dict with `openmult`midmult`closemult`transitionpoint + / progress: fraction of trading day elapsed (0 to 1) + / returns: intensity multiplier for current time + / + / transitionpoint controls when to switch from open->mid to mid->close + / 0.5 = symmetric (U-shape), 0.3 = asymmetric (J-shape) + openmult:cfg`openmult; + midmult:cfg`midmult; + closemult:cfg`closemult; + tp:cfg`transitionpoint; + $[progress=duration; :state,enlist[`done]!enlist 1b]; + + / decay excitation + excitation:state[`excitation]*exp neg beta*wait; + + / current intensity + progress:t%duration; + lambda0:baseintensity*.z.m.shape[cfg;progress]; + lambda:lambda0+excitation; + + / accept/reject + accept:(first 1?1.0)=close; '"arrivals: openingtime must be before closingtime"]; + duration:`long$(close-open)%nspersec; + + / upper bound for intensity (for thinning) + maxmult:cfg[`openmult]|cfg[`midmult]|cfg`closemult; + excitationbuffer:1+excitebuffer*alpha%beta; + lambdamax:baseintensity*maxmult*excitationbuffer; + + / params for step function + params:`duration`lambdamax`baseintensity`alpha`beta`cfg!( + duration;lambdamax;baseintensity;alpha;beta;cfg); + + / initial state + init:`t`excitation`times`done!(0f;0f;`float$();0b); + + / run until done + final:.z.m.hawkes.step[params]/[{not x`done};init]; + + final`times + }; + +gbm:{[s;r;eps;t] + / GBM single-step return factor + / s: annualized volatility (sigma) + / r: annualized drift (mu) + / eps: standard normal random variate + / t: time step in years + / returns: multiplicative return factor exp((r - 0.5*s^2)*t + s*sqrt(t)*eps) + exp (t*r-.5*s*s)+eps*s*sqrt t + }; + +pricegbm:{[cfg;dts] + / generate price path using geometric Brownian motion + / cfg: config dict with `startprice`vol`drift`rngmodel + / dts: list of time deltas in years (first element is time to first trade) + / returns: list of prices corresponding to each time point + eps:.z.m.rng.normal[-1+count dts;cfg]; + cfg[`startprice]*prds 1.0,.z.m.gbm[cfg`vol;cfg`drift;eps;1_ dts] + }; + +pricejump:{[cfg;dts] + / generate price path using Merton jump-diffusion model + / dS/S = μdt + σdW + J·dN where J is lognormal, N is Poisson + / cfg: config dict with `startprice`vol`drift`tradingdays`jumpintensity`jumpmean`jumpvol`rngmodel + / dts: list of time deltas in years + / returns: list of prices corresponding to each time point + n:-1+count dts; + stepdts:1_ dts; + + / diffusion component + eps:.z.m.rng.normal[n;cfg]; + diffusion:.z.m.gbm[cfg`vol;cfg`drift;eps;stepdts]; + + / jump component: Poisson arrivals with lognormal sizes + dtdays:stepdts*cfg`tradingdays; + hasjump:(n?1.0)<1-exp neg cfg[`jumpintensity]*dtdays; + epsj:.z.m.rng.normal[n;cfg]; + jumps:exp hasjump*(cfg[`jumpmean]+cfg[`jumpvol]*epsj); + + cfg[`startprice]*prds 1.0,diffusion*jumps + }; + +price:{[cfg;times] + / generate prices for given arrival times + / cfg: configuration dictionary + / times: list of arrival times in seconds from session start + / returns: list of prices corresponding to each arrival time + / + / Required config keys: + / openingtime, closingtime, tradingdays, pricemodel, startprice, vol, drift + / For jump model: jumpintensity, jumpmean, jumpvol + + / validate inputs + .z.m.val.nonempty[times;"times";"price"]; + if[any times<0; '"price: times must be non-negative"]; + + reqkeys:`openingtime`closingtime`tradingdays`pricemodel`startprice`vol`drift; + .z.m.val.haskeys[cfg;reqkeys;"price"]; + + / convert times to dt in years + open:`timespan$cfg`openingtime; + close:`timespan$cfg`closingtime; + secsperyear:cfg[`tradingdays]*`long$(close-open)%nspersec; + dts:deltas[times]%secsperyear; + + $[cfg[`pricemodel]=`jump; .z.m.pricejump[cfg;dts]; .z.m.pricegbm[cfg;dts]] + }; + +qty.constant:{[n;cfg] + / generate constant quantities + / n: number of quantities + / cfg: config dict with `qty + / returns: list of n identical quantities + n#cfg`avgqty + }; + +qty.lognormal:{[n;cfg] + / generate lognormal random quantities + / n: number of quantities + / cfg: config dict with `avgqty`qtyvol`rngmodel + / returns: list of n integer quantities (minimum 1) + avgqty:cfg`avgqty; + qtyvol:cfg`qtyvol; + mu:log[avgqty]-0.5*qtyvol*qtyvol; + eps:.z.m.rng.normal[n;cfg]; + `long$1|floor exp mu+qtyvol*eps + }; + +qty.gen:{[n;cfg] + / dispatch to appropriate quantity generator + / n: number of quantities + / cfg: config dict with `qtymodel and model-specific params + / returns: list of n quantities + model:cfg`qtymodel; + $[model=`constant; .z.m.qty.constant[n;cfg]; + model=`lognormal; .z.m.qty.lognormal[n;cfg]; + '"qty.gen: unknown qtymodel - ",string model] + }; + +quote.generate:{[cfg;trades] + / generate quote updates for trades (fully vectorized) + / cfg: configuration dictionary + / trades: trade table with `time`price columns + / returns: quote table with `time`bid`ask`bidsize`asksize + + / validate inputs + .z.m.val.hascols[trades;`time`price;"quote.generate"]; + + n:count trades; + if[n=0; :([]time:`timestamp$();bid:`float$();ask:`float$();bidsize:`long$();asksize:`long$())]; + + tradetimes:trades`time; + tradeprices:trades`price; + + / parameters + basespread:cfg`basespread; + pretradeoffset:cfg`pretradeoffset; + quoteupdaterate:cfg`quoteupdaterate; + avgquotesize:cfg`avgquotesize; + + / === 1. initial quote (before first trade) === + initoffset:`timespan$`long$nsperms*pretradeoffset+first 1?initquotejitterms; + inittime:tradetimes[0]-initoffset; + initprice:tradeprices[0]; + initspread:basespread*initprice*cfg`spreadopenmult; + + / === 2. pre-trade quotes (one per trade, vectorized) === + / times: random offset before each trade + randoffsets:n?pretradeoffset; + pretimes:tradetimes-`timespan$`long$(pretradeoffset+randoffsets)*nsperms; + + / spreads based on time of day (vectorized) + prespreadmults:.z.m.quote.spreadmults[cfg;tradetimes]; + prespreads:basespread*tradeprices*prespreadmults; + prebids:tradeprices-prespreads%2; + preasks:tradeprices+prespreads%2; + + / sizes (vectorized) + prebidsizes:avgquotesize+`long$100*.z.m.rng.boxmuller[n]; + preasksizes:avgquotesize+`long$100*.z.m.rng.boxmuller[n]; + + / === 3. intermediate quotes (vectorized) === + / only if we have at least 2 trades + intresult:$[n>1; + .z.m.quote.intermediates[cfg;tradetimes;tradeprices;basespread;pretradeoffset;quoteupdaterate;avgquotesize]; + `times`bids`asks`bidsizes`asksizes!5#enlist`float$() + ]; + + / === 4. combine all quotes === + alltimes:(enlist inittime),intresult[`times],pretimes; + allbids:(enlist initprice-initspread%2),intresult[`bids],prebids; + allasks:(enlist initprice+initspread%2),intresult[`asks],preasks; + allbidsizes:(enlist avgquotesize),intresult[`bidsizes],prebidsizes; + allasksizes:(enlist avgquotesize),intresult[`asksizes],preasksizes; + + / build table, enforce minimum size of 1, sort by time + quotes:([]time:alltimes;bid:allbids;ask:allasks;bidsize:allbidsizes;asksize:allasksizes); + quotes:update bidsize:1|bidsize,asksize:1|asksize from quotes; + `time xasc quotes + }; + +quote.intermediates:{[cfg;tradetimes;tradeprices;basespread;pretradeoffset;quoteupdaterate;avgquotesize] + / generate all intermediate quotes across all gaps (fully vectorized) + / returns dict with `times`bids`asks`bidsizes`asksizes + n:count tradetimes; + empty:`times`bids`asks`bidsizes`asksizes!5#enlist`float$(); + + / gap times in ms between consecutive trades + prevtimes:tradetimes til n-1; + nexttimes:tradetimes 1+til n-1; + prevprices:tradeprices til n-1; + nextprices:tradeprices 1+til n-1; + gaps:`long$(nexttimes-prevtimes)%nsperms; + + / number of intermediate quotes per gap (capped) + nupdates:maxquoteupdates&`long$floor quoteupdaterate*gaps%1000; + + / filter gaps that are too short (need room for quotes before pretradeoffset) + mingap:2*pretradeoffset; + nupdates:nupdates*gaps>mingap; + + totint:sum nupdates; + if[totint=0; :empty]; + + / expand gap indices: create nupdates[i] copies of index i for each gap + / e.g., if nupdates=(0 2 0 3), gapidx=(1 1 3 3 3) + gapidx:raze {x#y}'[nupdates; til count nupdates]; + + / position within each gap (0, 1, 2, ... for each gap) + / e.g., if nupdates=(0 2 0 3), positions=(0 1 0 1 2) + positions:raze til each nupdates; + + / gap-specific values expanded to each intermediate quote + gapnupdates:nupdates gapidx; + gapprevtimes:prevtimes gapidx; + gapnexttimes:nexttimes gapidx; + gapprevprices:prevprices gapidx; + gapnextprices:nextprices gapidx; + + / times: evenly spaced within [prevtime, nexttime - pretradeoffset] + availdurations:gapnexttimes-gapprevtimes-`timespan$`long$pretradeoffset*nsperms; + fractions:(1+positions)%1+gapnupdates; + inttimes:gapprevtimes+`timespan$`long$fractions*`long$availdurations; + + / prices: interpolate from prev toward next trade price, plus noise + midprices:gapprevprices+fractions*(gapnextprices-gapprevprices); + noise:quoteticksize*midprices*.z.m.rng.boxmuller[totint]; + midprices+:noise; + + / spreads (vectorized across all intermediate quotes) + intspreadmults:.z.m.quote.spreadmults[cfg;inttimes]; + spreadvar:1+0.1*abs .z.m.rng.boxmuller[totint]; + intspreads:basespread*midprices*intspreadmults*spreadvar; + intbids:midprices-intspreads%2; + intasks:midprices+intspreads%2; + + / sizes + intbidsizes:avgquotesize+`long$100*.z.m.rng.boxmuller[totint]; + intasksizes:avgquotesize+`long$100*.z.m.rng.boxmuller[totint]; + + `times`bids`asks`bidsizes`asksizes!(inttimes;intbids;intasks;intbidsizes;intasksizes) + }; + +quote.spreadmults:{[cfg;times] + / spread multiplier based on time of day (vectorized) + / cfg: config dict with spread parameters + / times: list of timestamps + / returns: list of spread multipliers (wider at open/close, tighter at midday) + opentime:`timespan$cfg`openingtime; + closetime:`timespan$cfg`closingtime; + duration:closetime-opentime; + + / time of day as timespan + timeofday:times-`timestamp$`date$times; + + / progress through trading day (0 to 1) + progress:(timeofday-opentime)%duration; + progress:0f|progress&1f; + + / vectorized conditional: early part vs late part of day + earlyvals:cfg[`spreadopenmult]+(cfg[`spreadmidmult]-cfg`spreadopenmult)*2*progress; + latevals:cfg[`spreadmidmult]+(cfg[`spreadclosemult]-cfg`spreadmidmult)*2*progress-0.5; + early:progress<0.5; + (early*earlyvals)+(not early)*latevals + }; + +validate:{[cfg] + / validate configuration dictionary for run + / cfg: configuration dictionary + / returns: cfg if valid, throws error otherwise + / + / Checks: + / - Hawkes stability: alpha < beta + / - Positive multipliers: openmult, midmult, closemult > 0 + / - Positive base intensity + / - Transitionpoint in valid range (prevents division by zero) + + / check Hawkes stability condition + if[cfg[`alpha]>=cfg`beta; '"validate: Hawkes unstable - alpha must be < beta"]; + / check multipliers positive + if[0>=min cfg`openmult`midmult`closemult; '"validate: multipliers must be positive"]; + / check base intensity + if[0>=cfg`baseintensity; '"validate: baseintensity must be positive"]; + / check transitionpoint bounds (prevents division by zero in shape function) + if[not cfg[`transitionpoint] within 0.01 0.99; + '"validate: transitionpoint must be between 0.01 and 0.99"]; + cfg + }; + + +run:{[cfg] + / main simulation entry point + / cfg: configuration dictionary (typically loaded via loadconfig) + / returns: trade table if generatequotes=0b, else dict with `trade`quote + / + / Example: + / cfg:first loadconfig`:presets.csv + / trades:run[cfg] + / cfg[`generatequotes]:1b + / result:run[cfg] / result`trade, result`quote + cfg:.z.m.validate[cfg]; + + / set seed for reproducibility + if[cfg[`seed]>0; system "S ",string cfg`seed]; + + / generate arrival times (seconds from open) + arrs:.z.m.arrivals[cfg]; + n:count arrs; + + if[n=0; + trades:([]time:`timestamp$();price:`float$();qty:`long$()); + :$[cfg`generatequotes; + `trade`quote!(trades;([]time:`timestamp$();bid:`float$();ask:`float$();bidsize:`long$();asksize:`long$())); + trades] + ]; + + / convert to timestamps + basetime:cfg[`tradingdate]+`timespan$cfg`openingtime; + times:basetime+`timespan$`long$arrs*nspersec; + + / generate prices + prices:.z.m.price[cfg;arrs]; + + / generate quantities + qtys:.z.m.qty.gen[n;cfg]; + + trades:([]time:times;price:prices;qty:qtys); + + / return trades only or dictionary with quotes + $[cfg`generatequotes; + `trade`quote!(trades;.z.m.quote.generate[cfg;trades]); + trades] + }; + +/ configuration schema: column name -> (type; description) +/ type codes: S=symbol, D=date, U=minute, F=float, J=long, B=boolean +schema:()!() +schema[`name]:("S";"preset name (key)") +schema[`tradingdate]:("D";"simulation date") +schema[`openingtime]:("U";"market open time") +schema[`closingtime]:("U";"market close time") +schema[`startprice]:("F";"initial price") +schema[`seed]:("J";"random seed (0 = no seed)") +schema[`rngmodel]:("S";"RNG model (`pseudo)") +schema[`drift]:("F";"annualized drift") +schema[`vol]:("F";"annualized volatility") +schema[`tradingdays]:("J";"trading days per year") +schema[`pricemodel]:("S";"price model (`gbm or `jump)") +schema[`jumpintensity]:("F";"jump arrival rate (jumps/day)") +schema[`jumpmean]:("F";"log jump mean") +schema[`jumpvol]:("F";"log jump volatility") +schema[`baseintensity]:("F";"base trade arrival rate (trades/sec)") +schema[`alpha]:("F";"Hawkes excitation parameter") +schema[`beta]:("F";"Hawkes decay parameter (must be > alpha)") +schema[`transitionpoint]:("F";"intraday shape parameter (0.3=J, 0.5=U)") +schema[`openmult]:("F";"intensity multiplier at open") +schema[`midmult]:("F";"intensity multiplier at midday") +schema[`closemult]:("F";"intensity multiplier at close") +schema[`qtymodel]:("S";"quantity model (`constant or `lognormal)") +schema[`avgqty]:("J";"average trade quantity") +schema[`qtyvol]:("F";"quantity volatility (for lognormal)") +schema[`generatequotes]:("B";"generate quotes flag") +schema[`basespread]:("F";"base bid-ask spread (fraction of price)") +schema[`spreadopenmult]:("F";"spread multiplier at open") +schema[`spreadmidmult]:("F";"spread multiplier at midday") +schema[`spreadclosemult]:("F";"spread multiplier at close") +schema[`pretradeoffset]:("J";"min ms before trade for quote") +schema[`quoteupdaterate]:("F";"quote updates per second") +schema[`avgquotesize]:("J";"average quote size") + +/ derive type string from schema +csvtypes:raze first each value schema + +loadconfig:{[filepath] + / load preset configurations from CSV file + / filepath: file handle to CSV (e.g., `:presets.csv) + / returns: keyed table with preset name as key + / + / Example: + / cfgs:loadconfig`:di/simtick/presets.csv + / cfg:cfgs`default + / run[cfg] + if[not -11h=type filepath; '"loadconfig: filepath must be a file handle"]; + 1!(.z.m.csvtypes;enlist csv) 0: filepath + }; + +describe:{[] + / return configuration schema as a table + / useful for documentation and introspection + / Example: + / simtick.describe[] + ([]param:key .z.m.schema;typ:first each value .z.m.schema;description:last each value .z.m.schema) + }; + +/ export public interface +export:([run;arrivals;price;loadconfig;describe]) diff --git a/di/simtick/notebooks/simtickDemo.ipynb b/di/simtick/notebooks/simtickDemo.ipynb new file mode 100644 index 00000000..b2a93b93 --- /dev/null +++ b/di/simtick/notebooks/simtickDemo.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "257066ec-d9f0-4274-87ca-5e4d260eb658", + "metadata": {}, + "source": [ + "# di.simtick Demo\n", + "\n", + "This notebook demonstrates the `di.simtick` module — a realistic intraday tick data simulator for KDB-X." + ] + }, + { + "cell_type": "markdown", + "id": "50b498eb-e2e1-4173-a4da-978e63f5ee9e", + "metadata": {}, + "source": [ + "## Import Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "59f2cf0b-f88f-47f8-9244-279040513e5a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module loaded successfully!\n" + ] + } + ], + "source": [ + "import os\n", + "import pykx as kx\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "# Get paths\n", + "module_path = os.path.expanduser('~/kdbx-modules')\n", + "presets_path = f\"{module_path}/di/simtick/presets.csv\"\n", + "\n", + "# Set QPATH and load module\n", + "kx.q(f'setenv[`QPATH;\"{module_path}\"]')\n", + "kx.q('simtick:use`di.simtick')\n", + "kx.q(f'cfgs:simtick.loadconfig`$\":{presets_path}\"')\n", + "\n", + "print(\"Module loaded successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cc3c8523-a2f8-4a67-8568-fad87a9afbc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
name
0default
1liquid
2illiquid
3volatile
4jumpy
\n", + "
" + ], + "text/plain": [ + " name\n", + "0 default\n", + "1 liquid\n", + "2 illiquid\n", + "3 volatile\n", + "4 jumpy" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kx.q('key cfgs').pd()" + ] + }, + { + "cell_type": "markdown", + "id": "71356987-cb0c-4c41-b058-42ca13316271", + "metadata": {}, + "source": [ + "## Select a scenario" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6bf1641a-6eb8-4231-b219-1dd39d5d347f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 30191 trades\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timepriceqty
02026-01-20 09:30:00.689317695100.00000060
12026-01-20 09:30:01.868664471100.00082479
22026-01-20 09:30:03.16424453199.99633460
32026-01-20 09:30:03.21602883999.99573481
42026-01-20 09:30:03.665811537100.009424118
\n", + "
" + ], + "text/plain": [ + " time price qty\n", + "0 2026-01-20 09:30:00.689317695 100.000000 60\n", + "1 2026-01-20 09:30:01.868664471 100.000824 79\n", + "2 2026-01-20 09:30:03.164244531 99.996334 60\n", + "3 2026-01-20 09:30:03.216028839 99.995734 81\n", + "4 2026-01-20 09:30:03.665811537 100.009424 118" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scenario = 'default' # Change to: 'liquid', 'illiquid', 'volatile', 'jumpy'\n", + "\n", + "result = kx.q(f'simtick.run[cfgs`{scenario}]')\n", + "trades = result.pd()\n", + "\n", + "print(f\"Generated {len(trades)} trades\")\n", + "trades.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e1b5e47c-a135-4bdd-86a2-2ed163799c12", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Cell: Plot price and quantity\n", + "fig, ax1 = plt.subplots(figsize=(12, 5))\n", + "\n", + "# Price on left axis\n", + "ax1.plot(trades['time'], trades['price'], 'b-', linewidth=0.5, label='Price')\n", + "ax1.set_xlabel('Time')\n", + "ax1.set_ylabel('Price', color='blue')\n", + "ax1.tick_params(axis='y', labelcolor='blue')\n", + "\n", + "# Quantity on right axis\n", + "ax2 = ax1.twinx()\n", + "ax2.bar(trades['time'], trades['qty'], width=0.0001, alpha=0.3, color='orange', label='Quantity')\n", + "ax2.set_ylabel('Quantity', color='orange')\n", + "ax2.tick_params(axis='y', labelcolor='orange')\n", + "\n", + "plt.title(f'Simulated Trades - {scenario}')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0c2675a-f174-49d3-bbc0-daab09d6fb8c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/di/simtick/presets.csv b/di/simtick/presets.csv new file mode 100644 index 00000000..ad2bc28c --- /dev/null +++ b/di/simtick/presets.csv @@ -0,0 +1,6 @@ +name,tradingdate,openingtime,closingtime,startprice,seed,rngmodel,drift,vol,tradingdays,pricemodel,jumpintensity,jumpmean,jumpvol,baseintensity,alpha,beta,transitionpoint,openmult,midmult,closemult,qtymodel,avgqty,qtyvol,generatequotes,basespread,spreadopenmult,spreadmidmult,spreadclosemult,pretradeoffset,quoteupdaterate,avgquotesize +default,2026.01.20,09:30,16:00,100.0,0,pseudo,0.05,0.2,252,gbm,0.0,-0.01,0.03,0.5,0.3,1.0,0.3,1.5,0.5,3.0,lognormal,100,0.8,0,0.001,1.5,1.0,2.0,50,2.0,500 +liquid,2026.01.20,09:30,16:00,100.0,0,pseudo,0.05,0.2,252,gbm,0.0,-0.01,0.03,2.0,0.5,1.0,0.3,1.5,0.5,3.0,lognormal,200,0.8,0,0.001,1.5,1.0,2.0,50,2.0,500 +illiquid,2026.01.20,09:30,16:00,100.0,0,pseudo,0.05,0.2,252,gbm,0.0,-0.01,0.03,0.1,0.2,1.0,0.3,1.5,0.5,3.0,lognormal,50,0.8,0,0.001,1.5,1.0,2.0,50,2.0,500 +volatile,2026.01.20,09:30,16:00,100.0,0,pseudo,0.05,0.4,252,gbm,0.0,-0.01,0.03,0.5,0.6,1.5,0.3,1.5,0.5,3.0,lognormal,100,0.8,0,0.001,1.5,1.0,2.0,50,2.0,500 +jumpy,2026.01.20,09:30,16:00,100.0,0,pseudo,0.05,0.2,252,jump,2.0,-0.005,0.02,0.5,0.3,1.0,0.3,1.5,0.5,3.0,lognormal,100,0.8,0,0.001,1.5,1.0,2.0,50,2.0,500 diff --git a/di/simtick/requirements.txt b/di/simtick/requirements.txt new file mode 100644 index 00000000..893eae72 --- /dev/null +++ b/di/simtick/requirements.txt @@ -0,0 +1,5 @@ +pykx==4.0.0b4 +jupyterlab +matplotlib +pandas +ipywidgets diff --git a/di/simtick/test.csv b/di/simtick/test.csv new file mode 100644 index 00000000..70addaf2 --- /dev/null +++ b/di/simtick/test.csv @@ -0,0 +1,103 @@ +action,ms,bytes,lang,code,repeat,comment +before,0,0,q,simtick:use`di.simtick,1,,Initialize module +before,0,0,q,cfgs:simtick.loadconfig`:di/simtick/presets.csv,1,,Load presets +before,0,0,q,cfg:cfgs`default,1,,Get default config +before,0,0,q,duration:23400,1,,Session duration in seconds (6.5 hours) +comment,0,0,q,,1,,=== Validation Tests === +before,0,0,q,badcfg1:cfg,1,,Setup bad config for alpha >= beta +before,0,0,q,badcfg1[`alpha]:2.0,1,,Set alpha > beta +fail,0,0,q,simtick.run[badcfg1],1,,alpha >= beta throws error +before,0,0,q,badcfg2:cfg,1,,Setup bad config for negative baseintensity +before,0,0,q,badcfg2[`baseintensity]:-1.0,1,,Set negative baseintensity +fail,0,0,q,simtick.run[badcfg2],1,,Negative baseintensity throws error +before,0,0,q,badcfg3:cfg,1,,Setup bad config for zero multiplier +before,0,0,q,badcfg3[`openmult]:0.0,1,,Set zero openmult +fail,0,0,q,simtick.run[badcfg3],1,,Zero multiplier throws error +comment,0,0,q,,1,,=== Arrivals Tests === +before,0,0,q,cfg[`seed]:42,1,,Set seed for reproducibility +before,0,0,q,arr:simtick.arrivals[cfg],1,,Generate arrivals +true,0,0,q,0duration-3600,1,,Count last hour arrivals +true,0,0,q,firsthour>midhour,1,,Open activity > mid activity +true,0,0,q,lasthour>midhour,1,,Close activity > mid activity +true,0,0,q,lasthour>firsthour,1,,J-shape: close > open (transitionpoint 0.3) +comment,0,0,q,,1,,=== Price Tests === +before,0,0,q,times:1+til 100,1,,Setup times +before,0,0,q,prices:simtick.price[cfg;times],1,,Generate prices +true,0,0,q,(count times)=count prices,1,,Price count matches input +true,0,0,q,all 0=opentime,1,,All trades at or after open +true,0,0,q,all trades[`time]<=closetime,1,,All trades at or before close +comment,0,0,q,,1,,=== Quotes Tests === +before,0,0,q,cfg[`generatequotes]:1b,1,,Enable quotes +before,0,0,q,result:simtick.run[cfg],1,,Generate trades and quotes +before,0,0,q,trades:result`trade,1,,Extract trades +before,0,0,q,quotes:result`quote,1,,Extract quotes +true,0,0,q,99h=type result,1,,Result with quotes is dict +true,0,0,q,`trade`quote~key result,1,,Dict has trade and quote keys +true,0,0,q,`time`bid`ask`bidsize`asksize~cols quotes,1,,Quotes has correct columns +true,0,0,q,(asc quotes`time)~quotes`time,1,,Quotes sorted by time +true,0,0,q,all quotes[`bid]