Rust-ல் QuantLib: libitofin மற்றும் அதன் பயன்பாடு

Rust-ல் QuantLib என்பது libitofin-ன் ஒரு வரி விளக்கம்: 2000-களின் தொடக்கத்திலிருந்தே derivatives pricing-க்கான திறந்தநிலை ஆதாரமாக (open source reference) விளங்கும் C++ நூலகமான QuantLib-ஐ Rust-க்கு மாற்றி, அதன் மேல் itofin என்ற Python தொகுப்பை உருவாக்கியுள்ளனர். ஆகஸ்ட் 2026 நிலவரப்படி, இந்தத் திட்டம் தன்னை 1.0-க்கு முந்தைய (pre-1.0) பதிப்பாகக் குறிப்பிடுகிறது; இதைப் பயன்படுத்துவதில் உள்ள நடைமுறை விஷயங்கள் அனைத்தும் இந்த அடையாளத்தையே சார்ந்திருக்கும். ஒரு pricing library, அதன் சூத்திரத்தைச் சுற்றியுள்ள கட்டமைப்பின் மூலமே தனது மதிப்பை நிலைநாட்டுகிறது; எந்த மொழியாக இருந்தாலும் இந்தக் கட்டமைப்பு ஒரே பணியையே செய்கிறது.

Spreadsheet சூத்திரம் வழங்காதவற்றை ஒரு pricing library எவ்வாறு வழங்குகிறது

Spreadsheet-ல் உள்ள ஒரு Black-Scholes கட்டம் ஐந்து உள்ளீடுகளைப் பெற்று ஒரு விலையைத் தருகிறது. சூத்திரம் என்பது எளிதான பகுதி. அதைச் சுற்றி நான்கு அடுக்குகள் உள்ளன, அந்த அடுக்குகளே நூலகம் (library) ஆகும்.

Term structures. ஒரு discount rate என்பது முதிர்வு காலங்களுக்கு இடையிலான வளைகோடு (curve) ஆகும்; சந்தையில் மேற்கோள் காட்டப்படும் புள்ளிகளுக்கு இடைப்பட்ட இடைவெளிகளை நிரப்ப ஒரு interpolation விதி தேவைப்படுகிறது. கீழே உள்ள பலகம் (panel) இதற்கான மூலப்பொருளைக் காட்டுகிறது: ஒரு குறிப்பிட்ட தேதியில் மேற்கோள் காட்டப்பட்ட Treasury tenors.

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

Aug 10, 2026 நிலவரப்படி, மேற்கோள் காட்டப்பட்ட வளைகோட்டில் 7 tenors இருந்தன; அவை 3.79%-ல் 1 month முதல் 5.25%-ல் 30 years வரை நீடிக்கின்றன. ஒரு spreadsheet இதை ஒரு lookup மற்றும் hardcoded 4% மூலம் கையாள்கிறது. ஒரு நூலகம் இதை ஒரு curve object மூலம் கையாள்கிறது; ஒவ்வொரு கருவியும் (instrument) இதிலிருந்தே விலை நிர்ணயம் செய்யப்படுகிறது. இது ஒரு குறிப்பிட்ட interpolation (zero rates-க்கு linear, discount factors-க்கு log-linear, monotone splines) மற்றும் கடைசி புள்ளிக்கு அப்பால் ஒரு extrapolation கொள்கையைக் கொண்டுள்ளது. அந்த ஒரு object-ஐ ஒரு basis point மாற்றினால், புத்தகத்தில் உள்ள அனைத்து sensitivity-களும் அதற்கேற்ப சீராக மாறும்.

Day-count conventions. வட்டி ஒரு ஆண்டின் ஒரு பகுதியாகக் கணக்கிடப்படுகிறது; அந்தப் பகுதியின் வரையறை என்பது அந்த கருவியுடன் இணைக்கப்பட்ட ஒரு மரபு (convention) ஆகும். Actual/360 என்பது கடந்த நாட்களை 360-ஆல் வகுக்கிறது. Actual/365 என்பது 365-ஆல் வகுக்கிறது. 30/360 குடும்பம் ஒவ்வொரு மாதமும் 30 நாட்களைக் கொண்டதாகக் கருதுகிறது. Business/252 என்பது 252-நாள் ஆண்டிற்கு எதிராக வர்த்தக அமர்வுகளைக் கணக்கிடுகிறது; இதற்கு விடுமுறை நாட்களுடன் கூடிய உண்மையான பங்குச் சந்தை நாட்காட்டி (exchange calendar) தேவை. 5% வட்டியில் 90 நாட்களுக்கு ஒரு மில்லியன் டாலர் கடன் வாங்கப்பட்டதாகக் கொள்வோம்: actual/360 முறையில் $12,500 வட்டியும், actual/365 முறையில் $12,329 வட்டியும் கிடைக்கும். கீழே உள்ள பலகம், ஏன் business-day அடிப்படையிலான கணக்கீட்டிற்கு வகுத்தியை விட நாட்காட்டி அவசியம் என்பதைக் காட்டுகிறது.

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

