libitofin คืออะไร พอร์ต QuantLib ในภาษา Rust

libitofin คือ QuantLib ในภาษา Rust ซึ่งสามารถอธิบายสั้น ๆ ได้ว่าเป็นพอร์ตของ QuantLib ซึ่งเป็นไลบรารี C++ ที่เป็นมาตรฐานอ้างอิงแบบโอเพนซอร์สสำหรับการคำนวณราคาอนุพันธ์มาตั้งแต่ช่วงต้นทศวรรษ 2000 โดยนำมาเขียนใหม่ในภาษา Rust พร้อมด้วยแพ็กเกจ Python ที่ชื่อว่า itofin ณ เดือนมิถุนายน 2026 โครงการนี้ยังอยู่ในสถานะก่อนเวอร์ชัน 1.0 ซึ่งสถานะดังกล่าวเป็นตัวกำหนดแนวทางปฏิบัติทั้งหมดในการใช้งาน ไลบรารีสำหรับการคำนวณราคาจะสร้างคุณค่าผ่านกลไกที่ครอบคลุมสูตรคำนวณ ซึ่งกลไกเหล่านี้เป็นงานที่ต้องทำเหมือนกันไม่ว่าจะใช้ภาษาใดก็ตาม

สิ่งที่ไลบรารีคำนวณราคาให้คุณได้มากกว่าสูตรในสเปรดชีต

เซลล์ Black-Scholes ในสเปรดชีตรับค่าอินพุตห้าตัวและส่งคืนราคาออกมา สูตรคำนวณเป็นเพียงส่วนที่ง่ายที่สุดเท่านั้น โดยมีสี่ชั้นที่ล้อมรอบสูตรนั้นอยู่ และชั้นเหล่านั้นคือสิ่งที่เรียกว่าไลบรารี

โครงสร้างอัตราดอกเบี้ย (Term structures): อัตราคิดลดคือเส้นโค้งที่ครอบคลุมช่วงเวลาครบกำหนดต่างๆ พร้อมด้วยกฎการประมาณค่า (interpolation) สำหรับช่องว่างระหว่างจุดที่มีการเสนอราคาจริง แผงข้อมูลด้านล่างนี้คือวัตถุดิบตั้งต้น ได้แก่ ระยะเวลาครบกำหนดของพันธบัตรรัฐบาลที่เสนอราคา ณ วันที่หนึ่ง

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 ระยะเวลา โดยเริ่มตั้งแต่ 3.79% ที่ 1 month ไปจนถึง 5.25% ที่ 30 years สเปรดชีตจัดการเรื่องนี้ด้วยการค้นหาค่าและกำหนดค่าคงที่ไว้ที่ 4% แต่ไลบรารีจัดการด้วยวัตถุเส้นโค้ง (curve object) ที่เครื่องมือทางการเงินทุกตัวใช้ในการคำนวณราคา ภายใต้กฎการประมาณค่าที่ระบุไว้ (เช่น linear on zero rates, log-linear on discount factors, monotone splines) และนโยบายการประมาณค่าภายนอกช่วง (extrapolation policy) หลังจากจุดสุดท้าย หากขยับวัตถุนั้นเพียงหนึ่ง basis point ค่าความอ่อนไหว (sensitivity) ทุกตัวในพอร์ตจะเคลื่อนไหวอย่างสอดคล้องกัน

ธรรมเนียมการนับวัน (Day-count conventions): ดอกเบี้ยจะสะสมตามสัดส่วนของปี ซึ่งนิยามของสัดส่วนนั้นเป็นธรรมเนียมที่ผูกติดกับเครื่องมือทางการเงินนั้นๆ วิธี Actual/360 จะนำจำนวนวันที่ผ่านไปหารด้วย 360 ส่วน Actual/365 จะหารด้วย 365 ตระกูล 30/360 จะสมมติว่าทุกเดือนมี 30 วัน ส่วน Business/252 จะนับวันทำการเทียบกับปีที่มี 252 วัน ซึ่งต้องอาศัยปฏิทินของตลาดหลักทรัพย์ที่ระบุวันหยุดไว้แล้ว ลองพิจารณาสมมติฐานการกู้ยืมเงินหนึ่งล้านดอลลาร์ที่อัตรา 5% เป็นเวลา 90 วัน วิธี 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): พารามิเตอร์ของโมเดลไม่มีการเสนอราคาไว้ที่ใด คุณต้องเลือกพารามิเตอร์โดยการปรับค่าราคาจากโมเดลให้เข้ากับราคาตลาดที่สังเกตได้ทั่วทั้งพื้นผิวของราคาเสนอ (surface of quotes) แล้วปรับใหม่เมื่อพื้นผิวนั้นเคลื่อนไหว นี่คือปัญหาการหาค่ากำลังสองน้อยที่สุดที่มีขอบเขต (bounded least-squares problem) และไลบรารีจะจัดเตรียมลูปสำหรับการทำงานนี้ไว้ให้ ได้แก่ ตัวปรับค่า Levenberg-Marquardt, การแปลงพารามิเตอร์ที่ช่วยให้ค่าความแปรปรวนเป็นบวกโดยไม่มีข้อจำกัดที่เข้มงวด, ฟังก์ชันต้นทุนเหนือชุดราคาเสนอ และเกณฑ์การลู่เข้า (convergence criteria) ที่จะแจ้งเตือนเมื่อเกิดข้อผิดพลาดแทนที่จะส่งคืนค่าเริ่มต้นกลับมาอย่างเงียบๆ

