call put option

Options คืออะไร

Options เป็นตราสารอนุพันธ์ (Derivatives) ที่ให้สิทธิ์ (แต่ไม่ใช่ข้อผูกมัด) ในการซื้อหรือขายสินทรัพย์อ้างอิง (Underlying Asset) เช่น หุ้น ดัชนี สินค้าโภคภัณฑ์ ที่ราคาที่กำหนดไว้ล่วงหน้า (Strike Price) ภายในระยะเวลาที่กำหนด (Expiration Date)

Options แบ่งเป็น 2 ประเภทหลัก คือ Call Option (สิทธิ์ในการซื้อ) และ Put Option (สิทธิ์ในการขาย) ผู้ซื้อ Option ต้องจ่ายค่า Premium ให้ผู้ขาย ซึ่งเป็นจำนวนเงินสูงสุดที่ผู้ซื้อจะขาดทุน ในขณะที่กำไรไม่จำกัดสำหรับ Call Option

Call Option vs Put Option

Script คำนวณ Option Payoff

# Python Script คำนวณ Option Payoff และ Greeks
import math
from scipy.stats import norm

class OptionCalculator:
    """คำนวณ Option Pricing, Payoff และ Greeks"""

    def __init__(self, spot, strike, days_to_expiry, risk_free_rate=0.02,
                 volatility=0.25):
        self.S = spot            # ราคาปัจจุบัน
        self.K = strike          # Strike Price
        self.T = days_to_expiry / 365  # เวลาถึง Expiry (ปี)
        self.r = risk_free_rate  # อัตราดอกเบี้ย
        self.sigma = volatility  # Implied Volatility

    def _d1(self):
        return (math.log(self.S / self.K) +
                (self.r + self.sigma**2 / 2) * self.T) / \
               (self.sigma * math.sqrt(self.T))

    def _d2(self):
        return self._d1() - self.sigma * math.sqrt(self.T)

    def call_price(self):
        """Black-Scholes Call Price"""
        d1, d2 = self._d1(), self._d2()
        return self.S * norm.cdf(d1) - \
               self.K * math.exp(-self.r * self.T) * norm.cdf(d2)

    def put_price(self):
        """Black-Scholes Put Price"""
        d1, d2 = self._d1(), self._d2()
        return self.K * math.exp(-self.r * self.T) * norm.cdf(-d2) - \
               self.S * norm.cdf(-d1)

    def call_payoff(self, price_at_expiry):
        """Call Option Payoff ที่ Expiry"""
        return max(price_at_expiry - self.K, 0)

    def put_payoff(self, price_at_expiry):
        """Put Option Payoff ที่ Expiry"""
        return max(self.K - price_at_expiry, 0)

    def delta(self, option_type="call"):
        """Delta — ความไวต่อราคา"""
        d1 = self._d1()
        if option_type == "call":
            return norm.cdf(d1)
        return norm.cdf(d1) - 1

    def gamma(self):
        """Gamma — อัตราเปลี่ยนของ Delta"""
        d1 = self._d1()
        return norm.pdf(d1) / (self.S * self.sigma * math.sqrt(self.T))

    def theta(self, option_type="call"):
        """Theta — Time Decay ต่อวัน"""
        d1, d2 = self._d1(), self._d2()
        common = -(self.S * norm.pdf(d1) * self.sigma) / \
                 (2 * math.sqrt(self.T))
        if option_type == "call":
            theta = common - self.r * self.K * \
                    math.exp(-self.r * self.T) * norm.cdf(d2)
        else:
            theta = common + self.r * self.K * \
                    math.exp(-self.r * self.T) * norm.cdf(-d2)
        return theta / 365  # ต่อวัน

    def vega(self):
        """Vega — ความไวต่อ Volatility"""
        d1 = self._d1()
        return self.S * norm.pdf(d1) * math.sqrt(self.T) / 100

    def summary(self):
        """สรุปทั้งหมด"""
        print("=== Option Analysis ===")
        print(f"Spot: {self.S} | Strike: {self.K} | "
              f"Days: {self.T*365:.0f} | IV: {self.sigma*100:.0f}%")
        print(f"\nCall Price: {self.call_price():.2f}")
        print(f"Put Price: {self.put_price():.2f}")
        print(f"\n--- Greeks (Call) ---")
        print(f"Delta: {self.delta('call'):.4f}")
        print(f"Gamma: {self.gamma():.4f}")
        print(f"Theta: {self.theta('call'):.4f} /day")
        print(f"Vega: {self.vega():.4f}")
        print(f"\n--- Greeks (Put) ---")
        print(f"Delta: {self.delta('put'):.4f}")
        print(f"Theta: {self.theta('put'):.4f} /day")

        # Payoff at different prices
        print(f"\n--- Payoff at Expiry ---")
        call_premium = self.call_price()
        put_premium = self.put_price()
        for p in [self.K * 0.8, self.K * 0.9, self.K, self.K * 1.1, self.K * 1.2]:
            c_pnl = self.call_payoff(p) - call_premium
            p_pnl = self.put_payoff(p) - put_premium
            print(f"  Price {p:>8.1f}: Call PnL {c_pnl:>8.2f} | "
                  f"Put PnL {p_pnl:>8.2f}")

