Kutumia libitofin: QuantLib katika lugha ya Rust

QuantLib katika Rust ndiyo maelezo ya mstari mmoja ya libitofin: ni toleo la QuantLib, maktaba ya C++ ambayo imekuwa rejeleo la chanzo huria (open source) kwa ajili ya kupanga bei za derivatives tangu mwanzoni mwa miaka ya 2000, iliyohamishiwa kwenye Rust, ikiwa na kifurushi cha Python kinachoitwa itofin juu yake. Kufikia Agosti 2026, mradi huu unajieleza kama wa hatua ya kabla ya 1.0, na lebo hiyo huongoza kila kitu cha kivitendo kuhusu matumizi yake. Maktaba ya kupanga bei hujipatia nafasi yake kupitia mitambo iliyofungwa kuzunguka fomula, na mitambo hiyo ni kazi ileile katika lugha yoyote.

Kile ambacho maktaba ya kupanga bei hukupa ambacho fomula ya spreadsheet haikupi

Seli ya Black-Scholes katika spreadsheet huchukua pembejeo tano na kutoa bei. Fomula ndiyo sehemu rahisi. Tabaka nne hukaa kuizunguka, na tabaka hizo ndizo maktaba yenyewe.

Muundo wa muda (Term structures). Kiwango cha punguzo (discount rate) ni mkondo (curve) unaovuka muda wa kukomaa (maturities), ukiwa na kanuni ya interpolation kwa mapengo yaliyopo kati ya pointi ambazo mtu yeyote hunukuu. Paneli iliyo hapa chini ni malighafi: tenors za Treasury zilizotajwa katika tarehe moja.

SELECT
    arrayElement(tenors, i)                  AS tenor,
    round(arrayElement(rates, i), 2)         AS yield_pct,
    formatDateTime(curve_date, '%b %e, %Y')  AS as_of
FROM
(
    SELECT
        date AS curve_date,
        ['1 month', '3 months', '6 months', '1 year', '2 years', '3 years',
         '5 years', '7 years', '10 years', '20 years', '30 years']         AS tenors,
        [toFloat64(yield_1_month), toFloat64(yield_3_month), toFloat64(yield_6_month),
         toFloat64(yield_1_year),  toFloat64(yield_2_year),  toFloat64(yield_3_year),
         toFloat64(yield_5_year),  toFloat64(yield_7_year),  toFloat64(yield_10_year),
         toFloat64(yield_20_year), toFloat64(yield_30_year)]                AS rates,
        arrayJoin(range(1, 12))                                            AS i
    FROM global_markets.treasury_yields
    WHERE date = (SELECT max(date) FROM global_markets.treasury_yields)
)
WHERE yield_pct > 0
ORDER BY i

Kufikia Aug 10, 2026, mkondo uliotajwa ulikuwa na 7 tenors, kuanzia 3.79% kwa 1 month hadi 5.25% kwa 30 years. Spreadsheet hukutana na hili kwa kutumia lookup na asilimia nne iliyowekwa (hardcoded). Maktaba hukutana na hili kwa kutumia kitu cha mkondo (curve object) ambacho kila chombo (instrument) hupanga bei yake, chini ya interpolation iliyoelezwa (linear kwenye viwango vya zero, log-linear kwenye discount factors, monotone splines) na sera ya extrapolation iliyoelezwa baada ya pointi ya mwisho. Badilisha kitu hicho kimoja kwa basis point moja na kila sensitivity katika kitabu itasogea kwa uwiano nayo.

Mikataba ya kuhesabu siku (Day-count conventions). Riba hujilimbikiza kwa sehemu ya mwaka, na ufafanuzi wa sehemu hiyo ni mkataba ulioambatishwa kwenye chombo husika. Actual/360 hugawanya siku zilizopita kwa 360. Actual/365 hugawanya kwa 365. Familia ya 30/360 hujifanya kama kila mwezi una siku 30. Business/252 huhesabu vipindi vya biashara dhidi ya mwaka wa siku 252, jambo linalohitaji kalenda halisi ya soko la hisa yenye likizo zilizopakiwa tayari. Chukua dola milioni moja zilizokopwa kwa asilimia tano kwa siku 90: actual/360 hujilimbikiza $12,500 na actual/365 hujilimbikiza $12,329 kwenye biashara ileile. Paneli iliyo hapa chini inaonyesha kwa nini msingi wa siku za biashara unahitaji kalenda badala ya kigawanyaji.

