Kadang aku mikir, kenapa banyak sistem kuantitatif modern masih terjebak memperlakukan deret waktu finansial sebagai antrean baris yang harus dilalui satu per satu. Mengiterasi candle demi candle dengan loop prosedural itu bukan cuma lambat, tapi cara pandang yang cacat terhadap struktur data diskrit.

Ketika aku berhadapan dengan ratusan ribu candle untuk mengidentifikasi formasi Smart Money Concepts seperti Fair Value Gaps, Fractal Swings, dan Order Blocks, aku sadar bahwa keterlambatan eksekusi bukan salah Python. Itu salah cara kita memetakan memori ke CPU.

Dari perenungan itu, aku merancang library pyvsmc (Python Vectorized Smart Money Concepts). Tujuannya bukan sekadar bikin kode lebih ringkas, tapi menghabisi seluruh iterasi baris tunggal dari ruang memori Python dan menyerahkan seluruh kalkulasi ke aljabar array berbasis SIMD di tingkat C dan Rust.

Package ini sudah aku rilis secara terbuka di PyPI:

pip install pyvsmc

Dan seluruh arsitektur sumbernya bisa dibaca di GitHub Khaymat/pyvsmc serta direktori resmi PyPI pypi.org/project/pyvsmc.

Inti Masalah: Mengapa Loop Waktu adalah Ilusi Komputasi

Ketika kita memandang grafik harga, otak manusia melihat narasi sekuensial: bar kemarin bergerak ke bar hari ini, lalu ke bar besok. Tapi bagi hardware, narasi itu tidak ada. Yang ada hanyalah blok memori contiguous float64 di dalam RAM.

Menggunakan perulangan baris seperti for i in range(len(prices)) di interpreter CPython memaksa CPU melakukan context switching, dynamic type checking, dan pointer chasing di setiap baris data.

Jika sebuah dataset memiliki $n = 100.000$ bar, dan untuk setiap bar kita mencari apakah ada mitigasi di masa depan sepanjang sisa array, algoritma itu langsung merosot ke kompleksitas kuadratik $\mathcal{O}(n^2)$ .

$\text{Total Operasi} \approx \frac{n(n-1)}{2} \approx 5 \times 10^9 \text{ operasi}$

Bagi aku, membiarkan CPU mengeksekusi 5 miliar instruksi untuk hal yang bisa diselesaikan dalam satu pass linear adalah pemborosan logika.

Rekayasa Matematika di Balik Algoritma pyvsmc

Berikut adalah bagaimana aku mendekonstruksi konsep-konsep SMC menjadi model komputasi vektor murni di dalam pyvsmc.

1. Fair Value Gap dan Reduksi Ruang Waktu ke O(n)

Fair Value Gap (FVG) adalah diskontinuitas likuiditas pada tiga candle berurutan pada indeks $i-2, i-1, i$ :

Bullish FVG: $Low[i] > High[i-2]$ Interval ketidakseimbangan: $[High[i-2], Low[i]]$ .

Bearish FVG: $High[i] < Low[i-2]$ Interval ketidakseimbangan: $[High[i], Low[i-2]]$ .

Deteksi gap itu sendiri sangat mudah diselesaikan dengan shifted array slicing tanpa menyisakan satu loop pun:

import numpy as np

bullish_fvg = low[2:] > high[:-2]
bearish_fvg = high[2:] < low[:-2]

Tantangan matematis yang sesungguhnya ada pada pelacakan mitigasi: menentukan apakah ada candle di masa depan ( $j > i$ ) yang menembus batas zona gap tersebut.

Pendekatan naif mengharuskan kita mencari $\min(Low[i+1 : n])$ . Jika dilakukan satu per satu, kompleksitasnya meledak jadi $\mathcal{O}(n^2)$ .

Solusi yang aku terapkan adalah memanfaatkan sifat monolitik dari Reverse Cumulative Extrema:

$\text{RevCumMin}(Low)_k = \min_{j \ge k} Low[j]$

Dengan membalik array, menghitung cumulative minimum, lalu membaliknya kembali, kita memperoleh batas bawah masa depan untuk setiap indeks $i$ dalam tepat satu lintasan linear $\mathcal{O}(n)$ :

# Reverse cumulative minimum dalam kompleksitas O(n)
rev_cummin_low = np.minimum.accumulate(low[::-1])[::-1]

# Evaluasi status mitigasi serentak untuk seluruh gap
mitigated_mask = rev_cummin_low[i + 1] <= bullish_upper[i]

Dalam sekejap, 5 miliar operasi perbandingan menyusut menjadi sekitar $10^5$ instruksi vektor yang selesai dalam beberapa milidetik.

2. Fractal Swings dan Nol Alokasi Memori dengan Strided Window

Untuk mendeteksi titik balik harga (Fractal Swings) dengan radius window $N$ :

$SwingHigh[i] \iff High[i] = \max \{ High[i-N], \dots, High[i+N] \}$ $SwingLow[i] \iff Low[i] = \min \{ Low[i-N], \dots, Low[i+N] \}$

Alih-alih membuat sub-array baru yang membebani garbage collector, aku menggunakan manipulasi stride memori lewat sliding_window_view. Trik ini memetakan array 1D menjadi matriks 2D virtual berdimensi $(n - 2N, 2N + 1)$ dengan nol alokasi memori tambahan (zero-copy memory view):

from numpy.lib.stride_tricks import sliding_window_view

# Matriks virtual 2D tanpa alokasi RAM baru
windows = sliding_window_view(high, window_shape=2 * N + 1)
is_swing_high = high[N:-N] == np.max(windows, axis=1)

Level harga swing yang terkonfirmasi kemudian disebarkan ke depan (forward-fill) secara vektor menggunakan akumulasi indeks maksimum:

$\text{FilledIdx}_i = \max_{k \le i} \{ k \mid \text{IsSwing}_k = \text{True} \}$

3. Integrasi Polars dan Ekosistem Kuantitatif

Sebagai jembatan ke sistem pemrosesan data modern, aku menyematkan namespace native .smc langsung ke dalam Polars. Tujuannya agar pemrosesan fitur teknis dapat langsung disatukan ke dalam pipeline komputasi Apache Arrow:

import polars as pl
import pyvsmc

df = pl.read_parquet("market_ticks.parquet")

# Ekstraksi seluruh fitur struktur pasar secara paralel
df_smc = df.smc.add_all(window_size=2, ob_lookback=10)

Refleksi Akhir

Bagi aku, mengoptimalkan kode bukan soal pamer angka benchmark, melainkan bentuk penghormatan terhadap efisiensi komputasi. Ketika kita menghapus abstraksi yang tidak perlu dan membiarkan data mengalir sebagaimana hardware memprosesnya, kita mendapatkan kejelasan logika yang jauh lebih tajam.

pyvsmc aku bangun atas dasar prinsip itu: matematis, deterministik, dan tanpa redundansi instruksi.

Dokumentasi dan implementasi lengkapnya tersedia secara bebas di GitHub pyvsmc dan PyPI pyvsmc.