காணப்படும் 12 மாதங்களில், 2026-07 ஆனது 31 நாட்காட்டி நாட்களுக்கு எதிராக 22 அமர்வுகளைக் கொண்டிருந்தது. எந்தவொரு எளிய கணித விதியும் அந்த முதல் எண்ணைத் தராது. இது ஒரு விடுமுறை நாட்காட்டியிலிருந்து வருகிறது, ஒவ்வொரு மாதத்திற்கும் தனித்தனி விடை உண்டு. ஒரு நூலகம் அந்தந்த இடத்திற்கும் நாட்டிற்கும் உரிய நாட்காட்டிகளை வழங்குகிறது; spreadsheet-ல் நீங்களே அவற்றை பராமரிக்க வேண்டும்.

Calibration machinery. மாதிரி அளவுருக்கள் (model parameters) எங்கும் மேற்கோள் காட்டப்படுவதில்லை. சந்தையில் மேற்கோள் காட்டப்பட்ட விலைகளுக்கு ஏற்ப மாதிரி விலைகளை ஒரு முழு மேற்பரப்பில் (surface of quotes) பொருத்துவதன் மூலம் நீங்கள் அவற்றை எடுக்கிறீர்கள், பின்னர் மேற்பரப்பு மாறும்போது மீண்டும் பொருத்துகிறீர்கள். இது ஒரு bounded least-squares சிக்கலாகும், மேலும் நூலகம் அதைச் சுற்றியுள்ள சுழற்சியை வழங்குகிறது: ஒரு Levenberg-Marquardt optimiser, கடினமான கட்டுப்பாடுகள் இன்றி variance-ஐ நேர்மறையாக வைத்திருக்கும் parameter transforms, மேற்கோள் தொகுப்பின் மீதான cost function, மற்றும் விடையைத் தேடும்போது அமைதியாகத் தோல்வியடையாமல், தொடக்க மதிப்பையே திருப்பித் தராத convergence criteria.

A numerics layer. எல்லாவற்றிற்கும் அடியில் linear algebra மற்றும் integration உள்ளன. QR மற்றும் SVD decompositions ஆகியவை ஒரு fit உருவாக்கும் அமைப்புகளைத் தீர்க்கின்றன, quadrature மற்றும் Fourier integration ஆகியவை சூத்திரங்கள் integrals-ஆக உள்ள மாதிரிகளுக்கு விலை நிர்ணயம் செய்கின்றன, மேலும் root finders ஆகியவை implied volatility-ஐக் கண்டறிகின்றன. இந்த அடுக்கு சலிப்பானது, ஆனால் இதுவே மிக மோசமாக மீண்டும் செயல்படுத்தப்படும் அடுக்கு ஆகும். இதன் பாரம்பரிய வடிவம், liquid at-the-money மேற்கோள்களில் converge ஆகி, deep out-of-the-money மேற்கோள்களில் திசைமாறிச் செல்லும் ஒரு hand-rolled Newton solver ஆகும். இதற்கு அடுத்தபடியாக, near-singular fit-ல் துல்லியத்தை இழந்து, முற்றிலும் நம்பத்தகுந்ததாகத் தோன்றும் அளவுருக்களைத் தரும் matrix inverse உள்ளது. நீங்கள் ஒரு mental model-ஐ புதிதாக உருவாக்குகிறீர்கள் என்றால், an open source quant trading book எந்தவொரு நூலகத்தின் API reference-ஐ விடவும் சிறந்த தொடக்கப் புள்ளியாகும்.

libitofin என்றால் என்ன, அது Rust-ல் உள்ள QuantLib-ஆ?