ชั้นตัวเลข (A numerics layer): ภายใต้ทุกอย่างคือพีชคณิตเชิงเส้นและการอินทิเกรต การแยกส่วน QR และ SVD จะแก้ระบบสมการที่เกิดจากการปรับค่า ส่วน quadrature และ Fourier integration จะใช้คำนวณราคาโมเดลที่สูตรเป็นอินทิเกรต และตัวหาค่าราก (root finders) จะคำนวณค่าความผันผวนแฝง (implied volatility) ชั้นนี้ดูน่าเบื่อ แต่มันคือชั้นที่มักถูกเขียนขึ้นมาใหม่แบบผิดๆ เวอร์ชันคลาสสิกคือตัวแก้ Newton ที่เขียนขึ้นเองซึ่งลู่เข้าได้ดีกับราคาเสนอที่สภาพคล่องสูงและราคาที่ใกล้เคียงราคาใช้สิทธิ (at-the-money) แต่กลับทำงานผิดพลาดเมื่อเป็นราคาที่ห่างจากราคาใช้สิทธิมาก (deep out-of-the-money) รองลงมาคือการหาอินเวอร์สของเมทริกซ์ที่สูญเสียความแม่นยำในการปรับค่าที่เกือบจะเป็นเอกฐาน (near-singular fit) และส่งคืนพารามิเตอร์ที่ดูสมเหตุสมผลเกินจริง หากคุณกำลังสร้างโมเดลความคิดขึ้นมาใหม่ หนังสือการเทรดเชิงปริมาณแบบโอเพนซอร์ส เป็นจุดเริ่มต้นที่ดีกว่าการอ้างอิง API ของไลบรารีใดๆ

libitofin คืออะไร และใช่ QuantLib ในภาษา Rust หรือไม่

ใช่ ในแง่ที่สำคัญ มันคือการพอร์ตการออกแบบของ QuantLib มาสู่ภาษา Rust และโครงการระบุว่ามีการทดสอบเทียบกับชุดทดสอบของ QuantLib เอง นั่นเป็นวิธีที่ซื่อตรงในการพอร์ตไลบรารีเชิงตัวเลข ผลลัพธ์จะถูกตรวจสอบเทียบกับการใช้งานอ้างอิง แทนที่จะเทียบกับความคาดหวังที่เขียนขึ้นเองว่าคำตอบควรจะเป็นอย่างไร เส้นทางของ Python คือแพ็กเกจที่ชื่อว่า itofin ดังนั้นกระบวนการของ Python จึงสามารถเข้าถึงเอนจินของ Rust ได้โดยไม่ต้องมี C++ toolchain เข้ามาเกี่ยวข้อง

ป้ายกำกับที่สำคัญกว่าคือสถานะก่อนเวอร์ชัน 1.0 ภายใต้ธรรมเนียมการกำหนดเวอร์ชันของ Rust การปล่อยเวอร์ชัน 0.x ไม่มีการรับประกันความเข้ากันได้ระหว่างเวอร์ชันย่อย: เวอร์ชัน 0.4 ไปยัง 0.5 สามารถเปลี่ยนชื่อ ย้าย หรือลบสิ่งใดก็ได้ที่ต้องการ จงปฏิบัติต่อ API เสมือนเป้าหมายที่เคลื่อนที่ได้ และควรมีนิสัยดังนี้