SELECT
    formatDateTime(toStartOfMonth(date), '%Y-%m')      AS month,
    countDistinct(date)                                AS trading_days,
    toUInt8(toDayOfMonth(toLastDayOfMonth(max(date)))) AS calendar_days
FROM global_markets.stocks_daily_aggs
WHERE ticker = 'SPY'
  AND date >= toStartOfMonth(today() - 365)
  AND date <  toStartOfMonth(today())
GROUP BY month
ORDER BY month

Katika kipindi cha 12 miezi inayoonekana, 2026-07 ilikuwa na 22 vipindi dhidi ya 31 siku za kalenda. Hakuna kanuni ya hesabu inayozalisha namba hiyo ya kwanza. Inatokana na kalenda ya likizo, na kila mwezi una jibu lake. Maktaba husafirisha kalenda hizo kwa kila ukumbi na kila nchi; spreadsheet inakuomba uzitunze wewe mwenyewe.

Mitambo ya calibration. Vigezo vya mfano (model parameters) havijatajwa popote. Unavichagua kwa kulinganisha bei za mfano na bei za soko zilizozingatiwa katika uso mzima wa nukuu, kisha unarekebisha upya kadiri uso huo unavyosogea. Hilo ni tatizo la least-squares lililofungwa, na maktaba hutoa kitanzi kinacholizunguka: Levenberg-Marquardt optimiser, mabadiliko ya vigezo yanayoweka variance kuwa chanya bila vikwazo vigumu, kazi ya gharama (cost function) juu ya seti ya nukuu, na vigezo vya muunganiko (convergence criteria) vinavyoshindwa kwa sauti badala ya kurudisha kimya kimya makisio ya kuanzia.

Tabaka la namba (Numerics layer). Chini ya kila kitu kuna aljebra ya mstari na ujumuishaji (integration). QR na SVD decompositions hutatua mifumo inayozalishwa na fit, quadrature na Fourier integration hupanga bei za mifano ambayo fomula zake ni integrals, na root finders hutoa implied volatility. Tabaka hili ni gumu, na ndilo tabaka ambalo mara nyingi hurejewa vibaya. Toleo la kawaida ni Newton solver iliyotengenezwa kwa mkono ambayo huungana kwenye nukuu za at-the-money zenye ukwasi na kupotea kwenye zile za deep out-of-the-money. Ya pili kwa karibu ni matrix inverse inayopoteza usahihi kwenye fit iliyo karibu na singular na kurudisha vigezo vinavyoonekana kuwa vya kweli kabisa. Ikiwa unajenga mfano wa kiakili kuanzia mwanzo, kitabu cha quant trading cha chanzo huria ni mahali pazuri pa kuanzia kuliko marejeleo yoyote ya API ya maktaba.

Libitofin ni nini, na je, ni QuantLib katika Rust?

Ndiyo, kwa maana inayohusika. Ni toleo la muundo wa QuantLib katika Rust, na mradi unasema kuwa umejaribiwa dhidi ya seti ya majaribio ya QuantLib yenyewe. Hiyo ndiyo njia ya uaminifu ya kuhamisha maktaba ya namba: matokeo hukaguliwa dhidi ya utekelezaji wa rejeleo badala ya dhidi ya matarajio yaliyoandikwa kwa mkono ya jibu linavyopaswa kuwa. Njia ya Python ni kifurushi kinachoitwa itofin, kwa hivyo mchakato wa Python unaweza kufikia injini ya Rust bila mnyororo wa zana za C++ katikati.

Lebo inayojali zaidi ni kabla ya 1.0. Chini ya mkataba wa toleo la Rust, toleo la 0.x halibebi ahadi ya utangamano kati ya matoleo madogo: 0.4 hadi 0.5 inaruhusiwa kubadili jina, kusogeza, au kufuta chochote inachopenda. Ichukulie API kama lengo linalosogea, na tabia chache hufuata.

• Bandika toleo kamili lililowekewa alama (tagged release) kwenye lockfile yako na uboreshe kwa makusudi, ukitumia seti yako ya majaribio kama lango.
• Weka kanga nyembamba ya kwako kuzunguka aina za maktaba, ili mabadiliko ya jina yatokee kwenye faili moja badala ya arobaini.
• Rekodi toleo la maktaba kando ya namba ilizozalisha, ili kurudia kwa matokeo tofauti kuonyeshe uboreshaji badala ya soko.
• Weka margin ya uzalishaji, dhamana, na namba za hatari za udhibiti kwenye kitu kinachobeba ahadi ya utangamano hadi 1.0 ifike.

