วิธีคำนวณ Implied volatility ด้วยการทำซ้ำ

การคำนวณ Implied volatility

Implied volatility คำนวณโดยใช้วิธีการทำซ้ำ (iteration) ไม่ใช่การใช้สูตรสำเร็จรูป เนื่องจากไม่มีสมการรูปแบบปิด (closed-form expression) ที่สามารถแปลงราคาตลาดของ option กลับมาเป็นค่าความผันผวนได้โดยตรง ดังนั้นโปรแกรมคำนวณจึงใช้วิธีการคาดเดาค่าความผันผวนขึ้นมาก่อน จากนั้นนำไปคำนวณหาราคา option ด้วยแบบจำลอง Black-Scholes แล้วนำราคาที่ได้จากแบบจำลองไปเปรียบเทียบกับราคาเสนอซื้อขายจริงในตลาด จากนั้นจึงทำซ้ำกระบวนการดังกล่าวจนกว่าราคาจากแบบจำลองและราคาตลาดจะตรงกันจนถึงระดับทศนิยมหลักสุดท้าย ต่อไปนี้คือวิธีการทั้งหมดที่ใช้ ได้แก่ ฟังก์ชันการตั้งราคา, ลูปการค้นหาในไลบรารีมาตรฐานของ Python และเหตุผลที่ผู้ให้บริการข้อมูลสองแห่งอาจเผยแพร่ตัวเลขที่แตกต่างกันสำหรับสัญญาเดียวกัน

ดูรายละเอียดเพิ่มเติมเกี่ยวกับแบบจำลองราคา

เหตุใด Implied volatility จึงไม่มีสูตรคำนวณแบบปิด

แบบจำลอง Black-Scholes ทำงานในทิศทางเดียว หากระบุราคา Spot, Strike price, ระยะเวลาจนถึงวันหมดอายุ, อัตราดอกเบี้ย และค่าความผันผวน (Volatility) แบบจำลองจะคำนวณราคาตามทฤษฎีออกมาให้ ในหกตัวแปรนี้ มีห้าตัวแปรที่สังเกตได้จริง แต่ค่าความผันผวนนั้นไม่ใช่ มันเป็นเพียงสมมติฐานเกี่ยวกับระยะการเคลื่อนที่ของหุ้นจากปัจจุบันจนถึงวันหมดอายุ

เทรดเดอร์ใช้วิธีแก้ปัญหาแบบย้อนกลับ ในเมื่อราคาปรากฏอยู่บนหน้าจอแล้ว ค่าความผันผวนจึงกลายเป็นตัวแปรที่ไม่ทราบค่า Implied volatility คือค่าความผันผวนที่ใส่เข้าไปเพื่อให้ราคาตามแบบจำลอง Black-Scholes เท่ากับราคาตลาดของ Option นั้น ตัวแปร Sigma ซึ่งเป็นค่าความผันผวน ปรากฏอยู่ในฟังก์ชันการแจกแจงแบบปกติถึงสองตำแหน่ง ทั้งใน d1 และ d2 ซึ่งไม่มีการจัดรูปสมการใดที่จะแยกตัวแปรนี้ออกมาได้โดยลำพัง พีชคณิตจึงทำได้เพียงเท่านี้ และต้องใช้การคำนวณเชิงตัวเลขเข้ามาแทนที่ สิ่งที่ Implied volatility วัดค่า ครอบคลุมถึงการตีความ ส่วนหน้านี้จะอธิบายถึงกลไกการทำงาน

คุณสมบัติสองประการของแบบจำลองทำให้การค้นหาค่านี้ทำได้ง่าย ราคาตามแบบจำลองของ Call option จะปรับตัวสูงขึ้นเสมอเมื่อค่าความผันผวนเพิ่มขึ้นโดยไม่มีข้อยกเว้น และเป็นการเคลื่อนไหวที่ราบรื่น ปริมาณที่มีแต่ทิศทางขาขึ้นเช่นนี้สามารถหาค่าที่แท้จริงได้โดยการบีบกรอบช่วงของค่าตัวแปรให้แคบลงเรื่อย ๆ

ตัวแก้สมการทำงานหนึ่งครั้งต่อหนึ่งสัญญา