• ตรึงเวอร์ชันที่ระบุไว้ (tagged release) ใน lockfile ของคุณและอัปเกรดอย่างตั้งใจ โดยมีชุดทดสอบของคุณเองเป็นตัวคัดกรอง
• สร้าง wrapper บางๆ ของคุณเองครอบประเภทข้อมูลของไลบรารี เพื่อให้การเปลี่ยนชื่อส่งผลกระทบในไฟล์เดียวแทนที่จะเป็นสี่สิบไฟล์
• บันทึกเวอร์ชันของไลบรารีไว้ข้างตัวเลขที่ผลิตออกมา เพื่อให้การรันซ้ำที่ได้ผลลัพธ์ต่างออกไปชี้ไปที่การอัปเกรดแทนที่จะเป็นตลาด
• เก็บตัวเลขมาร์จิ้น หลักประกัน และความเสี่ยงด้านกฎระเบียบไว้บนสิ่งที่รับประกันความเข้ากันได้จนกว่าเวอร์ชัน 1.0 จะมาถึง

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

Python, เอนจินที่คอมไพล์แล้ว, หรือ 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 รายการซื้อขายในเซสชันเดียว เทียบกับ 360 สำหรับ KO การคำนวณราคา chain ขนาดใหญ่หนึ่งครั้งไม่ใช่เรื่องยาก แต่การคำนวณด้วยค่าความอ่อนไหวห้าค่าต่อสัญญา ในทุกการอัปเดตราคาเสนอ ทั่วทั้งพอร์ตของสินทรัพย์อ้างอิง เป็นโปรแกรมที่แตกต่างกันโดยสิ้นเชิงและมีข้อจำกัดที่ต่างออกไป

จงใช้ Python กับไลบรารีที่มีอยู่เดิมเมื่อลูปการทำงานวัดได้เป็นหลักพันครั้งต่อนาที และงานโดยรอบคือการวิจัย การวิเคราะห์ หรือการทำราคาปิดสิ้นวัน Python bindings ของ QuantLib เองเป็นตัวเลือกที่เติบโตเต็มที่: เอนจิน C++ ตัวเดียวกัน ครอบคลุมเครื่องมือทางการเงินกว้างขวางที่สุด และผ่านการใช้งานจริงมาหลายปี ความเร็วแทบไม่ใช่ข้อจำกัดในการเขียนโค้ดวิจัย แต่ความครอบคลุมและความถูกต้องต่างหากที่สำคัญ

จงเรียกใช้เอนจินที่คอมไพล์แล้วจาก Python เมื่อลูปการทำงานมีความถี่สูงและโค้ดโดยรอบไม่ได้เป็นเช่นนั้น ต้นทุนที่ต้องระวังคือรอยต่อระหว่างภาษา การเรียกใช้จาก Python ต่อสัญญาจะเสียค่า overhead ในทุกการข้ามผ่าน และวิธีแก้ไขคือการส่งอาร์เรย์ให้เอนจินและรับอาร์เรย์กลับมา นี่คือจุดที่ itofin มุ่งเน้น เช่นเดียวกับ QuantLib-Python

จงเขียนด้วย Rust เมื่อลูปการคำนวณราคาคือตัวผลิตภัณฑ์: เช่น pricer ภายในบริการเสนอราคา, การคำนวณความเสี่ยงตามกำหนดเวลาที่คุณพลาดไม่ได้ หรือไบนารีที่ส่งไปยังเครื่องที่ไม่มี Python คำถามข้อที่สองก็มาตกที่จุดนี้เช่นกัน ผลลัพธ์ของเลขทศนิยมขึ้นอยู่กับลำดับการดำเนินการ ดังนั้นโมเดลเดียวกันที่ถูกนำไปใช้สองครั้งอาจให้ผลลัพธ์ต่างกันในหลักสุดท้าย และสมุดบันทึกการวิจัยที่ไม่ตรงกับบริการที่ใช้งานจริงอาจนำไปสู่การตรวจสอบย้อนหลังเป็นสัปดาห์ เอนจินเดียวที่ใช้จากทั้งสองฝั่งจะขจัดความคลาดเคลื่อนประเภทนี้ทั้งหมด ซึ่งเป็นข้อโต้แย้งที่ยั่งยืนสำหรับเอนจินที่คอมไพล์แล้วพร้อม bindings ไม่ว่าจะเขียนด้วยภาษาใดก็ตาม สัญชาตญาณเดียวกันนี้ใช้กับงานด้านกลยุทธ์ ดังที่ การทดสอบย้อนหลังที่ทำซ้ำได้ แสดงให้เห็น

