Rustలో QuantLib: libitofin లైబ్రరీ పరిచయం

Rustలో QuantLib అనేది libitofin యొక్క ఒకే వాక్య వివరణ: ఇది 2000ల ప్రారంభం నుండి డెరివేటివ్స్ ప్రైసింగ్ కోసం ఓపెన్ సోర్స్ రిఫరెన్స్‌గా ఉన్న C++ లైబ్రరీ QuantLibని Rustలోకి మార్చిన వెర్షన్. దీనికి పైన itofin అనే Python ప్యాకేజీ ఉంటుంది. ఆగస్టు 2026 నాటికి, ఈ ప్రాజెక్ట్ తనను తాను 1.0 కంటే ముందు దశ (pre-1.0)గా పేర్కొంది; దీనిని ఉపయోగించేటప్పుడు ఆ లేబుల్ అన్ని ఆచరణాత్మక అంశాలను ప్రభావితం చేస్తుంది. ఒక ప్రైసింగ్ లైబ్రరీ దాని ఫార్ములా చుట్టూ ఉండే యంత్రాంగం ద్వారా తన విలువను నిరూపించుకుంటుంది, ఆ యంత్రాంగం ఏ భాషలోనైనా ఒకే విధమైన పనిని చేస్తుంది.

స్ప్రెడ్‌షీట్ ఫార్ములా ఇవ్వలేని ప్రైసింగ్ లైబ్రరీ ప్రయోజనాలు

స్ప్రెడ్‌షీట్‌లోని ఒక Black-Scholes సెల్ ఐదు ఇన్‌పుట్‌లను తీసుకుని ఒక ధరను ఇస్తుంది. ఫార్ములా అనేది సులభమైన భాగం. దాని చుట్టూ నాలుగు పొరలు ఉంటాయి, ఆ పొరలే లైబ్రరీని ఏర్పరుస్తాయి.

Term structures. డిస్కౌంట్ రేటు అనేది మెచ్యూరిటీల అంతటా ఉండే ఒక కర్వ్, ఇది మార్కెట్‌లో కోట్ చేయబడిన పాయింట్ల మధ్య గ్యాప్‌లను పూరించడానికి ఇంటర్‌పోలేషన్ నియమాన్ని ఉపయోగిస్తుంది. కింద ఉన్న ప్యానెల్ ముడి సమాచారాన్ని చూపుతుంది: ఒక నిర్దిష్ట తేదీన కోట్ చేయబడిన 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 వరకు విస్తరించి ఉంది. స్ప్రెడ్‌షీట్ దీనిని ఒక లుకప్ మరియు హార్డ్‌కోడ్ చేసిన 4%తో పరిష్కరిస్తుంది. లైబ్రరీ దీనిని ఒక కర్వ్ ఆబ్జెక్ట్‌తో పరిష్కరిస్తుంది, దీని ద్వారా ప్రతి ఇన్‌స్ట్రుమెంట్ ధర నిర్ణయించబడుతుంది. ఇది నిర్ణీత ఇంటర్‌పోలేషన్ (zero ratesపై లీనియర్, డిస్కౌంట్ ఫ్యాక్టర్లపై లాగ్-లీనియర్, మోనోటోన్ స్ప్లైన్స్) మరియు చివరి పాయింట్ తర్వాత ఎక్స్‌ట్రాపోలేషన్ విధానాన్ని అనుసరిస్తుంది. ఆ ఆబ్జెక్ట్‌ను ఒక బేసిస్ పాయింట్ మార్చితే, బుక్‌లోని ప్రతి సెన్సిటివిటీ దానికి అనుగుణంగా మారుతుంది.