ผลลัพธ์ที่ได้คือหนึ่งตัวเลขต่อหนึ่งสัญญา ไม่ใช่หนึ่งตัวเลขต่อหนึ่งหุ้น และสัญญาที่อ้างอิงหุ้นตัวเดียวกันในกรอบเวลาหมดอายุเดียวกันอาจให้ค่าที่ไม่ตรงกัน ตัวอย่างเช่น ออปชันของ Apple (AAPL) ทุกตัวที่มีอายุคงเหลือยี่สิบถึงสี่สิบห้าวันซึ่งมีการซื้อขายในวันที่ 30 มิถุนายน 2026 โดยจัดกลุ่มตามราคาใช้สิทธิ (strike) ในสัดส่วนเทียบกับราคาหุ้น:

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)

เมื่อไล่ระดับราคาใช้สิทธิขึ้นไป โซน 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 คือ strike price, T คือระยะเวลาจนถึงวันหมดอายุในหน่วยปี, r คืออัตราผลตอบแทนที่ปราศจากความเสี่ยง และ N() คือฟังก์ชันการแจกแจงสะสมปกติมาตรฐาน ซึ่งหมายถึงความน่าจะเป็นที่ค่าจากการสุ่มแบบปกติมาตรฐานจะมีค่าน้อยกว่าจุดที่กำหนด Python มีฟังก์ชันส่วนสุดท้ายนี้อยู่ใน math.erf ดังนั้นตัว Interpreter เพียงอย่างเดียวก็เพียงพอแล้ว

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

ใส่คำนำหน้าคำสั่งทั้งสองด้วย sudo บนเครื่องที่คุณไม่ได้ใช้งานในฐานะ root จากนั้นบันทึกไฟล์นี้เป็น 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)

นั่นคือแบบจำลองไปข้างหน้า (forward model) ทั้งหมด เพียงแค่ป้อนค่าความผันผวน (volatility) เข้าไป ก็จะได้ราคาออกมา

วิธีการคำนวณ Implied volatility ทีละขั้นตอน

Bisection เป็นวิธีแรกที่ควรเรียนรู้ วิธีนี้ไม่มีทางล้มเหลว (diverge) และไม่จำเป็นต้องใช้แคลคูลัส

1. กำหนดขอบเขตของคำตอบไว้ระหว่าง 0.01 (ร้อยละ 1 ต่อปี) และ 5.0 (ร้อยละ 500) ออปชันทุกตัวที่มีการซื้อขายจะอยู่ในช่วงนี้
2. คำนวณราคาออปชันที่จุดกึ่งกลางของขอบเขตที่กำหนด
3. หากราคาจากแบบจำลองสูงกว่าราคาตลาด แสดงว่าค่าที่คาดการณ์ไว้สูงเกินไป ให้เลื่อนขอบเขตบนลงมาที่จุดกึ่งกลาง หากราคาต่ำกว่า ให้เลื่อนขอบเขตล่างขึ้นไป
4. หยุดคำนวณเมื่อราคาจากแบบจำลองอยู่ในระดับที่ใกล้เคียงกับราคาตลาดไม่เกินหนึ่งเซนต์

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 ดอลลาร์, Strike price 100 ดอลลาร์, ระยะเวลาสามเดือน, อัตราดอกเบี้ยร้อยละ 4, ราคาบนหน้าจอ 5.00 ดอลลาร์
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

รัน python3 iv.py ผลลัพธ์ที่ได้คือประมาณ 0.226 ซึ่งหมายถึง Implied volatility อยู่ที่ประมาณร้อยละ 22.6 ต่อปีสำหรับราคาอ้างอิงสมมตินี้ การคำนวณแต่ละรอบจะลดช่วงขอบเขตลงครึ่งหนึ่ง และช่วงความกว้าง 4.99 ที่ถูกหารครึ่งยี่สิบครั้งจะแคบกว่า 0.00001 ดังนั้นเพดานการคำนวณที่ 100 รอบจึงไม่เคยถูกใช้งานจนเต็มขีดจำกัด

เหตุผลที่ Newton-Raphson ลู่เข้าได้เร็วกว่า และจุดที่อัลกอริทึมล้มเหลว