ஆம், முக்கியமான அர்த்தத்தில் அது அப்படித்தான். இது QuantLib-ன் வடிவமைப்பை Rust-க்கு மாற்றியமைத்த ஒரு பதிப்பாகும், மேலும் இந்தத் திட்டம் QuantLib-ன் சொந்த சோதனைத் தொகுப்பிற்கு எதிராகச் சோதிக்கப்பட்டதாகக் கூறுகிறது. ஒரு numerics நூலகத்தை மாற்றுவதற்கு இதுவே நேர்மையான வழி: முடிவுகள், விடை எப்படி இருக்க வேண்டும் என்ற கற்பனைக்கு எதிராக அல்லாமல், reference implementation-க்கு எதிராகச் சரிபார்க்கப்படுகின்றன. Python பாதை itofin என்ற தொகுப்பாக இருப்பதால், ஒரு Python செயல்முறை C++ toolchain இல்லாமலேயே Rust engine-ஐ அடைய முடியும்.

முக்கியமான அடையாளம் pre-1.0 என்பதாகும். Rust-ன் பதிப்பு மரபின்படி, ஒரு 0.x வெளியீடு சிறிய பதிப்புகளுக்கு இடையே எந்தவொரு இணக்கத்தன்மை (compatibility) வாக்குறுதியையும் அளிக்காது: 0.4 முதல் 0.5 வரை எதையும் மறுபெயரிடவோ, நகர்த்தவோ அல்லது நீக்கவோ அனுமதிக்கப்படுகிறது. API-ஐ ஒரு நகரும் இலக்காகக் கருதுங்கள், அதற்கேற்ப சில பழக்கவழக்கங்களைப் பின்பற்றுங்கள்.

• உங்கள் lockfile-ல் ஒரு குறிப்பிட்ட tagged release-ஐப் பதிந்து வைத்து, உங்கள் சொந்த சோதனைத் தொகுப்பை நுழைவாயிலாகக் கொண்டு திட்டமிட்டு மேம்படுத்தவும்.
• நூலகத்தின் வகைகளைச் சுற்றி உங்களுக்கென ஒரு மெல்லிய wrapper-ஐ வைத்திருங்கள், இதனால் ஒரு மறுபெயரிடுதல் நாற்பது கோப்புகளுக்குப் பதிலாக ஒரே கோப்பில் முடிந்துவிடும்.
• நூலகத்தின் பதிப்பை அது உருவாக்கிய எண்களுக்கு அருகில் பதிவு செய்யுங்கள், இதனால் முடிவுகள் மாறும்போது சந்தையை விட மேம்படுத்தல் (upgrade) மீது சந்தேகம் எழ வாய்ப்புள்ளது.
• 1.0 பதிப்பு வரும் வரை, production margin, collateral மற்றும் ஒழுங்குமுறை இடர் எண்களை இணக்கத்தன்மை வாக்குறுதி கொண்ட ஒன்றில் வைத்திருங்கள்.

இவை எவையும் திட்டத்தின் மீதான விமர்சனம் அல்ல. Pre-1.0 என்பது ஒரு துல்லியமான சுய-விளக்கம் மற்றும் மிகப்பாரிய நூலகத்தின் இளம் பதிப்பிற்கு இதுவே சரியான இடமாகும். ஒரு வாசகர் இதை QuantLib-க்கு மாற்றாகக் கருதி, ஒரு காலாண்டின் பாதியில் சிறிய பதிப்பில் மாறிய signature-ஐச் சந்திப்பதுதான் தோல்விக்கான வழி. நிறுவல் வழிமுறைகளும் பதிப்புடன் மாறுகின்றன, மேலும் cargo மற்றும் pip ஆகிய இரண்டிற்கும் எதையும் தீர்க்க நெட்வொர்க் அணுகல் தேவை, எனவே வலைப்பதிவு இடுகையிலிருந்து நகலெடுக்கப்பட்ட துணுக்கை விட, நீங்கள் பதிக்க விரும்பும் tag-ல் உள்ள திட்டத்தின் சொந்த README-ஐப் படிக்கவும்.

Python, ஒரு compiled engine, அல்லது Rust?

இரண்டு கேள்விகள் இதைத் தீர்மானிக்கின்றன, இரண்டும் சுவை சார்ந்தவை அல்ல. நீங்கள் ஒரு வினாடிக்கு எத்தனை முறை விலை நிர்ணயம் செய்கிறீர்கள், மற்றும் உங்கள் எண்கள் தனித்தனி செயல்முறைகளில் ஒத்துப்போக வேண்டுமா? Chain அளவு முதல் கேள்வியின் அளவைத் தீர்மானிக்கிறது.

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