เป้าหมายการปรับเทียบอยู่ที่ไหน

การปรับเทียบต้องการสิ่งที่ใช้เทียบ และสิ่งนั้นคือพื้นผิวของค่าความผันผวนที่ตลาดคาดการณ์ (market-implied volatilities) ด้านการหาค่ารากของเรื่องนี้ครอบคลุมอยู่ใน วิธีการคำนวณค่าความผันผวนแฝง รูปร่างด้านล่างคือสิ่งที่โมเดลต้องทำให้ตรงกัน

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)

ใกล้ราคาใช้สิทธิ สัญญา AAPL ในกลุ่ม 0 to 7 days มีค่าความผันผวนแฝงเฉลี่ย 29.6% ตลอดเซสชันที่แสดง เทียบกับ 29.3% ที่ 241 days or more โมเดลที่มีพารามิเตอร์ความผันผวนเพียงตัวเดียวไม่สามารถครอบคลุมทั้งสองจุดได้พร้อมกัน ซึ่งเป็นเหตุผลว่าทำไมโมเดลที่มีโครงสร้างระยะเวลาของความผันผวนจึงมีอยู่ การปรับค่าให้เข้ากับพื้นผิวเช่นนี้คือขั้นตอนการปรับเทียบ และค่าความอ่อนไหวที่ได้จากโมเดลที่ปรับเทียบแล้วคือค่า Greeks ซึ่งครอบคลุมอยู่ใน คำอธิบายค่า Greeks ของออปชัน

คำถามที่พบบ่อย

libitofin เป็นตัวแทนที่ใช้งานแทน QuantLib ได้ทันทีหรือไม่?

ไม่ ณ เดือนมิถุนายน 2026 มันเป็นพอร์ตสถานะก่อน 1.0 ที่ครอบคลุมพื้นผิวบางส่วนของ QuantLib และตรวจสอบผลลัพธ์เทียบกับชุดทดสอบของ QuantLib เอง ตัว QuantLib เอง ซึ่งเข้าถึงผ่าน Python bindings ยังคงเป็นตัวเลือกที่กว้างขวางและเสถียรกว่าสำหรับงานที่ใช้งานจริง

สถานะก่อน 1.0 หมายถึงอะไรสำหรับไลบรารีคำนวณราคา?

ภายใต้ธรรมเนียมการกำหนดเวอร์ชันของ Rust เวอร์ชัน 0.x ไม่มีการรับประกันความเข้ากันได้: เวอร์ชันย่อยถัดไปสามารถเปลี่ยนชื่อหรือลบสิ่งใดก็ได้ ในทางปฏิบัติหมายถึงการตรึงเวอร์ชันที่ระบุไว้และรันชุดทดสอบของคุณเองซ้ำทุกครั้งที่มีการอัปเกรด

ฉันจำเป็นต้องเขียนภาษา Rust เพื่อใช้ libitofin หรือไม่?

ไม่ โครงการเผยแพร่แพ็กเกจ Python ที่ชื่อว่า itofin ดังนั้นเอนจินจึงสามารถเรียกใช้จากกระบวนการ Python ปกติได้ การเขียน Rust จะมีความเกี่ยวข้องเมื่อลูปการคำนวณราคาคือสิ่งที่คุณกำลังส่งมอบเป็นผลิตภัณฑ์

ไลบรารีคำนวณราคาให้อะไรฉันมากกว่าสูตรในสเปรดชีต?

เส้นโค้งแทนที่จะเป็นอัตราดอกเบี้ยเดี่ยวๆ, ธรรมเนียมการนับวันที่มาพร้อมกับปฏิทินตลาดหลักทรัพย์จริง, ลูปการปรับเทียบที่ปรับพารามิเตอร์โมเดลให้เข้ากับราคาที่เสนอ และชั้นตัวเลขที่ผ่านการทดสอบภายใต้ทั้งสามส่วน สูตรคำนวณแบบปิด (closed-form) เป็นเพียงส่วนเล็กๆ ของงานเท่านั้น

ภาษาโปรแกรมเปลี่ยนราคาออปชันหรือไม่?

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

แผงข้อมูลทุกแผงที่นี่มี SQL ที่ใช้สร้างกำกับอยู่ ดังนั้นให้ขยายแผงเพื่อดูวิธีการนับข้อมูล คำถามเกี่ยวกับเส้นโค้ง ปฏิทิน และ chain เดียวกันนี้สามารถสอบถามเป็นภาษาอังกฤษทั่วไปได้ที่เทอร์มินัล Strasmore