วิธี Bisection ทิ้งข้อมูลที่โมเดลมีอยู่แล้วไปอย่างน่าเสียดาย Vega คือการเปลี่ยนแปลงของราคา option ต่อหนึ่งหน่วยความผันผวน (volatility) ซึ่งแบบจำลอง Black-Scholes สามารถคำนวณค่านี้ออกมาได้โดยตรงในรูปแบบ closed form วิธี 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

สำหรับ option ที่มีราคาใกล้เคียงกับราคาหุ้น (near the money) วิธีนี้จะหาคำตอบได้ภายในสามถึงสี่รอบ ในขณะที่วิธี bisection ต้องใช้ถึงสิบกว่ารอบ จุดอ่อนของวิธีนี้อยู่ที่ตัวหาร เนื่องจากค่า Vega จะลดลงเมื่อราคาใช้สิทธิ (strike price) ห่างจากราคาหุ้นออกไปเรื่อย ๆ ลองพิจารณาสัญญาของ AAPL โดยแสดงค่า Vega เฉลี่ยในแต่ละโซนเป็นเปอร์เซ็นต์เทียบกับค่าที่ระดับ at the money:

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)

บริเวณปีกของกราฟ (wings) จะมีความไวต่อความผันผวนเพียงเศษเสี้ยวหนึ่งเท่านั้น กล่าวคือมีค่าเป็น 33.1% ของ Vega ที่ระดับ at the money ในโซน 0.80-0.90 และเป็น 31.6% ในโซน 1.10-1.20 การนำส่วนต่างของราคาไปหารด้วยตัวเลขที่น้อยมากเช่นนี้ จะทำให้เกิดการก้าว (step) ที่ใหญ่เกินไป ซึ่งอาจส่งผลให้ค่าประมาณการติดลบ ซึ่งเป็นจุดที่โมเดลไม่สามารถประมวลผลต่อได้ ระบบคำนวณในระดับใช้งานจริง (production solvers) จึงมักใช้วิธีผสมผสาน โดยเริ่มจากการกำหนดขอบเขต (bracketing) แล้วจึงใช้ Newton เข้ามาปรับค่าให้แม่นยำ Vega อธิบายรายละเอียดเกี่ยวกับค่า Greek ตัวนี้ไว้

เหตุใดสองแหล่งข้อมูลจึงรายงานค่า Implied Volatility ต่างกัน

แบบจำลองเป็นสาธารณะและหลักการคำนวณเป็นที่ยอมรับกันทั่วไป ดังนั้นความเห็นต่างจึงอยู่ที่ข้อมูลนำเข้า

• ราคา Mid เทียบกับราคาล่าสุด: ตัวแก้สมการ (solver) ต้องการราคาเพียงค่าเดียว สัญญาที่มีราคา Bid 2.00 ดอลลาร์ และราคา Offer 2.20 ดอลลาร์ จะมีราคา Mid อยู่ที่ 2.10 ดอลลาร์ ในขณะที่ราคาซื้อขายล่าสุด (last print) อาจอยู่ที่ 2.02 ดอลลาร์เมื่อเก้าสิบนาทีก่อน สำหรับสัญญาในลักษณะนี้ ราคาที่ต่างกันสิบเซนต์มีผลต่อค่าความผันผวนมากกว่าหนึ่งจุด
• เงินปันผลและต้นทุนการถือครอง (Carry): ฟังก์ชันข้างต้นใช้คำนวณราคา European call ของหุ้นที่ไม่มีการจ่ายเงินปันผล หากมีการจ่ายเงินปันผลก่อนวันหมดอายุ จะทำให้ราคาล่วงหน้า (forward price) ลดลง ซึ่งแต่ละ Trading desk จะใช้การปรับค่าและอัตราดอกเบี้ยของตนเอง
• การใช้สิทธิก่อนกำหนดของออปชันแบบอเมริกัน: ออปชันหุ้นรายตัวในสหรัฐฯ สามารถใช้สิทธิได้ทุกวัน ซึ่งสิทธินี้มีมูลค่าที่สูตรแบบยุโรปไม่สามารถคำนวณได้ ตัวแก้สมการที่ละเลยปัจจัยนี้จะผลักส่วนต่างไปรวมอยู่ในค่าความผันผวน ในขณะที่แบบจำลอง Binomial tree จะคำนวณมูลค่าสิทธิการใช้สิทธิโดยตรง
• ราคาเสนอซื้อขายที่ไม่อัปเดต (Stale quotes): Strike price ที่มีการซื้อขายล่าสุดเมื่อวันอังคารยังคงแสดงราคาเสนอซื้อขายอยู่ และตัวแก้สมการจะถือว่าราคาที่ได้รับมานั้นเป็นความจริง