Hakuna kati ya hayo ni ukosoaji wa mradi. Kabla ya 1.0 ni maelezo sahihi ya kibinafsi na mahali sahihi kwa toleo changa la maktaba kubwa sana kukaa. Njia ya kushindwa ni msomaji kuichukulia kama QuantLib swap ya moja kwa moja na kukutana na sahihi iliyobadilishwa katika toleo dogo, katikati ya robo mwaka. Maagizo ya usakinishaji pia husogea pamoja na toleo, na cargo na pip zote zinahitaji ufikiaji wa mtandao ili kutatua chochote, kwa hivyo soma README ya mradi kwenye tag unayokusudia kubandika badala ya kipande kilichonakiliwa kutoka kwenye chapisho la blogu, hili likiwemo.

Python, injini iliyokusanywa (compiled engine), au Rust?

Maswali mawili hutatua hili, na hakuna hata moja linalohusu ladha. Ni mara ngapi kwa sekunde unapanga bei upya, na je, namba zako lazima zilingane katika michakato tofauti? Ukubwa wa mnyororo huweka kiwango cha swali la kwanza.

WITH (SELECT max(date) FROM global_markets.options_greeks) AS last_session
SELECT
    underlying_symbol                      AS symbol,
    countDistinct(ticker)                  AS contracts_priced,
    formatDateTime(max(date), '%b %e, %Y') AS as_of
FROM global_markets.options_greeks
WHERE date = last_session
  AND underlying_symbol IN ('SPY', 'AAPL', 'NVDA', 'MSFT', 'KO')
  AND volume > 0
GROUP BY symbol
ORDER BY contracts_priced DESC

Mnamo Aug 11, 2026, SPY ilikuwa na 5336 mikataba tofauti iliyofanya biashara katika kipindi kimoja, dhidi ya 360 kwa KO. Kupanga bei ya mnyororo mpana mara moja si kitu kabisa. Kuipanga kwa sensitivities tano kwa kila mkataba, kwenye kila sasisho la nukuu, katika kitabu cha underlyings, ni programu tofauti yenye vikwazo tofauti.

Kaa kwenye Python na maktaba iliyoanzishwa wakati kitanzi kinapimwa kwa maelfu ya tathmini kwa dakika na kazi inayozunguka ni utafiti, uchambuzi, au alama za mwisho wa siku. Vifungo vya Python vya QuantLib vyenyewe ndivyo chaguo lililokomaa: injini ileile ya C++, ufikiaji mpana zaidi wa vyombo, na miaka ya matumizi ya uzalishaji. Kasi mara chache ndiyo kikwazo cha msingi katika msimbo wa utafiti; ufikiaji na usahihi ndivyo.

Ita injini iliyokusanywa kutoka Python wakati kitanzi ni cha moto na msimbo unaozunguka si wa moto. Gharama ya kutazama ni mpaka wenyewe. Wito wa kila mkataba kutoka Python hulipa gharama ya ziada kwenye kila mpaka, na suluhisho ni kuipa injini safu (array) na kuchukua safu nyingine kurudi. Hii ndiyo nafasi ambayo itofin inalenga, kando ya QuantLib-Python.

Andika Rust wakati kitanzi cha kupanga bei ndicho bidhaa: pricer ndani ya huduma ya nukuu, hatari inayofanyika kwa ratiba ambayo huwezi kuikosa, au binary iliyosafirishwa kwenye kisanduku kisicho na Python. Swali la pili linatua hapa pia. Matokeo ya floating point hutegemea mpangilio wa shughuli, kwa hivyo mfano uleule uliotekelezwa mara mbili unaweza kutofautiana katika tarakimu za mwisho, na daftari la utafiti linalotofautiana na huduma ya uzalishaji ni wiki moja ya uchunguzi wa kitaalamu. Injini moja inayotumiwa kutoka pande zote mbili huondoa kategoria hiyo yote ya tofauti, ambayo ndiyo hoja ya kudumu kwa msingi uliokusanywa wenye vifungo bila kujali lugha iliyoandikiwa. Silika ileile inatumika kwa kazi ya mkakati, kama backtest inayoweza kuzalishwa upya inavyoonyesha.