Day-count conventions. వడ్డీ అనేది సంవత్సరంలో కొంత భాగంపై లెక్కించబడుతుంది, ఆ భిన్నం యొక్క నిర్వచనం ఇన్‌స్ట్రుమెంట్‌కు అనుబంధంగా ఉండే ఒక కన్వెన్షన్. Actual/360 అనేది గడిచిన రోజులను 360తో భాగిస్తుంది. Actual/365 అనేది 365తో భాగిస్తుంది. 30/360 పద్ధతి ప్రతి నెలకు 30 రోజులు ఉంటాయని భావిస్తుంది. Business/252 అనేది 252 రోజుల సంవత్సరానికి వ్యతిరేకంగా ట్రేడింగ్ సెషన్లను లెక్కిస్తుంది, దీనికి సెలవులతో కూడిన అసలైన ఎక్స్ఛేంజ్ క్యాలెండర్ అవసరం. ఉదాహరణకు, 90 రోజుల పాటు 5% వడ్డీకి తీసుకున్న మిలియన్ డాలర్లను తీసుకుంటే: actual/360 పద్ధతిలో $12,500 వడ్డీ వస్తే, actual/365 పద్ధతిలో అదే ట్రేడ్‌పై $12,329 వస్తుంది. కింద ఉన్న ప్యానెల్ బిజినెస్-డే బేసిస్‌కు డివైజర్ కంటే క్యాలెండర్ ఎందుకు అవసరమో చూపుతుంది.

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 లో 22 సెషన్లు ఉన్నాయి, ఇవి 31 క్యాలెండర్ రోజులకు సమానం. ఏ అంకగణిత నియమం కూడా ఆ మొదటి సంఖ్యను ఇవ్వదు. ఇది హాలిడే క్యాలెండర్ నుండి వస్తుంది, ప్రతి నెలకు దాని స్వంత సమాధానం ఉంటుంది. ఒక లైబ్రరీ ప్రతి వేదిక మరియు దేశానికి ఆ క్యాలెండర్లను అందిస్తుంది; స్ప్రెడ్‌షీట్‌లో మీరు వాటిని మాన్యువల్‌గా నిర్వహించాలి.

Calibration machinery. మోడల్ పారామితులు ఎక్కడా కోట్ చేయబడవు. మీరు మార్కెట్ ధరలకు అనుగుణంగా మోడల్ ధరలను సరిపోల్చడం ద్వారా వాటిని ఎంచుకుంటారు, ఆపై సర్ఫేస్ మారినప్పుడు తిరిగి ఫిట్ చేస్తారు. ఇది ఒక బౌండెడ్ లీస్ట్-స్క్వేర్స్ సమస్య, లైబ్రరీ దీని చుట్టూ లూప్‌ను అందిస్తుంది: Levenberg-Marquardt ఆప్టిమైజర్, కఠినమైన పరిమితులు లేకుండా వేరియన్స్‌ను పాజిటివ్‌గా ఉంచే పారామీటర్ ట్రాన్స్‌ఫార్మ్స్, కోట్ సెట్‌పై కాస్ట్ ఫంక్షన్ మరియు ప్రారంభ అంచనాను ఇవ్వకుండా స్పష్టంగా విఫలమయ్యే కన్వర్జెన్స్ ప్రమాణాలు.

A numerics layer. అన్నింటికీ అడుగున లీనియర్ ఆల్జీబ్రా మరియు ఇంటిగ్రేషన్ ఉంటాయి. QR మరియు SVD డీకంపోజిషన్లు ఫిట్ ద్వారా వచ్చే సిస్టమ్‌లను పరిష్కరిస్తాయి, క్వాడ్రేచర్ మరియు ఫోరియర్ ఇంటిగ్రేషన్ ఫార్ములాలు ఇంటిగ్రల్స్‌గా ఉన్న మోడళ్లకు ధరను నిర్ణయిస్తాయి, మరియు రూట్ ఫైండర్లు ఇంప్లైడ్ వోలటాలిటీని లెక్కిస్తాయి. ఈ పొర చాలా క్లిష్టమైనది, సరిగ్గా అమలు చేయకపోతే సమస్యలు వస్తాయి. సాధారణంగా వాడే న్యూటన్ సాల్వర్ లిక్విడ్ అట్-ది-మనీ కోట్స్‌పై బాగా పనిచేస్తుంది కానీ అవుట్-ఆఫ్-ది-మనీ కోట్స్‌పై తప్పుగా పనిచేస్తుంది. మ్యాట్రిక్స్ ఇన్వర్స్ కూడా తక్కువ ప్రిసిషన్ ఉన్నప్పుడు తప్పు పారామితులను ఇవ్వవచ్చు. మీరు మొదటి నుండి మోడల్‌ను నిర్మిస్తుంటే, ఓపెన్ సోర్స్ క్వాంట్ ట్రేడింగ్ బుక్ ఏదైనా లైబ్రరీ API రిఫరెన్స్ కంటే మంచి ప్రారంభ స్థానం.