การลู่เข้าของข้อมูล (convergence) ทำให้เห็นปัจจัยสองประการหลังได้ชัดเจน ตารางด้านล่างแสดงหุ้นชื่อดังแปดตัว ณ วันที่ มิถุนายน 2026 โดยนับจำนวนสัญญาที่มีการซื้อขายและมีอายุคงเหลือ 20 ถึง 45 วัน พร้อมรายงานทั้งค่าความผันผวนที่ระดับ At the money และสัดส่วนของสัญญาที่ตัวแก้สมการสามารถหาคำตอบได้

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

TSLA มีค่าความผันผวนที่ระดับ At the money สูงที่สุดในบรรดาหุ้น 8 ตัว โดยอยู่ที่ 47.7% เทียบกับ 14.4% สำหรับ SPY ซึ่งอยู่ในอันดับต่ำสุด ในส่วนของกระดาน TSLA นั้น 97.8% ของสัญญาที่มีการซื้อขายสามารถหาคำตอบที่ลู่เข้าได้ ส่วนที่เหลือคือ Strike price ที่ราคาซึ่งส่งให้ตัวแก้สมการอยู่นอกเหนือช่วงที่ค่าความผันผวนใด ๆ จะคำนวณได้ เช่น ราคาที่ต่ำกว่ามูลค่าที่แท้จริง (intrinsic value) หรือสภาวะตลาดที่ราคาเสนอซื้อสูงกว่าราคาเสนอขาย (crossed market) ส่วนตัวเลขดังกล่าวจะถือว่าสูงหรือไม่นั้นเป็นอีกประเด็นหนึ่ง โดย ค่า IV ที่ 30% ถือว่าสูงหรือไม่ จะอธิบายในรายละเอียด และ การเคลื่อนไหวที่คาดการณ์ จะแปลงค่าดังกล่าวเป็นช่วงราคาในหน่วยดอลลาร์

สัญญาฉบับเดียวกันที่คำนวณใหม่ทุกรอบการซื้อขาย

ไม่มีการจัดเก็บข้อมูลเกี่ยวกับ implied volatility แต่อย่างใด ค่าดังกล่าวจะถูกคำนวณใหม่จากราคาที่ปรากฏบนหน้าจอเสมอ ด้านล่างนี้คือสัญญา AAPL ที่มีการซื้อขายหนาแน่นที่สุดซึ่งจะหมดอายุในวันที่ 17 มิถุนายน 2026 โดยติดตามข้อมูลตั้งแต่วันที่ 1 มิถุนายน จนถึงวันหมดอายุ โดยที่ strike price และวันหมดอายุไม่มีการเปลี่ยนแปลงแต่อย่างใด

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

ตลอดระยะเวลา 29 รอบการซื้อขาย ค่าที่คำนวณได้เริ่มต้นที่ 25.1% โดยมีเวลาคงเหลือ 46 วัน และสิ้นสุดที่ 26.6% โดยมีเวลาคงเหลือ 4 วัน ทุกจุดบนเส้นกราฟดังกล่าวคือผลลัพธ์จากการประมวลผลตามขั้นตอนข้างต้นเทียบกับราคาเสนอซื้อขายของรอบนั้นๆ หน้าข้อมูลราย ticker ของเราได้เผยแพร่ผลการคำนวณในลักษณะเดียวกันนี้ไว้ โดย AAPL implied volatility จะแสดงผลการคำนวณรายวันสำหรับสัญญาตลอดทั้ง chain เพื่อให้ผู้อ่านสามารถตรวจสอบความถูกต้องของตัวเลขแต่ละค่าได้ด้วยตนเองโดยใช้โค้ดในหน้านี้

คำถามที่พบบ่อยเกี่ยวกับการคำนวณ Implied volatility

มีสูตรสำหรับคำนวณ Implied volatility หรือไม่