Aug 11, 2026 அன்று, SPY ஒரே அமர்வில் 5336 தனித்துவமான ஒப்பந்தங்களை வர்த்தகம் செய்தது, KO-க்கு 360 ஒப்பந்தங்கள் இருந்தன. ஒரு பெரிய chain-க்கு ஒருமுறை விலை நிர்ணயம் செய்வது எளிது. ஒவ்வொரு quote update-க்கும், ஒரு ஒப்பந்தத்திற்கு ஐந்து sensitivities வீதம், ஒரு புத்தகத்தின் கீழ் உள்ள அனைத்து சொத்துக்களுக்கும் விலை நிர்ணயம் செய்வது, வெவ்வேறு கட்டுப்பாடுகளைக் கொண்ட ஒரு மாறுபட்ட நிரலாகும்.

லூப் (loop) நிமிடத்திற்கு ஆயிரக்கணக்கான மதிப்பீடுகளில் அளவிடப்படும்போதும், அதைச் சுற்றியுள்ள வேலை ஆராய்ச்சி, பகுப்பாய்வு அல்லது நாள் இறுதி மதிப்புகளாக இருக்கும்போதும், நிறுவப்பட்ட நூலகத்துடன் Python-லேயே இருங்கள். QuantLib-ன் சொந்த Python bindings முதிர்ந்த தேர்வாகும்: அதே C++ engine, பரந்த அளவிலான கருவிகள் மற்றும் பல ஆண்டுகால பயன்பாட்டு அனுபவம். ஆராய்ச்சி குறியீட்டில் வேகம் அரிதாகவே ஒரு தடையாக இருக்கும்; கவரேஜ் மற்றும் துல்லியம் தான் முக்கியம்.

லூப் வேகமாகவும், அதைச் சுற்றியுள்ள குறியீடு மெதுவாகவும் இருக்கும்போது, Python-லிருந்து ஒரு compiled engine-ஐ அழைக்கவும். கவனிக்க வேண்டிய செலவு எல்லை (boundary) தான். Python-லிருந்து ஒவ்வொரு ஒப்பந்த அழைப்பும் ஒவ்வொரு முறை கடக்கும்போதும் overhead-ஐ ஏற்படுத்துகிறது, இதற்குத் தீர்வாக engine-க்கு ஒரு array-ஐக் கொடுத்து, ஒரு array-ஐத் திரும்பப் பெறுவது சிறந்தது. QuantLib-Python-க்கு இணையாக itofin-ம் இந்த இடத்தையே குறிவைக்கிறது.

விலை நிர்ணய லூப் தான் தயாரிப்பு என்றால் Rust-ல் எழுதுங்கள்: ஒரு quoting service-க்குள் இருக்கும் pricer, நீங்கள் தவறவிட முடியாத கால அட்டவணையில் இயங்கும் இடர் கணக்கீடு, அல்லது Python இல்லாத ஒரு கணினியில் அனுப்பப்படும் binary. இரண்டாவது கேள்வியும் இங்கேதான் பொருந்துகிறது. மிதக்கும் புள்ளி (floating point) முடிவுகள் செயல்பாடுகளின் வரிசையைப் பொறுத்தது, எனவே ஒரே மாதிரியான இரண்டு மாதிரிகள் கடைசி இலக்கங்களில் மாறுபடலாம், மேலும் ஆராய்ச்சி குறிப்பேடு production service-உடன் முரண்படுவது ஒரு வார கால தடயவியல் ஆய்வுக்கு வழிவகுக்கும். ஒரே engine-ஐ இரு பக்கங்களிலிருந்தும் பயன்படுத்துவது இந்த முரண்பாட்டை நீக்குகிறது, இதுவே எந்த மொழியில் எழுதப்பட்டாலும் compiled core-ஐப் பயன்படுத்துவதற்கான வலுவான வாதமாகும். இதே உணர்வு உத்தி சார்ந்த வேலைகளுக்கும் பொருந்தும், a reproducible backtest இதைக் காட்டுகிறது.

Calibration இலக்கு உண்மையில் எங்கே உள்ளது

Calibration-க்கு பொருத்துவதற்கு ஒன்று தேவை, அது சந்தை-குறித்த implied volatilities-ன் மேற்பரப்பு ஆகும். அதன் root-finding பக்கம் how implied volatility is calculated என்பதில் விவரிக்கப்பட்டுள்ளது. கீழே உள்ள வடிவம் ஒரு மாதிரி பொருத்த வேண்டிய ஒன்றாகும்.

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)