libitofin అంటే ఏమిటి, ఇది Rustలో QuantLib అవునా?

అవును, ముఖ్యమైన కోణంలో ఇది QuantLibనే. ఇది QuantLib డిజైన్‌ను Rustలోకి మార్చిన వెర్షన్, మరియు ఈ ప్రాజెక్ట్ తనను తాను QuantLib యొక్క టెస్ట్ సూట్‌తో పరీక్షించుకున్నట్లు పేర్కొంది. ఒక న్యూమరిక్స్ లైబ్రరీని పోర్ట్ చేయడానికి ఇది సరైన మార్గం: ఫలితాలు ఊహల ఆధారంగా కాకుండా, రిఫరెన్స్ ఇంప్లిమెంటేషన్‌తో సరిపోల్చబడతాయి. Python కోసం itofin అనే ప్యాకేజీ ఉంది, కాబట్టి C++ టూల్‌చైన్ లేకుండానే Python ప్రాసెస్ Rust ఇంజిన్‌ను చేరుకోగలదు.

ఇక్కడ ముఖ్యమైన విషయం ఏమిటంటే ఇది 1.0 కంటే ముందు దశలో ఉంది. Rust వెర్షనింగ్ కన్వెన్షన్ ప్రకారం, 0.x రిలీజ్ మైనర్ వెర్షన్ల మధ్య అనుకూలతకు (compatibility) హామీ ఇవ్వదు: 0.4 నుండి 0.5కి మారినప్పుడు ఏదైనా పేరు మార్చవచ్చు, తరలించవచ్చు లేదా తొలగించవచ్చు. APIని మారుతున్న లక్ష్యంగా భావించండి, మరియు కొన్ని అలవాట్లను పాటించండి.

• మీ లాక్‌ఫైల్‌లో ఖచ్చితమైన ట్యాగ్ చేయబడిన రిలీజ్‌ను పిన్ చేయండి మరియు మీ స్వంత టెస్ట్ సూట్‌ను గేట్‌గా ఉపయోగించి అప్‌గ్రేడ్ చేయండి.
• లైబ్రరీ టైప్స్ చుట్టూ మీ స్వంత చిన్న ర్యాపర్‌ను ఉంచండి, తద్వారా పేరు మార్పు జరిగితే నలభై ఫైళ్లలో కాకుండా ఒకే ఫైల్‌లో సరిచేయవచ్చు.
• అది ఉత్పత్తి చేసిన సంఖ్యల పక్కన లైబ్రరీ వెర్షన్‌ను రికార్డ్ చేయండి, తద్వారా ఫలితాలు మారితే అది మార్కెట్ వల్లనా లేదా అప్‌గ్రేడ్ వల్లనా అనేది తెలుస్తుంది.
• ప్రొడక్షన్ మార్జిన్, కొలేటరల్ మరియు రెగ్యులేటరీ రిస్క్ నంబర్లను 1.0 వెర్షన్ వచ్చే వరకు అనుకూలత హామీ ఉన్న వాటిపైనే ఉంచండి.

ఇది ప్రాజెక్ట్‌ను విమర్శించడం కాదు. Pre-1.0 అనేది ఖచ్చితమైన స్వీయ-వివరణ మరియు చాలా పెద్ద లైబ్రరీ యొక్క కొత్త పోర్ట్‌కు ఇది సరైన స్థానం. ఒక రీడర్ దీనిని QuantLibకి ప్రత్యామ్నాయంగా భావించి, మైనర్ రిలీజ్‌లో సిగ్నేచర్ మారినప్పుడు ఇబ్బంది పడటం వైఫల్యానికి దారితీస్తుంది. ఇన్‌స్టాలేషన్ సూచనలు కూడా వెర్షన్‌తో పాటు మారుతుంటాయి, కాబట్టి మీరు పిన్ చేయాలనుకుంటున్న ట్యాగ్ వద్ద ప్రాజెక్ట్ యొక్క READMEని చదవండి.

Python, కంపైల్డ్ ఇంజిన్, లేదా Rust?

