Strasmore Research
सीखें Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-08-05

Implied Volatility की गणना कैसे की जाती है

Implied Volatility का कोई सीधा फॉर्मूला नहीं है। जानें कि कैसे एक सॉल्वर इटरेशन के जरिए ऑप्शन प्राइस से इसे निकालता है, इसके लिए Python कोड क्या है और इसमें क्या जोखिम हैं।

1.10-1.20
Implied volatility की गणना किसी फॉर्मूले से नहीं, बल्कि iteration (पुनरावृत्ति) के जरिए की जाती है। किसी option की बाजार कीमत को वापस volatility संख्या में बदलने के लिए कोई closed-form expression मौजूद नहीं है। इसलिए, एक solver पहले एक volatility का अनुमान लगाता है, फिर Black-Scholes मॉडल का उपयोग करके option की कीमत निर्धारित करता है। इसके बाद, वह इस मॉडल कीमत की तुलना बाजार के quote से करता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि दोनों कीमतें पैसे (penny) तक समान न हो जाएं। नीचे पूरी विधि दी गई है: pricing function, standard library Python में search loop, और वे कारण जिनकी वजह से दो वेंडर एक ही contract के लिए अलग-अलग आंकड़े प्रकाशित करते हैं।

Implied volatility की गणना की प्रक्रिया

Implied volatility का अर्थ है बाजार द्वारा भविष्य की अस्थिरता का अनुमान। चूंकि Black-Scholes मॉडल में volatility एक इनपुट है, इसलिए हमें इसे उलटी प्रक्रिया (reverse engineering) से निकालना पड़ता है। Solver एक अनुमानित volatility से शुरुआत करता है और उसे मॉडल में डालता है। यदि मॉडल की कीमत बाजार की कीमत से कम है, तो solver volatility को बढ़ा देता है। यदि मॉडल की कीमत अधिक है, तो वह इसे घटा देता है। यह प्रक्रिया तब तक चलती है जब तक मॉडल की कीमत और बाजार का quote एक-दूसरे के करीब नहीं आ जाते।

Python में solver का कार्यान्वयन

Python में, हम math लाइब्रेरी का उपयोग करके एक साधारण bisection method या Newton-Raphson विधि का उपयोग कर सकते हैं। यह लूप तब तक चलता है जब तक कि error tolerance एक निश्चित सीमा से कम न हो जाए। यह ध्यान रखना महत्वपूर्ण है कि यदि बाजार में option का volume कम (thinly traded) है, तो bid-ask spread बहुत चौड़ा हो सकता है, जिससे implied volatility का सटीक अनुमान लगाना कठिन हो जाता है।

वेंडरों के बीच आंकड़ों में अंतर के कारण

अलग-अलग डेटा वेंडर एक ही contract के लिए अलग-अलग implied volatility क्यों दिखाते हैं, इसके मुख्य कारण निम्नलिखित हैं:

  • Pricing model में अंतर: कुछ वेंडर Black-Scholes का उपयोग करते हैं, जबकि अन्य अधिक जटिल मॉडलों का उपयोग करते हैं जो लाभांश (dividends) या ब्याज दरों में बदलाव को बेहतर ढंग से समायोजित करते हैं।
  • Input data का स्रोत: अलग-अलग वेंडर अलग-अलग exchanges या consolidated feeds से डेटा लेते हैं।
  • Interpolation तकनीक: यदि किसी विशेष strike price के लिए quote उपलब्ध नहीं है, तो वेंडर volatility surface का उपयोग करके अनुमान लगाते हैं। हर वेंडर की interpolation विधि अलग हो सकती है।
  • समय का अंतर: डेटा को प्रोसेस करने और अपडेट करने की गति में मामूली अंतर भी अंतिम परिणाम को प्रभावित कर सकता है।

Implied volatility का कोई क्लोज्ड-फॉर्म फॉर्मूला क्यों नहीं है

Black-Scholes मॉडल एक ही दिशा में काम करता है। यदि आप इसमें स्पॉट प्राइस, स्ट्राइक प्राइस, एक्सपायरी तक का समय, ब्याज दर और वोलैटिलिटी डालते हैं, तो यह एक सैद्धांतिक कीमत (theoretical price) देता है। इन छह में से पांच राशियाँ देखी जा सकती हैं। वोलैटिलिटी ऐसी नहीं है। यह इस बात की एक धारणा है कि स्टॉक आज से एक्सपायरी के बीच कितनी दूरी तय करेगा।