ไม่มี แบบจำลอง Black-Scholes ใช้สำหรับแปลงค่าความผันผวนให้เป็นราคา แต่การแปลงกลับไม่มีสูตรสำเร็จรูป เนื่องจากค่า sigma ปรากฏอยู่ในฟังก์ชันการแจกแจงปกติถึงสองตำแหน่ง ค่า Implied volatility ทุกค่าที่คุณพบ ไม่ว่าจะที่นี่หรือที่ใดก็ตาม ล้วนได้มาจากการใช้ตัวแก้สมการแบบวนซ้ำ (iterative solver) ทั้งสิ้น

การคำนวณต้องใช้การวนซ้ำกี่รอบ

การคำนวณแบบ bisection แต่ละรอบจะลดช่วงของค่าลงครึ่งหนึ่ง ดังนั้นช่วงตั้งแต่ 0.01 ถึง 5.0 จะลดลงเหลือต่ำกว่า 0.00001 ในยี่สิบรอบ และการจับคู่ราคาเสนอซื้อขายให้ใกล้เคียงระดับเซนต์มักใช้เวลาประมาณสิบสองรอบ ส่วนวิธี Newton-Raphson สามารถหาค่าได้ในสามหรือสี่รอบหากราคาอยู่ใกล้ราคาใช้สิทธิ (near the money) แต่มีข้อเสียคือขั้นตอนการคำนวณอาจมีความผิดพลาดในจุดที่ค่า vega มีขนาดเล็ก

เหตุใดโบรกเกอร์และผู้ให้บริการข้อมูลจึงแสดงค่า Implied volatility ไม่เท่ากัน

พวกเขาป้อนข้อมูลนำเข้า (inputs) ให้กับตัวแก้สมการต่างกัน ความแตกต่างที่พบบ่อยคือการใช้ราคาเฉลี่ย (mid quote) เทียบกับราคาซื้อขายล่าสุด (last trade) การสมมติอัตราดอกเบี้ยและเงินปันผล รวมถึงการที่แบบจำลองรองรับการใช้สิทธิก่อนกำหนด (American early exercise) หรือไม่ ในกรณีของราคาใช้สิทธิที่มีสภาพคล่องต่ำ (thin strike) เพียงแค่ราคาเสนอที่ไม่อัปเดตก็อาจทำให้ค่าที่ได้คลาดเคลื่อนไปหลายจุด

Call option และ Put option ที่ราคาใช้สิทธิเดียวกันให้ค่า Implied volatility เท่ากันหรือไม่

ในทางทฤษฎีคือเท่ากัน เนื่องจาก Put-call parity เชื่อมโยงทั้งสองฝั่งเข้าด้วยกันที่ราคาใช้สิทธิและวันหมดอายุเดียวกัน แต่ในทางปฏิบัติ ราคาเสนอซื้อขายทั้งสองฝั่งถูกกำหนดแยกจากกัน ทำให้ค่าที่คำนวณได้แตกต่างกันเล็กน้อย ซึ่งเป็นอีกหนึ่งเหตุผลที่ค่าเฉลี่ยของทั้งกระดานมีความแตกต่างกันไปในแต่ละผู้ให้บริการ

ฉันสามารถคำนวณ Implied volatility โดยไม่มีข้อมูลตลาดได้หรือไม่

ได้ สำหรับราคาเสนอสมมติ โค้ดด้านบนรับค่าราคา ราคาใช้สิทธิ ราคาตลาดปัจจุบัน (spot) ระยะเวลาจนถึงวันหมดอายุ และอัตราดอกเบี้ย ซึ่งทั้งหมดสามารถพิมพ์ด้วยตนเองได้ ส่วนที่ยากกว่าคือการทำให้ได้ค่าที่ตรงกับตัวเลขของผู้ให้บริการข้อมูล ซึ่งต้องใช้ข้อมูลนำเข้าชุดเดียวกับที่ผู้ให้บริการรายนั้นใช้

ทุกแผงข้อมูลที่นี่จัดเก็บคำสั่ง SQL ที่อยู่เบื้องหลังไว้ คุณสามารถเปิดแผงข้อมูลและรันการคำนวณเดียวกันกับข้อมูลราคาแบบเรียลไทม์บนเทอร์มินัล Strasmore ได้