రెండు ప్రశ్నలు దీనిని నిర్ణయిస్తాయి, అవి అభిరుచికి సంబంధించినవి కావు. మీరు సెకనుకు ఎన్నిసార్లు రీప్రైస్ చేస్తారు, మరియు వేర్వేరు ప్రాసెస్లలో మీ నంబర్లు సరిపోలాలా? చైన్ సైజు మొదటి ప్రశ్నకు స్కేల్‌ను నిర్ణయిస్తుంది.

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గా ఉంది. పెద్ద చైన్‌ను ఒకసారి ప్రైసింగ్ చేయడం పెద్ద విషయం కాదు. ప్రతి కోట్ అప్‌డేట్‌పై, ప్రతి కాంట్రాక్టుకు ఐదు సెన్సిటివిటీలతో, అండర్లయింగ్ బుక్ అంతటా ప్రైసింగ్ చేయడం అనేది వేర్వేరు పరిమితులతో కూడిన వేరే ప్రోగ్రామ్.

లూప్ నిమిషానికి వేలకొద్దీ వాల్యుయేషన్ల వద్ద ఉండి, మిగిలిన పని పరిశోధన, విశ్లేషణ లేదా ఎండ్-ఆఫ్-డే మార్క్స్ అయితే Pythonలోనే ఉండండి. QuantLib యొక్క Python బైండింగ్స్ పరిణతి చెందిన ఎంపిక: అదే C++ ఇంజిన్, విస్తృతమైన ఇన్‌స్ట్రుమెంట్ కవరేజ్ మరియు సంవత్సరాల ప్రొడక్షన్ అనుభవం. పరిశోధన కోడ్‌లో వేగం కంటే కవరేజ్ మరియు ఖచ్చితత్వం ముఖ్యం.

లూప్ వేగంగా ఉండి, దాని చుట్టూ ఉన్న కోడ్ నెమ్మదిగా ఉన్నప్పుడు Python నుండి కంపైల్డ్ ఇంజిన్‌ను పిలవండి. ప్రతి కాంట్రాక్ట్ కాల్ Python నుండి ఓవర్‌హెడ్‌ను పెంచుతుంది, దీనికి పరిష్కారం ఇంజిన్‌కు ఒక అర్రేని ఇచ్చి, తిరిగి అర్రేని తీసుకోవడం. itofin ఈ విభాగంలోనే QuantLib-Pythonతో పాటు పోటీ పడుతోంది.

ప్రైసింగ్ లూప్ మీ ఉత్పత్తిలో భాగంగా ఉన్నప్పుడు Rust రాయండి: కోటింగ్ సర్వీస్‌లో ప్రైసర్, మీరు మిస్ అవ్వకూడని షెడ్యూల్‌లో రిస్క్ రన్, లేదా Python లేని బాక్స్‌లో రన్ అయ్యే బైనరీ. రెండవ ప్రశ్న కూడా ఇక్కడే వర్తిస్తుంది. ఫ్లోటింగ్ పాయింట్ ఫలితాలు ఆపరేషన్ల క్రమంపై ఆధారపడి ఉంటాయి, కాబట్టి ఒకే మోడల్‌ను రెండుసార్లు అమలు చేస్తే చివరి అంకెలలో తేడా రావచ్చు. ఒకే ఇంజిన్‌ను రెండు వైపులా ఉపయోగించడం వల్ల ఈ వ్యత్యాసాలు తొలగిపోతాయి, కంపైల్డ్ కోర్ కోసం ఇది బలమైన వాదన. ఇదే సూత్రం స్ట్రాటజీ పనికి కూడా వర్తిస్తుంది, పునరుత్పత్తి చేయగల బ్యాక్‌టెస్ట్ దీనిని చూపుతుంది.

క్యాలిబ్రేషన్ టార్గెట్ ఎక్కడ ఉంటుంది

క్యాలిబ్రేషన్‌కు ఫిట్ చేయడానికి ఏదో ఒకటి అవసరం, అది మార్కెట్-ఇంప్లైడ్ వోలటాలిటీల సర్ఫేస్. రూట్-ఫైండింగ్ వైపు ఇంప్లైడ్ వోలటాలిటీ ఎలా లెక్కించబడుతుందిలో కవర్ చేయబడింది. కింద ఉన్న ఆకారం మోడల్ సరిపోల్చాల్సినది.

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)