ट्रेडर इस समस्या को उल्टा हल करते हैं। कीमत स्क्रीन पर दिख रही होती है और वोलैटिलिटी अज्ञात होती है। Implied volatility वह वोलैटिलिटी इनपुट है जो Black-Scholes की कीमत को option की बाजार कीमत के बराबर बना देता है। सिग्मा, यानी वोलैटिलिटी टर्म, नॉर्मल डिस्ट्रीब्यूशन फंक्शन के अंदर दो बार आता है, d1 और d2 दोनों में, और इसे अलग करने के लिए कोई भी पुनर्व्यवस्था (rearrangement) काम नहीं करती। बीजगणित यहाँ रुक जाता है। इसके बाद न्यूमेरिकल सर्च का उपयोग किया जाता है। Implied volatility क्या मापता है में इसकी व्याख्या दी गई है; यह पेज इसकी कार्यप्रणाली को कवर करता है।

मॉडल के दो गुण इस खोज को आसान बनाते हैं। एक call option की मॉडल कीमत वोलैटिलिटी बढ़ने पर हमेशा बढ़ती है, बिना किसी अपवाद के, और यह सुचारू रूप से चलती है। एक ऐसी राशि जो केवल ऊपर जाती है, उसे एक ब्रैकेट के भीतर रखकर आसानी से खोजा जा सकता है।

सॉल्वर प्रत्येक कॉन्ट्रैक्ट के लिए एक बार चलता है

आउटपुट प्रति स्टॉक नहीं, बल्कि प्रति कॉन्ट्रैक्ट एक संख्या है। एक ही स्टॉक पर समान एक्सपायरी विंडो वाले कॉन्ट्रैक्ट एक-दूसरे से भिन्न परिणाम देते हैं। 30 जून, 2026 को ट्रेड किए गए 20 से 45 दिनों की अवधि वाले सभी Apple (AAPL) ऑप्शंस, जिन्हें शेयर मूल्य के अनुपात में स्ट्राइक के आधार पर समूहीकृत किया गया है:

क्वेरीप्रति अनुबंध एक समाधान: स्ट्राइक ज़ोन के अनुसार AAPL निहित अस्थिरता, 30 जून, 2026
हर आंकड़े के पीछे का पूरा SQL
WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)
Run this yourself

स्ट्राइक लैडर पर ऊपर की ओर बढ़ने पर, 0.80-0.90 ज़ोन का समाधान 35.5% निकला, 0.95-1.00 ज़ोन का 28.1%, और 1.10-1.20 ज़ोन का 27.3%। एक कंपनी, एक सत्र, 6 उत्तर। उस कर्व में आए झुकाव का एक नाम है, volatility skew, और प्रति स्टॉक एक एकल वोलैटिलिटी इसे दर्शा नहीं सकती।

Black-Scholes मूल्य जिसे सॉल्वर को मैच करना है

S शेयर की कीमत है, K स्ट्राइक प्राइस है, T वर्षों में समाप्ति तक का समय है, r जोखिम-मुक्त दर है, और N() मानक सामान्य संचयी वितरण (standard normal cumulative distribution) है, जिसका अर्थ है वह प्रायिकता कि एक मानक सामान्य ड्रा एक निश्चित बिंदु से नीचे आता है। पायथन इस अंतिम हिस्से को math.erf में ले जाता है, इसलिए केवल इंटरप्रेटर ही पर्याप्त है।

apt-get update && apt-get install -y python3

ऐसी मशीन पर जहाँ आप रूट नहीं हैं, दोनों कमांड के आगे sudo लगाएँ। फिर इसे iv.py के रूप में सहेजें:

import math

def norm_cdf(x):
 return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs_call(S, K, T, r, sigma):
 if T <= 0.0 or sigma <= 0.0:
 return max(S - K, 0.0)
 d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
 d2 = d1 - sigma * math.sqrt(T)
 return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)

यह पूर्ण फॉरवर्ड मॉडल है। इसमें वोलैटिलिटी डालें और मूल्य प्राप्त करें।

Implied volatility की गणना चरण-दर-चरण कैसे की जाती है

Bisection वह विधि है जिसे सबसे पहले सीखना चाहिए। यह कभी भी diverge नहीं होती और इसमें calculus की आवश्यकता नहीं होती है।

  1. उत्तर को 0.01 (एक प्रतिशत प्रति वर्ष) और 5.0 (पांच सौ प्रतिशत) के बीच सीमित करें। हर traded option इसी दायरे में आता है।
  2. ब्रैकेट के मध्य बिंदु (midpoint) पर option की कीमत तय करें।
  3. यदि मॉडल की कीमत बाजार के quote से ऊपर है, तो अनुमान बहुत अधिक था: ब्रैकेट के ऊपरी हिस्से को नीचे लाकर मध्य बिंदु पर सेट करें। यदि यह नीचे है, तो निचले हिस्से को ऊपर ले जाएं।
  4. जब मॉडल की कीमत quote के एक सेंट के भीतर आ जाए, तो रुक जाएं।