# ตัวอย่าง: หุ้นราคา 100 Strike 100 หมดอายุใน 30 วัน IV 25%
calc = OptionCalculator(spot=100, strike=100, days_to_expiry=30,
                        risk_free_rate=0.02, volatility=0.25)
calc.summary()

กลยุทธ์ Options ที่นิยม

# กลยุทธ์ Options พร้อมคำนวณ PnL

def covered_call(stock_price, strike, premium, shares=100):
    """Covered Call — ถือหุ้น + ขาย Call"""
    print("=== Covered Call Strategy ===")
    print(f"Stock: {stock_price} | Strike: {strike} | Premium: {premium}")
    print(f"Max Profit: {(strike - stock_price + premium) * shares:,.0f}")
    print(f"Break-even: {stock_price - premium:.2f}")
    print(f"Max Loss: {(stock_price - premium) * shares:,.0f} (ถ้าหุ้นไป 0)")

def protective_put(stock_price, strike, premium, shares=100):
    """Protective Put — ถือหุ้น + ซื้อ Put (Insurance)"""
    print("\n=== Protective Put Strategy ===")
    print(f"Stock: {stock_price} | Strike: {strike} | Premium: {premium}")
    print(f"Max Loss: {(stock_price - strike + premium) * shares:,.0f}")
    print(f"Break-even: {stock_price + premium:.2f}")
    print(f"Protection below: {strike}")

def bull_call_spread(buy_strike, sell_strike, buy_premium, sell_premium):
    """Bull Call Spread — ซื้อ Call ต่ำ + ขาย Call สูง"""
    net_cost = buy_premium - sell_premium
    max_profit = sell_strike - buy_strike - net_cost
    print("\n=== Bull Call Spread ===")
    print(f"Buy Call {buy_strike} @ {buy_premium}")
    print(f"Sell Call {sell_strike} @ {sell_premium}")
    print(f"Net Cost: {net_cost:.2f}")
    print(f"Max Profit: {max_profit:.2f}")
    print(f"Max Loss: {net_cost:.2f}")
    print(f"Break-even: {buy_strike + net_cost:.2f}")

def iron_condor(put_buy, put_sell, call_sell, call_buy,
                put_buy_p, put_sell_p, call_sell_p, call_buy_p):
    """Iron Condor — ขาย Put Spread + ขาย Call Spread"""
    credit = (put_sell_p - put_buy_p) + (call_sell_p - call_buy_p)
    max_loss_put = put_sell - put_buy - credit
    max_loss_call = call_buy - call_sell - credit
    max_loss = max(max_loss_put, max_loss_call)
    print("\n=== Iron Condor ===")
    print(f"Buy Put {put_buy} | Sell Put {put_sell}")
    print(f"Sell Call {call_sell} | Buy Call {call_buy}")
    print(f"Net Credit: {credit:.2f}")
    print(f"Max Profit: {credit:.2f} (ถ้าราคาอยู่ระหว่าง {put_sell}-{call_sell})")
    print(f"Max Loss: {abs(max_loss):.2f}")
    print(f"Profit Zone: {put_sell}-{call_sell}")

# ตัวอย่าง
covered_call(100, 105, 3)
protective_put(100, 95, 2)
bull_call_spread(100, 110, 5, 2)
iron_condor(90, 95, 105, 110, 1, 3, 3, 1)

Options Greeks อธิบาย

Options ในตลาดไทย (TFEX)

• SET50 Index Options: Options บนดัชนี SET50 เทรดบน TFEX มี Monthly Expiry ทุกเดือน
• Contract Size: SET50 Index × 200 บาท เช่น SET50 = 900 Contract Value = 180,000 บาท
• Strike Interval: ทุก 25 จุด เช่น 875, 900, 925, 950
• Exercise Style: European Style (ใช้สิทธิ์ได้เฉพาะวัน Expiry)
• Settlement: Cash Settlement ไม่มีการส่งมอบจริง
• Trading Hours: 09:45-12:30 และ 14:15-16:55
• Initial Margin: ประมาณ 15-25% ของ Contract Value สำหรับผู้ขาย

Call Option คืออะไร

Call Option ให้สิทธิ์ผู้ซื้อในการซื้อสินทรัพย์ที่ Strike Price ภายใน Expiration Date ผู้ซื้อจ่าย Premium ใช้เมื่อคาดว่าราคาจะขึ้น กำไรไม่จำกัดถ้าราคาขึ้นมาก ขาดทุนสูงสุดคือ Premium ที่จ่ายไป

สรุป

Options เป็นเครื่องมือทางการเงินที่ทรงพลัง Call Option ใช้เมื่อคาดว่าราคาจะขึ้น Put Option ใช้เมื่อคาดว่าราคาจะลงหรือป้องกันพอร์ต สิ่งสำคัญคือเข้าใจ Greeks เพื่อจัดการความเสี่ยง เริ่มจากกลยุทธ์ง่ายๆเช่น Covered Call และ Protective Put ก่อน แล้วค่อยขยายไปกลยุทธ์ซับซ้อนเช่น Spread และ Iron Condor อย่าเทรด Options โดยไม่เข้าใจ Time Decay และ Implied Volatility