మనీకి దగ్గరగా, 0 to 7 days బకెట్‌లోని AAPL కాంట్రాక్టులు చూస్తున్న సెషన్లలో సగటున 29.6% ఇంప్లైడ్ వోలటాలిటీని కలిగి ఉన్నాయి, 241 days or more వద్ద 29.3%తో పోలిస్తే. ఒక వోలటాలిటీ పారామీటర్‌ను కలిగి ఉన్న మోడల్ రెండు పాయింట్ల వద్ద ఒకేసారి ఉండలేదు, అందుకే వోలటాలిటీ టర్మ్ స్ట్రక్చర్ ఉన్న మోడళ్లు అవసరం. ఇలాంటి సర్ఫేస్‌కు ఫిట్ చేయడం క్యాలిబ్రేషన్ దశ, మరియు ఫిట్ చేసిన మోడల్ నుండి వచ్చే సెన్సిటివిటీలే గ్రీక్స్, ఇవి ఆప్షన్ గ్రీక్స్ వివరణలో కవర్ చేయబడ్డాయి.

FAQ

libitofin అనేది QuantLibకి ప్రత్యామ్నాయమా?

కాదు. ఆగస్టు 2026 నాటికి ఇది 1.0 కంటే ముందు దశలో ఉన్న పోర్ట్, ఇది QuantLib యొక్క కొంత భాగాన్ని మాత్రమే కవర్ చేస్తుంది మరియు దాని ఫలితాలను QuantLib టెస్ట్ సూట్‌తో ధృవీకరిస్తుంది. ప్రొడక్షన్ పని కోసం QuantLib యొక్క Python బైండింగ్స్ మరింత విస్తృతమైన మరియు స్థిరమైన ఎంపిక.

ప్రైసింగ్ లైబ్రరీకి pre-1.0 అంటే ఏమిటి?

Rust వెర్షనింగ్ కన్వెన్షన్ ప్రకారం, 0.x రిలీజ్ అనుకూలతకు హామీ ఇవ్వదు: తదుపరి మైనర్ వెర్షన్‌లో ఏదైనా పేరు మార్చవచ్చు లేదా తొలగించవచ్చు. ఆచరణలో దీని అర్థం ఖచ్చితమైన ట్యాగ్ చేయబడిన రిలీజ్‌ను పిన్ చేయడం మరియు ప్రతి అప్‌గ్రేడ్‌లో మీ స్వంత టెస్ట్ సూట్‌ను రన్ చేయడం.

libitofin ఉపయోగించడానికి నేను Rust రాయాలా?

లేదు. ఈ ప్రాజెక్ట్ itofin అనే Python ప్యాకేజీని ప్రచురిస్తుంది, కాబట్టి ఇంజిన్‌ను సాధారణ Python ప్రాసెస్ నుండి పిలవవచ్చు. ప్రైసింగ్ లూప్ మీ ఉత్పత్తిలో భాగంగా ఉన్నప్పుడు మాత్రమే Rust రాయడం అవసరం.

స్ప్రెడ్‌షీట్ ఫార్ములా ఇవ్వలేని ప్రయోజనాలు ఏమిటి?

సింగిల్ రేట్లకు బదులుగా కర్వ్స్, అసలైన ఎక్స్ఛేంజ్ క్యాలెండర్లతో కూడిన డే-కౌంట్ కన్వెన్షన్స్, కోట్ చేసిన ధరలకు మోడల్ పారామితులను ఫిట్ చేసే క్యాలిబ్రేషన్ లూప్ మరియు వీటన్నింటికీ అడుగున పరీక్షించబడిన న్యూమరిక్స్ లేయర్. క్లోజ్డ్-ఫార్మ్ ఫార్ములా అనేది పనిలో చిన్న భాగం మాత్రమే.

ప్రోగ్రామింగ్ భాష ఆప్షన్ ధరను మారుస్తుందా?

గణితపరంగా కాదు. ఇది పునరుత్పత్తిని (reproducibility) మారుస్తుంది: ఫ్లోటింగ్ పాయింట్ ఫలితాలు ఆపరేషన్ల క్రమంపై ఆధారపడి ఉంటాయి, కాబట్టి ఒకే మోడల్ యొక్క రెండు ఇంప్లిమెంటేషన్లు చివరి అంకెలలో తేడా చూపవచ్చు. పరిశోధన మరియు ప్రొడక్షన్‌ను ఒకే ఇంజిన్‌తో రన్ చేయడం వల్ల ఆ వ్యత్యాసం తొలగిపోతుంది.