def implied_vol(price, S, K, T, r, lo=0.01, hi=5.0, tol=0.01):
 for _ in range(100):
 mid = 0.5 * (lo + hi)
 diff = bs_call(S, K, T, r, mid) - price
 if abs(diff) < tol:
 return mid
 if diff > 0.0:
 hi = mid
 else:
 lo = mid
 return 0.5 * (lo + hi)

# $100 का शेयर, $100 का strike, तीन महीने, 4% दरें, स्क्रीन पर $5.00
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

python3 iv.py को रन करें। यह लगभग 0.226 प्रिंट करता है, जो उस काल्पनिक quote के लिए लगभग 22.6 प्रतिशत प्रति वर्ष की implied volatility है। प्रत्येक चरण ब्रैकेट को आधा कर देता है, और 4.99 चौड़े दायरे को बीस बार आधा करने पर वह 0.00001 से भी कम हो जाता है, इसलिए 100 iteration की सीमा कभी भी बाधा नहीं बनती।

Newton-Raphson तेजी से कन्वर्ज क्यों करता है, और यह कहां विफल होता है

Bisection उस जानकारी को छोड़ देता है जो मॉडल के पास पहले से मौजूद है। Vega अस्थिरता (volatility) की प्रति इकाई विकल्प की कीमत में बदलाव है, और Black-Scholes इसे क्लोज्ड फॉर्म में प्रदान करता है। Newton-Raphson इसे एक ढलान (slope) के रूप में देखता है: मूल्य निर्धारण त्रुटि (pricing error) को मापें, उसे vega से विभाजित करें, और अनुमान को उस मात्रा से आगे बढ़ाएं।

def bs_vega(S, K, T, r, sigma):
 d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
 return S * math.sqrt(T) * math.exp(-0.5 * d1 * d1) / math.sqrt(2.0 * math.pi)

def implied_vol_newton(price, S, K, T, r, sigma=0.5):
 for _ in range(20):
 v = bs_vega(S, K, T, r, sigma)
 if v < 1e-8:
 return None # कोई ढलान नहीं बची, कार्य को bisection को सौंपें
 step = (bs_call(S, K, T, r, sigma) - price) / v
 sigma -= step
 if sigma <= 0.0:
 return None # स्टेप ओवरशूट होकर निरर्थक हो गया
 if abs(step) < 1e-6:
 return sigma
 return None

At-the-money के करीब, यह bisection के दर्जन भर प्रयासों की तुलना में तीन या चार चरणों में परिणाम दे देता है। विफलता का कारण हर (denominator) में निहित है: जैसे-जैसे strike price शेयर की कीमत से दूर जाती है, vega कम होता जाता है। AAPL के वही कॉन्ट्रैक्ट्स, जिसमें प्रत्येक ज़ोन का औसत vega, at-the-money रीडिंग के प्रतिशत के रूप में दिखाया गया है:

क्वेरीजहाँ न्यूटन स्टेप त्रुटिपूर्ण है: स्ट्राइक ज़ोन के अनुसार AAPL वेगा, 30 जून, 2026
हर आंकड़े के पीछे का पूरा SQL
WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness,
     (
         SELECT avg(toFloat64(vega))
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND days_to_expiry BETWEEN 20 AND 45
           AND iv_converged = 1
           AND volume > 0
           AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
     ) AS atm_vega
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(vega)) / atm_vega, 1) AS vega_pct_of_atm,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)
Run this yourself

विंग्स (wings) में संवेदनशीलता का एक छोटा हिस्सा ही होता है: 33.1% ज़ोन में at-the-money vega का 0.80-0.90, और 1.10-1.20 ज़ोन में 31.6%। मूल्य निर्धारण त्रुटि को इतनी छोटी संख्या से विभाजित करने पर एक बहुत बड़ा स्टेप मिलता है, जो अनुमान को शून्य से नीचे ले जा सकता है, जहां मॉडल के पास बताने के लिए कुछ नहीं बचता। प्रोडक्शन सॉल्वर इन दोनों विधियों को जोड़ते हैं, पहले ब्रैकेटिंग का उपयोग करते हैं और फिर Newton के साथ उसे सटीक बनाते हैं। Vega स्वयं इस ग्रीक (greek) को कवर करता है।