Money-க்கு அருகில், 0 to 7 days bucket-ல் உள்ள AAPL ஒப்பந்தங்கள், காணப்பட்ட அமர்வுகளில் சராசரியாக 29.6% implied volatility-ஐக் கொண்டிருந்தன, 241 days or more-ல் 29.3% ஆக இருந்தது. ஒரு volatility அளவுருவைக் கொண்ட ஒரு மாதிரியால் ஒரே நேரத்தில் இரண்டு புள்ளிகளிலும் இருக்க முடியாது, இதனால்தான் volatility term structure கொண்ட மாதிரிகள் உள்ளன. இது போன்ற ஒரு மேற்பரப்பில் ஒன்றைப்பொருத்துவதுதான் calibration படிநிலை, மேலும் பொருத்தப்பட்ட மாதிரியிலிருந்து வெளிவரும் sensitivities-கள் greeks ஆகும், இது the option greeks explained என்பதில் விவரிக்கப்பட்டுள்ளது.

FAQ

libitofin என்பது QuantLib-க்கு மாற்றாக (drop-in replacement) அமையுமா?

இல்லை. ஆகஸ்ட் 2026 நிலவரப்படி, இது QuantLib-ன் ஒரு பகுதியை உள்ளடக்கிய மற்றும் அதன் சொந்த சோதனைத் தொகுப்பிற்கு எதிராக முடிவுகளைச் சரிபார்க்கும் 1.0-க்கு முந்தைய பதிப்பாகும். QuantLib-ன் Python bindings மூலம் அணுகப்படும் QuantLib-யே production வேலைகளுக்கு மிகவும் பரந்த மற்றும் நிலையான தேர்வாக உள்ளது.

ஒரு pricing library-க்கு pre-1.0 என்பதன் பொருள் என்ன?

Rust-ன் பதிப்பு மரபின்படி, ஒரு 0.x வெளியீடு எந்தவொரு இணக்கத்தன்மை வாக்குறுதியையும் அளிக்காது: அடுத்த சிறிய பதிப்பு எதையும் மறுபெயரிடவோ அல்லது நீக்கவோ சுதந்திரமானது. நடைமுறையில், ஒரு குறிப்பிட்ட tagged release-ஐப் பதிந்து வைத்து, ஒவ்வொரு மேம்படுத்தலின் போதும் உங்கள் சொந்த சோதனைத் தொகுப்பை மீண்டும் இயக்குவதே இதன் பொருள்.

libitofin-ஐப் பயன்படுத்த நான் Rust-ல் எழுத வேண்டுமா?

இல்லை. இந்தத் திட்டம் itofin என்ற Python தொகுப்பை வெளியிடுகிறது, எனவே engine-ஐ ஒரு சாதாரண Python செயல்முறையிலிருந்து அழைக்க முடியும். விலை நிர்ணய லூப் தான் நீங்கள் அனுப்பும் தயாரிப்பு என்றால் மட்டுமே Rust-ல் எழுதுவது பொருத்தமானதாகிறது.

Spreadsheet சூத்திரம் வழங்காதவற்றை ஒரு pricing library எனக்கு எவ்வாறு வழங்குகிறது?

ஒற்றை வட்டி விகிதங்களுக்குப் பதிலாக வளைகோடுகள் (curves), உண்மையான பங்குச் சந்தை நாட்காட்டிகளைக் கொண்ட day-count மரபுகள், மாதிரி அளவுருக்களை மேற்கோள் காட்டப்பட்ட விலைகளுக்குப் பொருத்தும் calibration லூப், மற்றும் இவை மூன்றிற்கும் அடியில் ஒரு சோதிக்கப்பட்ட numerics அடுக்கு. Closed-form சூத்திரம் என்பது வேலையின் சிறிய பகுதி மட்டுமே.

நிரலாக்க மொழி (programming language) option விலையை மாற்றுகிறதா?

கணித ரீதியாக இல்லை. இது மறுஉருவாக்கத்தை (reproducibility) மாற்றுகிறது: மிதக்கும் புள்ளி முடிவுகள் செயல்பாடுகளின் வரிசையைப் பொறுத்தது, எனவே ஒரே மாதிரியான இரண்டு மாதிரிகள் கடைசி இலக்கங்களில் மாறுபடலாம். ஆராய்ச்சி மற்றும் production ஆகிய இரண்டையும் ஒரே engine-ல் இயக்குவது அந்த இடைவெளியை நீக்குகிறது.

இங்கே உள்ள ஒவ்வொரு பலகமும் அதன் துல்லியமான SQL-ஐக் கொண்டுள்ளது, எனவே கணக்கீடு எவ்வாறு எடுக்கப்பட்டது என்பதைப் பார்க்க ஒன்றை விரிவுபடுத்தவும். அதே curve, calendar மற்றும் chain கேள்விகளை Strasmore terminal-ல் எளிய ஆங்கிலத்தில் கேட்கலாம்.