Mahali ambapo lengo la calibration huishi

Calibration inahitaji kitu cha kulinganisha nacho, na kitu hicho ni uso wa volatilities zilizodokezwa na soko (market-implied volatilities). Upande wa kutafuta mzizi wa hilo umefunikwa katika jinsi implied volatility inavyohesabiwa. Umbo lililo hapa chini ndilo ambalo mfano lazima ulingane nalo.

SELECT
    multiIf(days_to_expiry <=   7, '0 to 7 days',
            days_to_expiry <=  30, '8 to 30 days',
            days_to_expiry <=  60, '31 to 60 days',
            days_to_expiry <= 120, '61 to 120 days',
            days_to_expiry <= 240, '121 to 240 days',
                                   '241 days or more') AS dte_bucket,
    round(avg(implied_volatility) * 100, 1)            AS iv_pct,
    countDistinct(ticker)                              AS contracts
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date >= today() - 10
  AND days_to_expiry >= 0
  AND iv_converged = 1
  AND volume > 0
  AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
GROUP BY dte_bucket
ORDER BY min(days_to_expiry)

Karibu na pesa (near the money), mikataba ya AAPL katika ndoo ya 0 to 7 days ilikuwa na wastani wa 29.6% implied volatility katika vipindi vinavyoonekana, dhidi ya 29.3% kwa 241 days or more. Mfano unaobeba kigezo kimoja cha volatility hauwezi kukaa kwenye pointi zote mbili kwa wakati mmoja, ambayo ndiyo sababu yote ya mifano yenye muundo wa muda wa volatility kuwepo. Kulinganisha moja na uso kama huu ndiyo hatua ya calibration, na sensitivities zinazotoka kwenye mfano uliolinganishwa ni greeks, zilizofunikwa katika option greeks zilizoelezwa.

Maswali Yanayoulizwa Mara Kwa Mara

Je, libitofin ni mbadala wa moja kwa moja wa QuantLib?

Hapana. Kufikia Agosti 2026 ni toleo la kabla ya 1.0 linalofunika sehemu ya uso wa QuantLib na kuhalalisha matokeo yake dhidi ya seti ya majaribio ya QuantLib yenyewe. QuantLib yenyewe, inayofikiwa kupitia vifungo vyake vya Python, inabaki kuwa chaguo pana na thabiti zaidi kwa kazi ya uzalishaji.

Kabla ya 1.0 inamaanisha nini kwa maktaba ya kupanga bei?

Chini ya mkataba wa toleo la Rust, toleo la 0.x halitoi ahadi ya utangamano: toleo dogo linalofuata liko huru kubadili jina au kufuta chochote. Katika mazoezi, hiyo inamaanisha kubandika toleo kamili lililowekewa alama na kurudia seti yako ya majaribio kwenye kila uboreshaji.

Je, ninahitaji kuandika Rust ili kutumia libitofin?

Hapana. Mradi huchapisha kifurushi cha Python kinachoitwa itofin, kwa hivyo injini inaweza kuitwa kutoka kwa mchakato wa kawaida wa Python. Kuandika Rust kunakuwa muhimu wakati kitanzi cha kupanga bei chenyewe ndicho kitu unachosafirisha.

Je, maktaba ya kupanga bei hunipa nini ambacho fomula ya spreadsheet haikupi?

Mikondo badala ya viwango vya pekee, mikataba ya kuhesabu siku yenye kalenda halisi za soko la hisa nyuma yake, kitanzi cha calibration kinacholinganisha vigezo vya mfano na bei zilizotajwa, na tabaka la namba lililojaribiwa chini ya yote matatu. Fomula ya closed-form ni sehemu ndogo ya kazi.

Je, lugha ya programu hubadilisha bei ya option?

Siyo kihisabati. Inabadilisha uwezekano wa kuzalishwa upya: matokeo ya floating point hutegemea mpangilio wa shughuli, kwa hivyo utekelezaji mbili wa mfano mmoja unaweza kutofautiana katika tarakimu za mwisho. Kuendesha utafiti na uzalishaji kutoka kwa injini ileile huondoa pengo hilo.

Kila paneli hapa inabeba SQL yake kamili chini yake, kwa hivyo panua moja ili kuona jinsi hesabu ilivyochukuliwa. Maswali yale yale ya mkondo, kalenda, na mnyororo yanaweza kuulizwa kwa Kiingereza rahisi kwenye terminal ya Strasmore.