दो स्रोत अलग-अलग implied volatility क्यों दिखाते हैं

मॉडल सार्वजनिक है और गणित तय है, इसलिए असहमति इनपुट में होती है।

  • Mid बनाम last। सॉल्वर को एक कीमत चाहिए। जिस कॉन्ट्रैक्ट की बोली $2.00 और ऑफर $2.20 है, उसका मिडपॉइंट $2.10 है, जबकि आखिरी प्रिंट नब्बे मिनट पहले $2.02 पर हो सकता है। ऐसे कॉन्ट्रैक्ट पर, दस सेंट की कीमत एक पॉइंट की volatility से अधिक मायने रखती है।
  • लाभांश और कैरी। ऊपर दिया गया फंक्शन बिना लाभांश वाले स्टॉक पर European call की कीमत तय करता है। समाप्ति से पहले का लाभांश forward price को कम कर देता है, और प्रत्येक ट्रेडिंग डेस्क अपना समायोजन और अपनी दर लागू करता है।
  • अमेरिकी early exercise। अमेरिकी सिंगल स्टॉक options को किसी भी दिन exercise किया जा सकता है, और इस अधिकार का मूल्य होता है जिसे European फॉर्मूला में कहीं नहीं रखा जा सकता। जो सॉल्वर इसे अनदेखा करता है, वह अंतर को volatility में डाल देता है। Binomial trees सीधे exercise अधिकार की कीमत तय करते हैं।
  • पुराने कोट्स। जिस strike पर आखिरी बार मंगलवार को ट्रेड हुआ था, वह अभी भी एक कोट दिखाता है, और सॉल्वर उसे ही सच मान लेता है जो उसे दिया जाता है।

कन्वर्जेंस (convergence) अंतिम दो बिंदुओं को स्पष्ट करता है। नीचे दी गई तालिका 30 जून, 2026 को आठ प्रसिद्ध कंपनियों को लेती है, 20 से 45 दिनों की शेष अवधि वाले ट्रेडेड कॉन्ट्रैक्ट्स की गणना करती है, और at the money volatility तथा उन कॉन्ट्रैक्ट्स का हिस्सा बताती है जहाँ सॉल्वर का परिणाम कन्वर्ज हुआ:

क्वेरीएट-द-मनी निहित अस्थिरता और सॉल्वर अभिसरण, आठ नाम, 30 जून, 2026
हर आंकड़े के पीछे का पूरा SQL
WITH abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS distance_from_spot
SELECT underlying_symbol AS symbol,
       round(100 * avgIf(toFloat64(implied_volatility), iv_converged = 1 AND distance_from_spot < 0.05), 1) AS atm_iv_pct,
       round(100 * countIf(iv_converged = 1) / count(), 1) AS solved_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE date = toDate('2026-06-30')
  AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMZN', 'TSLA', 'SPY', 'KO', 'JNJ')
  AND days_to_expiry BETWEEN 20 AND 45
  AND volume > 0
GROUP BY symbol
HAVING countIf(iv_converged = 1 AND distance_from_spot < 0.05) > 0
ORDER BY atm_iv_pct DESC
Run this yourself

TSLA ने 8 नामों में सबसे अधिक at the money रीडिंग 47.7% पर दर्ज की, जबकि सबसे नीचे SPY 14.4% पर रहा। TSLA चेन पर, ट्रेडेड कॉन्ट्रैक्ट्स में से 97.8% ने एक कन्वर्ज्ड उत्तर दिया। बाकी वे स्ट्राइक हैं जहाँ सॉल्वर को दी गई कीमत ऐसी है जिसे कोई भी volatility उत्पन्न नहीं कर सकती, जैसे कि intrinsic value से कम कोट या crossed market। क्या ऐसी संख्या को उच्च माना जाए, यह एक अलग प्रश्न है: क्या 30% IV उच्च है इस पर चर्चा करता है, और अपेक्षित चाल इसे डॉलर रेंज में बदल देती है।

वही अनुबंध, प्रत्येक सत्र में पुनः हल किया गया

Implied volatility के बारे में कुछ भी संग्रहीत नहीं किया जाता है। इसे स्क्रीन पर मौजूद किसी भी कीमत से पुनः गणना (recompute) किया जाता है। नीचे 17 जुलाई, 2026 को समाप्त होने वाला सबसे अधिक ट्रेड किया गया AAPL अनुबंध दिया गया है, जिसे 1 जून से समाप्ति तक ट्रैक किया गया है। स्ट्राइक प्राइस और समाप्ति तिथि में कोई बदलाव नहीं हुआ:

क्वेरीएक AAPL अनुबंध, प्रत्येक सत्र में 17 जुलाई, 2026 की समाप्ति तक पुन: समाधान
हर आंकड़े के पीछे का पूरा SQL
WITH (
         SELECT ticker
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND expiration_date = toDate('2026-07-17')
           AND iv_converged = 1
           AND volume > 0
         ORDER BY volume DESC
         LIMIT 1
     ) AS pinned_contract
SELECT date,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       round(avg(days_to_expiry)) AS days_to_expiry
FROM global_markets.options_greeks
WHERE ticker = pinned_contract
  AND date BETWEEN toDate('2026-06-01') AND toDate('2026-07-17')
  AND iv_converged = 1
  AND volume > 0
GROUP BY date
ORDER BY date
Run this yourself

29 सत्रों में, हल की गई रीडिंग 25.1% पर खुली, जिसमें 46 दिन शेष थे, और यह 26.6% पर समाप्त हुई, जिसमें 4 दिन बचे थे। उस लाइन का प्रत्येक बिंदु ऊपर दिए गए लूप का उस सत्र के कोट (quote) के विरुद्ध एक रन है। हमारे प्रति-टिकर पेज समान समाधान प्रकाशित करते हैं: AAPL implied volatility इसे पूरी चेन में दैनिक रूप से चलाता है, ताकि एक पाठक इस पेज पर दिए गए कोड के साथ वहां के किसी भी आंकड़े को पुनः उत्पन्न कर सके।

Implied volatility की गणना से जुड़े अक्सर पूछे जाने वाले प्रश्न

क्या implied volatility के लिए कोई फार्मूला है?

नहीं। Black-Scholes मॉडल volatility को price से जोड़ता है, और इस मैपिंग का कोई प्राथमिक व्युत्क्रम (inverse) नहीं है, क्योंकि sigma सामान्य वितरण (normal distribution) में दो बार आता है। आपको यहाँ या कहीं भी जो भी implied volatility संख्या मिलती है, वह एक iterative solver से निकलती है।

गणना में कितने iterations लगते हैं?

प्रत्येक bisection पास ब्रैकेट को आधा कर देता है, इसलिए 0.01 से 5.0 की रेंज बीस पास में 0.00001 से नीचे आ जाती है, और किसी quote को निकटतम सेंट तक मिलाने में आमतौर पर लगभग बारह पास लगते हैं। Newton-Raphson विधि money के करीब होने पर तीन या चार चरणों में परिणाम दे देती है, लेकिन इसकी कीमत उन चरणों के रूप में चुकानी पड़ती है जो vega के कम होने पर सही व्यवहार नहीं करते।

मेरे ब्रोकर और डेटा वेंडर अलग-अलग implied volatility क्यों दिखाते हैं?

उन्होंने solver को अलग-अलग इनपुट दिए हैं। सामान्य अंतर mid quote बनाम last trade, ब्याज दर और dividend की धारणा, और यह कि क्या मॉडल American early exercise को संभालता है या नहीं, के कारण होते हैं। एक thinly traded strike पर, केवल एक पुराना quote ही उत्तर को कई पॉइंट्स तक बदल सकता है।

क्या एक ही strike पर calls और puts समान implied volatility देते हैं?

सिद्धांत रूप में हाँ, put-call parity उन्हें एक साझा strike और expiry पर एक साथ जोड़ती है। व्यवहार में दोनों quotes स्वतंत्र रूप से सेट किए जाते हैं, और गणना की गई संख्याएं थोड़ी भिन्न होती हैं, जो वेंडरों के बीच chain-wide averages के अलग होने का एक और कारण है।

क्या मैं मार्केट डेटा के बिना implied volatility की गणना कर सकता हूँ?

हाँ, एक काल्पनिक quote के लिए। ऊपर दिया गया कोड एक price, एक strike, एक spot, expiry तक का समय और एक दर लेता है, जिन्हें हाथ से टाइप किया जाता है। किसी live vendor संख्या का मिलान करना कठिन हिस्सा है: इसके लिए उन्हीं इनपुट की आवश्यकता होती है जिनका उपयोग वेंडर ने किया है।

यहाँ प्रत्येक पैनल उसके पीछे का SQL स्टोर करता है। एक को खोलें, और फिर Strasmore टर्मिनल पर एक live chain के खिलाफ वही solve चलाएं।

#implied volatility#ऑप्शंस#black-scholes#python#how-to