1  การคำนวณเชิงสัญลักษณ์และการใช้งานซิมไพเบื้องต้น

1.1 บทนำ

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

เพื่อแก้ไขข้อจำกัดดังกล่าว แนวคิดของ การคำนวณเชิงสัญลักษณ์ (symbolic computation) จึงมีบทบาทสำคัญมากขึ้น โดยเปิดโอกาสให้ผู้เรียนสามารถทำงานกับนิพจน์ทางคณิตศาสตร์ในรูปแบบสัญลักษณ์ แทนที่จะเป็นเพียงค่าตัวเลข

Noteนิยาม

การคำนวณเชิงสัญลักษณ์ (symbolic computation) หมายถึง กระบวนการจัดการ แปลงรูป และวิเคราะห์นิพจน์ทางคณิตศาสตร์ในรูปของสัญลักษณ์ เช่น ตัวแปร ฟังก์ชัน หรือพารามิเตอร์ โดยไม่จำเป็นต้องแทนค่าตัวเลขในทันที

แนวทางดังกล่าวช่วยให้สามารถ:

• วิเคราะห์ความสัมพันธ์ระหว่างตัวแปรได้อย่างเป็นระบบ

• ติดตามที่มาของสูตรและแบบจำลอง

• ปรับเปลี่ยนสมมุติฐานของปัญหาได้อย่างยืดหยุ่น

ซึ่งมีความสำคัญอย่างยิ่งในคณิตศาสตร์การเงิน ที่สูตรจำนวนมากเกิดจากกระบวนการอนุมานและการแปลงรูปทางพีชคณิต

1.1.1 การคำนวณเชิงตัวเลขและเชิงสัญลักษณ์

เพื่อให้เห็นความแตกต่างอย่างชัดเจน สามารถพิจารณาเปรียบเทียบแนวทางทั้งสองได้ดังนี้

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

จากตารางจะเห็นได้ว่า การคำนวณเชิงสัญลักษณ์ไม่ได้มาแทนที่การคำนวณเชิงตัวเลข แต่ทำหน้าที่เสริม เพื่อให้เกิดความเข้าใจเชิงโครงสร้างของปัญหา

1.2 บทบาทของการคำนวณเชิงสัญลักษณ์ในคณิตศาสตร์การเงิน

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

การใช้การคำนวณเชิงสัญลักษณ์ช่วยให้สามารถ:

• นิยามแบบจำลองในรูปทั่วไป

• วิเคราะห์พฤติกรรมของฟังก์ชัน เช่น การเพิ่มขึ้นหรือลดลง

• หาความสัมพันธ์เชิงอนุพันธ์หรือขีดจำกัดของแบบจำลอง

• แปลงรูปสูตรให้อยู่ในรูปที่สะดวกต่อการตีความ

ดังนั้น แนวทางนี้จึงมีบทบาทสำคัญในการเชื่อมโยงระหว่างการเรียนรู้เชิงทฤษฎีกับการประยุกต์ใช้งานจริง

1.2.1 เครื่องมือสำหรับการคำนวณเชิงสัญลักษณ์

ในหนังสือเล่มนี้จะใช้ไลบรารีซิมไพ(SymPy) ซึ่งเป็นเครื่องมือในภาษาไพธอน (Python) สำหรับการคำนวณเชิงสัญลักษณ์ โดยมีความสามารถในการ:

• แก้สมการ (equation solving)

• หาอนุพันธ์และปริพันธ์

• จัดรูปนิพจน์ทางพีชคณิต

• นิยามฟังก์ชันเชิงสัญลักษณ์

• แปลงผลลัพธ์ให้อยู่ในรูปแบบ \(\LaTeX\)

ซิมไพเป็นซอฟต์แวร์แบบเปิด (open-source) ที่สามารถใช้งานได้โดยไม่มีค่าใช้จ่าย และสามารถทำงานร่วมกับเครื่องมืออื่นในระบบนิเวศของ Python เช่น NumPy, Matplotlib และ Pandas ได้อย่างมีประสิทธิภาพ

1.3 สภาพแวดล้อมสำหรับการใช้งาน

เพื่อให้สามารถทดลองและประยุกต์ใช้แนวคิดในบทนี้ได้อย่างมีประสิทธิภาพ ผู้อ่านควรใช้งานร่วมกับสภาพแวดล้อมที่รองรับการเขียนโปรแกรมแบบอินเทอร์แอกทีฟ เช่น Jupyter Notebook หรือเครื่องมืออื่นที่มีลักษณะใกล้เคียง โดยสามารถใช้งานได้ทั้งแบบติดตั้งในเครื่องหรือผ่านระบบออนไลน์

1.3.1 การติดตั้งโปรแกรมและการใช้งานซิมไพเบื้องต้น

ถ้าไม่ต้องการติดตั้งโปรแกรมภาษาไพธอนในเครื่องคอมพิวเตอร์ หรือผู้อ่านใช้ iPad หรือ tablet อื่นๆ ผู้อ่านสามารถใช้ภาษาไพธอนและซิมไพได้จาก

https://jupyter.org/ หรือ https://colab.google/ ก็ได้

โดยไม่ต้องติดตั้งโปรแกรมที่เกี่ยวข้องลงในคอมพิวเตอร์

1.3.2 ติดตั้งไพธอนสาม (Python3)

ตรวจสอบว่าเครื่องคอมพิวเตอร์มีไพธอนหรือไม่ โดยพิมพ์ใน command line สำหรับ WINDOWS และใน terminal สำหรับ MAC OS หรือ LINUX

python3 --version

ถ้ายังไม่มี

• macOS ดาวน์โหลดจาก https://www.python.org/downloads/macos/ หรือสามารถติดตั้งผ่าน Homebrew

  brew install python

• Windows ดาวน์โหลดจาก https://www.python.org/downloads/ อย่าลืมเลือก “Add Python to PATH”

• LINUX(สาย ubuntu) ติดตั้งผ่าน terminal

sudo apt update
sudo apt install python3 python3-pip -y

2. สร้าง Virtual Environment (แนะนำ)

python3 -m venv sympy-env
source sympy-env/bin/activate   # บน macOS / Linux
sympy-env\Scripts\activate.bat  # บน Windows

Virtual Environment (สภาพแวดล้อมเสมือน) คือเครื่องมือในภาษาไพธอนที่ใช้สร้างสภาพแวดล้อมเฉพาะตัวสำหรับโปรเจกต์หนึ่ง ๆ ซึ่งแยกออกจากไพธอนและไลบรารีหลักที่ติดตั้งไว้ในเครื่องเพื่อให้สามารถ

1. แยกไลบรารี แต่ละโปรเจกต์สามารถใช้เวอร์ชันของไลบรารีที่ต่างกันได้โดยไม่ชนกัน

2. หลีกเลี่ยงปัญหา dependency conflict โปรเจกต์ A อาจใช้ sympy==1.7.1 ส่วนโปรเจกต์ B ใช้ sympy==1.12

3. ทำงานร่วมกับทีมได้ง่ายขึ้น สามารถแนบ requirements.txt แล้วให้คนอื่นติดตั้งไลบรารีตามที่คุณใช้ได้

4. ไม่รบกวนระบบหลัก ไพธอนและไลบรารีในเครื่องยังคงปลอดภัยจากการเปลี่ยนแปลงในแต่ละโปรเจกต์

1.3.3 ติดตั้งซิมไพ และ Jupyter Notebook

ก่อนเริ่มต้นใช้งานซิมไพ ซึ่งเป็นไลบรารีในภาษาไ ํพธอนสำหรับการคำนวณเชิงสัญลักษณ์ (symbolic computation) และ Jupyter Notebook ซึ่งเป็นเครื่องมือยอดนิยมในการเขียนและรันโค้ดไพธอนในรูปแบบอินเทอร์แอกทีฟ ผู้ใช้จำเป็นต้องติดตั้งโปรแกรมทั้งสองผ่านคำสั่งในเทอร์มินัล (Terminal) หรือ Command Prompt ดังนี้

pip3 install sympy notebook

• pip3 คือคำสั่งสำหรับติดตั้งแพ็กเกจในไพธอน

• sympy คือไลบรารีสำหรับการคำนวณเชิงสัญลักษณ์ เช่น การแก้สมการ หาค่าอนุพันธ์ อินทิกรัล และอื่น ๆ

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

เมื่อดำเนินการติดตั้งเสร็จเรียบร้อยแล้ว ผู้ใช้สามารถเริ่มต้นเขียนสมการทางคณิตศาสตร์โดยใช้ซิมไพ ได้ทันทีใน Jupyter Notebook

Importantทดสอบว่าทุกอย่างใช้งานได้

เริ่มใช้งาน Jupyter notebook ใน ternimal หรือ command line โดยการพิมพ์

jupyter notebook

jupyter notebook ก็จะพร้อมใช้งานสำหรับการคำนวณเชิงสัญลักษณ์ด้วยซิมไพ

สามารถทดลองการใช้งาน โดยการประมวลผลคำสั่งต่อไปนี้

from sympy import symbols, expand
x = symbols('x')
expr = (x + 1)**3
expand(expr)

และถ้าใช้ jupyter notebook โดยตรงจะได้ผลลัพธ์ทางหน้าหน้าจอ \[x^3+3x^2+3x+1\]

แต่ถ้าผ่านอ่านใช้ quarto ในโปรแกรม RStudio จะได้ผลลัพธ์ทางหน้าจอคือ

x**3 + 3*x**2 + 3*x + 1

และเมื่อทำการประมวลผลออกมาเป็นเอกสารต่างๆ จะได้สมการที่ถูกต้องสวยงามไม่แตกต่างจาก jupyter notebook

Warningหมายเหตุเพิ่มเติม

หากผู้อ่านใช้งานผ่าน Quarto ให้ตั้งค่า YAML โดยกำหนด

jupyter: true

```{python}
from sympy import *
init_printing()
x = symbols('x')
expand((x + 1)**3)
```

แต่ต้องติดตั้ง jupyter notebook ให้เรียบร้อยก่อน

1.4 สรุปคำสั่งหลักสำหรับการใช้งานซิมไพ

# ติดตั้ง Python (ถ้ายังไม่มี)
brew install python  # สำหรับ macOS

# สร้าง virtual environment
python3 -m venv sympy-env
source sympy-env/bin/activate

# ติดตั้ง SymPy และ Jupyter
pip3 install sympy notebook

# เรียกใช้งาน Jupyter Notebook
jupyter notebook

การคำนวณเชิงสัญลักษณ์ (symbolic mathematics) โดยใช้ชุดคำสั่งซิมไพสำหรับผู้ที่มีพื้นฐานภาษาไพธอน เช่น การแก้สมการ การหาอนุพันธ์ การอินทิเกรต พีชคณิตเชิงเส้น สมการเชิงอนุพันธ์ ฯลฯ

from sympy import Symbol
## เช่นการสร้างตัวแปรสัญลักษณ์การจ่ายรายงวด
a_n = Symbol('a_{\\overline{x}|i}')
a_n

\(\displaystyle a_{\overline{x}|i}\)

1.4.1 ทำไมเลือกใช้ซิมไพ

1. พลังแห่งการคำนวณเชิงสัญลักษณ์ (The Power of Symbolic Math) SymPy ไม่ได้มองตัวเลขเป็นแค่ทศนิยมเหมือนเครื่องคิดเลขทั่วไป แต่มันมองคณิตศาสตร์เป็น “สัญลักษณ์” (Expression)

   • ความแม่นยำ 100%: เช่น การคำนวณค่า \(\sqrt{2}\) หรือ \(\pi\) จะไม่มีการปัดเศษทิ้งจนกว่าคุณจะสั่ง ทำให้ผลลัพธ์ในสมการการเงินที่ซับซ้อนไม่เกิด Error สะสม

   • แก้สมการติดตัวแปร: สามารถจัดรูปสมการ แก้สมการดิฟเฟอเรนเชียล หรือหาอนุพันธ์โดยติดค่าพารามิเตอร์ไว้ได้ (เช่น ติดค่า \(r\) หรือ \(\sigma\) ไว้) เหมือนมีซอฟต์แวร์ราคาแพงอย่าง Mathematica อยู่ในมือ แต่ใช้ฟรี!

2. ไร้รอยต่อบนโลกของ Cloud Computing ออกแบบมาเพื่อยุคสมัยของ Jupyter Notebook และ Google Colab โดยเฉพาะ

   • ไม่ต้องติดตั้งให้ยุ่งยาก: ผู้เรียนหรือผู้อ่านสามารถรัน Code ผ่าน Browser ได้ทันที

   • Interactive Learning: เปลี่ยนจาก “การดูสูตรนิ่งๆ ในตำรา” เป็น “การเปลี่ยนตัวแปรแล้วดูผลลัพธ์ทันที” (Real-time Experimentation) ซึ่งเป็นหัวใจของการศึกษาในยุคดิจิทัล

3. ศูนย์กลางของระบบนิเวศ Python (The Python Ecosystem Hub) SymPy ไม่ได้ทำงานโดดเดี่ยว แต่เป็น “สะพาน” เชื่อมไปสู่เครื่องมืออื่นๆ:

   • SymPy ➔ NumPy: สามารถเปลี่ยนสูตรทางคณิตศาสตร์ที่พิสูจน์เสร็จแล้ว ให้กลายเป็นฟังก์ชันความเร็วสูง (Vectorized Code) เพื่อประมวลผลข้อมูลการเงินขนาดใหญ่ใน Pandas ได้ทันที

   • SymPy ➔ Matplotlib: พล็อตกราฟจากฟังก์ชันสัญลักษณ์ได้โดยตรง ช่วยให้เห็นภาพรวมของฟังก์ชัน (เช่น กราฟกำไร-ขาดทุน) ได้ง่ายขึ้น

4. การสร้างเอกสารทางวิชาการระดับโลก (Seamless Documentation) เมื่อใช้ร่วมกับ Markdown และ Quarto จะทำให้การเขียนตำราการเงินกลายเป็นเรื่องง่าย:

   • Auto-LaTeX: SymPy สามารถแปลงผลลัพธ์ที่คำนวณได้ให้อยู่ในรูป \(\LaTeX\) ที่สวยงามโดยอัตโนมัติ ลดความผิดพลาดจากการพิมพ์สูตรเอง

   • One Source, Multi-Outputs: เขียน Code ครั้งเดียว แต่สามารถ Export ผลลัพธ์ออกมาเป็นทั้งเว็บไซต์ (HTML Book), รายงาน (PDF), หรือสไลด์สอน (Revealjs) ที่มีสูตรคณิตศาสตร์คมชัด

5. มาตรฐานใหม่ของ Open Source Library

   • Lightweight & Pure Python: ตัวไลบรารีมีขนาดเล็ก ติดตั้งง่าย และเขียนด้วยภาษา Python ทั้งหมด ทำให้เข้าถึงและเรียนรู้ได้รวดเร็วสำหรับนักศึกษาและนักวิจัย

   • Community Driven: มีการอัปเดตและตรวจสอบจากนักคณิตศาสตร์และโปรแกรมเมอร์ทั่วโลก ทำให้มั่นใจได้ในความถูกต้องและความทันสมัยของ Algorithm

1.4.2 การกำหนดสัญลักษณ์ด้วยคำสั่ง symbols

คำสั่ง symbols ในซิมไพเป็นคำสั่งพื้นฐานที่ สำคัญมาก เพราะใช้ในการสร้าง ตัวแปรเชิงสัญลักษณ์ (symbolic variables) ซึ่งเป็นหัวใจของการคำนวณเชิงสัญลักษณ์ เช่น การแก้สมการ, การอนุพันธ์, อินทิกรัล, การแทนค่า ฯลฯ

ความหมายของคำสั่ง symbols

from sympy import symbols
x = symbols('x')

• คำสั่งนี้หมายถึง สร้างตัวแปรสัญลักษณ์ชื่อว่า \(x\)

• เป็นวัตถุ (object) ของชนิด Symbol ที่ซิมไพใช้แทน “ตัวแปรทางคณิตศาสตร์” เหมือนที่เราใช้ในสมการจริงๆ

ซิมไพไม่ใช้ตัวแปรแบบไพธอนทั่วไป เช่น x = 5 แต่ใช้ x = symbols('x') เพื่อบอกว่า “ฉันต้องการใช้ \(x\) เป็นตัวแปรในสมการ/สูตร”

ความสำคัญของคำสั่ง symbols()

วัตถุประสงค์	อธิบาย
1. สร้างตัวแปรเชิงสัญลักษณ์	เหมือน \(x, y, z\) ในคณิตศาสตร์
2. ใช้ในสมการ	ใช้สร้าง, แก้, หรือแปลงสมการ
3. ใช้ในการคำนวณขั้นสูง	เช่นการหาอนุพันธ์, อินทิกรัล, ลิมิต, พีชคณิตเชิงเส้น เป็นต้น
4. ควบคุมสมบัติตัวแปร	เช่นมีคุณสมบัติเป็นจำนวนบวก, จำนวนจริง หรือจำนวนเต็ม
5. รองรับเวกเตอร์/แมทริกซ์/อนุกรม	ใช้ได้ทั้งการตัวแปรแบบรายตัวหรือหลายตัวพร้อมกัน

from sympy import symbols
# สร้างตัวแปรเชิงสัญลักษณ์ชื่อ x ให้มีค่าเท่ากับ x
x = symbols('x')

หรือหลายตัว:

from sympy import symbols
# สร้างตัวแปรเชิงสัญลักษณ์ชื่อ x y และ z ให้มีค่าเท่ากับ x y และ z ตามลำดับ
x, y, z = symbols('x y z')

หรือเป็นลำดับ ลิสต์/เมตริกซ์ของตัวแปร

from sympy import symbols
a = symbols('a1:6')  # ได้ a1, a2, ..., a5
a

(a1, a2, a3, a4, a5)

1.4.3 การกำหนดสมมุติฐานให้ตัวแปรเชิงสัญลักษณ์ (assumptions)

ซิมไพรองรับสมมุติฐานที่ช่วยลดความซับซ้อนของนิพจน์ หรือข่วยในเวลาต้องการแก้สมการหาคำตอบ

• หากไม่กำหนดสมมุติฐาน ซิมไพจะให้เป็นค่าไม่ทราบแน่ชัด

• การกำหนดสมมุติฐานที่เหมาะสมช่วยให้ simplify, solve, limit, และการพิสูจน์เชิงสัญลักษณ์ต่าง ๆ แม่นยำขึ้น

a = symbols('a', positive = True)  # a > 0
b = symbols('b', real = True, positive = True)      # b เป็นจำนวนจริง บวก
c = symbols('c', integer = True)   # c เป็นจำนวนเต็ม
d = symbols('d', nonzero = True)  # d ไม่เท่ากับ 0
e = symbols('d')

ตรวจสอบว่า a เป็นจำนวนเต็มบวกใช่หรือไม่?

a.is_positive

True

หรือ b เป็นจำนวนจริงบวกใช่หรือไม่?

b.is_real

True

b.is_positive

True

ถ้าไม่กำหนดสมมุติฐานเช่น ตัวแแปรเชิงสัญลักษณ์ e

e.is_real # เป็นจำนวนเต็มใช่หรือไม่?

e.is_complex # เป็นจำนวนเชิงซ้อนใช่หรือไม่?

จะไม่ได้คำตอบออกมา ว่าเป็นจริงหรือเท็จ

1.4.4 ตัวอย่างสมมุติฐานที่ใช้ได้

สมมุติฐาน	ความหมาย
real = True	เป็นจำนวนจริง
positive = True	> 0
negative = True	< 0
nonzero = True	\(\neq\) 0
integer = True	เป็นจำนวนเต็ม
odd = True, even = True	เป็นเลขคี่, เลขคู่
finite = True	ไม่เป็นอินฟินิตี้
prime = True	เป็นจำนวนเฉพาะ

1.4.5 การสร้างสัญลักษณ์ภาษากรีก

สัญลักษณ์หรือตัวแปรต่างๆ ในทางคณิตศาสตร์มักใช้ตัวอักษรกรีซในการสื่อความหมาย และซิมไพอนุญาติให้เราสามารถใช้ตัวอักษรกรีกได้โดยใช้ชื่อของสัญลักษณ์โดยตรง เช่น

## ตัวแปรเชิงสัญลักษณ์ภาษากรีซ
alpha, beta, gamma, lam, mu, nu, pi = symbols('alpha beta gamma lambda mu nu pi')

ซิมไพรองรับการแสดงผลเป็นอักษรกรีกอัตโนมัติเมื่อใช้ pretty(), LaTeX, หรือ notebook rendering

พิมพ์ว่า	ได้เป็นสัญลักษณ์
alpha	\(\alpha\)
beta	\(\beta\)
lam	\(\lambda\)
mu	\(\mu\)
nu	\(\nu\)
pi	\(\pi\)

ตัวอย่างใช้งานและผลลัพธ์ทางหน้าจอหรือเอกสาร

alpha + beta - gamma/lam + mu + nu/pi

\(\displaystyle \alpha + \beta - \frac{\gamma}{\lambda} + \mu + \frac{\nu}{\pi}\)

1.4.6 การหลีกเลี่ยงการใช้บางชื่อเป็นตัวแปร

1. ถูกใช้เป็นชื่อฟังก์ชันหรือคลาสของซิมไพเอง

2. เป็นคำสงวน (reserved keywords) ในไพธอน

3. อาจทำให้เกิด conflict หรือพฤติกรรมผิดพลาดโดยไม่รู้ตัว

ชื่อที่ควรหลีกเลี่ยงในซิมไพโดยเฉพาะ

ชื่อ	เหตุผล
I	แทนหน่วยจินตภาพ \(i = \sqrt{-1}\)
E	แทนค่าคงที่ \(e \approx 2.718\)
pi	ค่าคงที่ \(\pi\)
oo	Infinity (\(\infty\))
zoo	Complex infinity
NaN	Not a Number
S	ตัวช่วยเรียกค่าคงที่ เช่น S(1)/2
Eq, solve, diff, integrate, symbols, expand, ฯลฯ	เป็นฟังก์ชันหลักของซิมไพ

ถ้าเขียน I = symbols('I') \(\rightarrow\) จะทำให้ I ไม่ใช่ \(\sqrt{-1}\) อีกต่อไป และอาจทำให้การคำนวณตัวเลขเชิงซ้อนผิดพลาดได้

ชื่อที่เป็น reserved keywords ของไพธอน (ห้ามใช้)

เช่น:

if, else, while, for, in, def, class, return, lambda, True, False, None

ห้ามสร้างตัวแปรชื่อ lambda

lambda = symbols('lambda')  # SyntaxError

ผลลัพธ์

File "<string>", line 1
    lambda = symbols('lambda')  # SyntaxError
           ^
SyntaxError: invalid syntax)

แต่สามารถใช้ชื่อใกล้เคียงได้

lambda_ = symbols('lambda_')  # สามารถทำได้
lambda_

\(\displaystyle \lambda_{}\)

ชื่อที่ใช้ในชุดคำสั่งหรือไลบรารีอื่น เช่น NumPy, matplotlib

ถ้าเราต้องใช้หลายไลบรารีร่วมกัน (เช่น NumPy, Pandas, matplotlib) ก็ควรหลีกเลี่ยงชื่อต่อไปนี้เช่นกัน:

ชื่อ	ความเสี่ยง
sum, min, max, range	เป็น built-in function ของ Python
list, dict, set	ชื่อชนิดข้อมูล
np, pd, plt	ชื่อย่อ (alias) ของไลบรารี

วิธีป้องกันตัวแปรซ้อนชื่อสำคัญ

• ใช้ suffix เช่น _var, _sym, _val

• ใช้ underscore _ เช่น lambda_, I_, pi_

• ใช้ dir() เพื่อตรวจสอบว่าชื่อนั้นถูกใช้แล้วหรือไม่

'I' in dir()  # ถ้า True แสดงว่ามี object ชื่อ I แล้ว

ถ้าต้องการสร้างสัญลักษณ์หลายตัว เช่น \(\lambda, \mu, \sigma\) ที่ชื่อซ้อนกับค่าพิเศษเหล่านี้อาจใช้ lambda_ mu_sym หรือ sigma_sym

1.4.7 สัญลักษณ์ที่มี “ยกกำลัง” หรือ “ตัวห้อย”

x_t = symbols('x_t')    # ตัวห้อย
x_t

\(\displaystyle x_{t}\)

i_m = symbols('i^{(m)}') # ตัวยก 
i_m

\(\displaystyle i^{(m)}\)

ผู้อ่านควรจะต้องเข้าใจภาษา LaTeX เบื้องต้นเกี่ยวกับเขียนสมการก่อน จะทำให้เข้าใจหลักของ การสร้างตัวแปรเชิงสัญลักษณ์ด้วยซิมไพได้เข้าใจมากยิ่งขึ้น

1.5 สัญลักษณ์พื้นฐานที่ใช้ในคณิตศาสตร์การเงิน

ในการศึกษาวิชาคณิตศาสตร์การเงิน การใช้ สัญลักษณ์ทางคณิตศาสตร์ มีความสำคัญอย่างยิ่ง เนื่องจากช่วยให้สามารถเขียนสูตรและแบบจำลองต่าง ๆ ได้อย่างกระชับ ชัดเจน และเป็นสากล โดยเฉพาะอย่างยิ่งในการวิเคราะห์เรื่องดอกเบี้ย มูลค่าเงินตามเวลา เงินงวด (Annuities) และเงินสำรอง (Reserves)

หัวข้อนี้จึงรวบรวมสัญลักษณ์พื้นฐานที่ใช้กันอย่างแพร่หลายในการคำนวณทางการเงิน เช่น

• อัตราดอกเบี้ย (เช่น \(i\), \(d\))

• ค่าคิดลด (\(v\))

• จำนวนงวดและระยะเวลา (\(n, m\))

• มูลค่าปัจจุบันและมูลค่าในอนาคต (\(PV, FV\))

• เงินงวดและทุนตั้งต้น (\(A, P, F, S\))

การกำหนดสัญลักษณ์ด้วยภาษาไพธอนด้วยชุดคำสั่งซิมไพยังช่วยให้สามารถคำนวณเชิงสัญลักษณ์ได้ ซึ่งเหมาะทั้งสำหรับการเรียน การสอน และการสร้างแบบจำลองเชิงทฤษฎีและเชิงปฏิบัติ

1.5.1 อัตราดอกเบี้ย และมูลค่าเงิน

ในการคำนวณทางการเงิน อัตราดอกเบี้ยและการวัดมูลค่าของเงินในช่วงเวลาต่าง ๆ ถือเป็นพื้นฐานสำคัญที่ใช้ในการวิเคราะห์ เช่น การคำนวณดอกเบี้ย มูลค่าปัจจุบัน (Present Value) หรือมูลค่าในอนาคต (Future Value) ของเงิน

เพื่อความสะดวกในการเขียนสมการและทำงานเชิงสัญลักษณ์ เราสามารถกำหนดสัญลักษณ์ที่สำคัญได้ดังนี้

from sympy import symbols
# อัตราดอกเบี้ย
i = symbols('i', positive=True)             # i: effective
i_m = symbols('i^{(m)}', positive=True)     # i^{(m)}: nominal interest rate (m ครั้งต่อปี)
r = symbols('r', positive=True)             # r: nominal interest rate m -> oo
d = symbols('d', positive=True)             # d: effective discount rate
d_m = symbols('d^{(m)}', positive=True)     # i: nominal discount rate
# อัตราต่อช่วง
m = symbols('m', integer=True, positive=True) # จำนวนงวดต่อปี

# ปัจจัยมูลค่าปัจจุบัน / อนาคต
v = symbols('v', positive=True)            # v = 1/(1+i)
n = symbols('n', positive=True)            # n ปี

# มูลค่าปัจจุบันและอนาคต
PV, FV = symbols('PV FV')                 # Present Value / Future Value

# ปริมาณเงินหรือจำนวนเงิน
A, P, F, S = symbols('A P F S')           # Annuity, Principal, Future, Sinking fund

1.5.2 มูลค่าปัจจุบันและอนุกรม

ในคณิตศาสตร์การเงิน การคำนวณมูลค่าปัจจุบันของเงินงวด (annuity) และมูลค่าในอนาคตของเงินงวด เป็นหัวข้อหลักที่สำคัญ โดยทั่วไปจะมีสัญลักษณ์เฉพาะที่ใช้เรียกสูตรมาตรฐาน เช่น \(a_{\overline{n}|i}\), \(s_{\overline{n}|i}\), \(\ddot{a}_{\overline{n}|i}\), \(\ddot{s}_{\overline{n}|i}\) เป็นต้น

เงินงวดสิ้นงวด (Ordinary Annuity)

สัญลักษณ์ a_n ใช้แทนค่าปัจจุบันของเงินงวดสิ้นงวดจำนวน \(n\) งวด โดยมีอัตราดอกเบี้ย \(i\) ต่อช่วง ค่าของมันคำนวณจากสูตร

# ปัจจัยมูลค่าปัจจุบันของเงินงวดสิ้นงวด อย่างย่อ
a_n = symbols('a_n')    # a_n = (1 - v^n)/i

สัญลักษณ์ \(a_{\overline{n}|i}\) คือรูปแบบเต็มที่ใช้กันในเอกสารทางการเงิน เพื่อแสดงว่าเป็นมูลค่าปัจจุบันของอนุกรมเงินงวดสิ้นงวด

# หรือสร้างสัญลักษณ์เต็มรูปแบบ
a_n = symbols('a_{\\overline{n}|i}')
a_n  # แสดงผลลัพธ์

\(\displaystyle a_{\overline{n}|i}\)

สัญลักษณ์ s_n ใช้แทน มูลค่าในอนาคต (Future Value) ของเงินงวดสิ้นงวดจำนวน \(n\) งวด

# สัญลักษณ์อย่างย่อ
s_n = symbols('s_n')    # s_n = ((1+i)^n - 1)/i

สัญลักษณ์ \(s_{\overline{n}|i}\) คือรูปแบบเต็มของมูลค่าในอนาคตของอนุกรมเงินงวดสิ้นงวด

# หรือ สร้างสัญลักษณ์เต็มรูปแบบ
s_n = symbols('s_{\\overline{n}|i}')
s_n  # แสดงผลลัพธ์

\(\displaystyle s_{\overline{n}|i}\)

เงินงวดต้นงวด (Annuity Due)

สัญลักษณ์ a_n_due แทนมูลค่าปัจจุบันของเงินงวดต้นงวด โดยแต่ละงวดจ่ายต้นงวดแทนที่จะเป็นสิ้นงวด

# สัญลักษณ์อย่างย่อ
a_n_due = symbols('a_n_due')       # เงินรายงวด ต้นงวด

สัญลักษณ์ \(\ddot{a}_{\overline{n}|i}\) คือรูปแบบมาตรฐานของมูลค่าปัจจุบันของเงินงวดต้นงวด ซึ่งต่างจากกรณีสิ้นงวดเพียงแค่คูณเพิ่มด้วย \(1 + i\)

# สัญลักษณ์เต็ม
a_n_due = symbols('\\ddot{a}_{\\overline{n}|i}')
a_n_due

\(\displaystyle \ddot{a}_{\overline{n}|i}\)

s_n_due ใช้แทนมูลค่าในอนาคตของอนุกรมที่จ่ายต้นงวด

# สัญลักษณ์อย่างย่อ
s_n_due = symbols('s_n_due')

\(\ddot{s}_{\overline{n}|i}\) คือรูปแบบเต็มของมูลค่าในอนาคตของเงินงวดต้นงวด ใช้ในกรณีที่เราสนใจผลรวมเงินสะสมที่ปลายงวดสุดท้าย

# สัญลักษณ์เต็ม
s_n_due = symbols('\\ddot{s}_{\\overline{n}|i}')
s_n_due

\(\displaystyle \ddot{s}_{\overline{n}|i}\)

1.5.3 เงินงวดชำระไม่เท่ากัน

นอกจากเงินงวดที่มีจำนวนคงที่ทุกงวด (level annuity) ซึ่งใช้บ่อยในการคำนวณเบี้ยประกันหรือเงินสำรอง เรายังพบกับกรณีที่ จำนวนเงินงวดเปลี่ยนแปลงในแต่ละงวด เช่น

• เงินงวด เพิ่มขึ้นทีละจำนวนคงที่ เช่น เพิ่มขึ้น 1 หน่วยทุกงวด (Arithmetic Increasing Annuity)

• เงินงวด เพิ่มขึ้นแบบทบต้น เช่น เพิ่มขึ้น 5% ทุกงวด (Geometric Increasing Annuity)

เราสามารถกำหนดสัญลักษณ์แทนกรณีเหล่านี้ไว้ล่วงหน้า เพื่อใช้ในสูตรและสมการต่าง ๆ ดังนี้

# เงินงวดเพิ่มขึ้นตามเลขคณิต/เรขาคณิต
Ia_n = symbols('Ia_n')             # เงินงวดเพิ่มขึ้น 1 หน่วย/งวด (Arithmetic)
Ga_n = symbols('Ga_n')             # เงินงวดเพิ่มขึ้นแบบ geometric

1.5.4 Yield และ Internal Rate of Return (IRR)

ในโลกของการเงินและการลงทุน การประเมินผลตอบแทนจากการลงทุนระยะยาว เช่น พันธบัตร ประกันชีวิตแบบมีเงินปันผล หรือการลงทุนในสินทรัพย์ทางการเงินอื่น ๆ จำเป็นต้องใช้แนวคิด อัตราผลตอบแทนภายใน (IRR) หรือ ผลตอบแทนของพันธบัตร (YTM)

• IRR (Internal Rate of Return) คือ อัตราดอกเบี้ยที่ทำให้มูลค่าปัจจุบันของกระแสเงินสดเท่ากับศูนย์

• YTM (Yield to Maturity) คือ อัตราผลตอบแทนที่ผู้ลงทุนจะได้รับหากถือพันธบัตรจนครบกำหนด

การกำหนดตัวแปรสัญลักษณ์เหล่านี้จะช่วยให้เขียนสมการคำนวณกระแสเงินสดในลักษณะทั่วไปได้อย่างยืดหยุ่น

IRR = symbols('IRR', positive=True)
YTM = symbols('YTM', positive=True)

1.6 การเปลี่ยนฟังก์ชันสัญลักษณ์เป็นฟังก์ชันเชิงตัวเลข

สาเหตุที่ต้องการแปลงฟังก์ชันเชิงสัญลักษณ์เป็นฟังก์ชันเชิงตัวเลขก็เพื่อใช้สำหรับการวาดแผนภาคหรือกราฟที่สวยงามกว่าในการวาดกราฟด้วยซิมไพ ดังตัวอย่างต่อไปนี้

from sympy import symbols,  lambdify
import numpy as np
import matplotlib.pyplot as plt
# สร้างตัวแปรเชิงสัญลักษณ์ t
t = symbols('t')
# เงินสะสมของดอกเบี้ยทบต้นที่อัตราดอกเบี้ย 5% ณเวลาที่ t
expr = (1.05)**t 
# แปลงเป็นฟังก์ชัน Python (numerical FV =(1.05)^t
FV = lambdify(t, expr, modules=['numpy'])

# สร้าง array เริ่มจากจุด 0 ไปถึง 100 จำนวน 100 จุด
T = np.linspace(0, 100, 100)
Fv = FV(T)
# สร้างกราฟ
plt.plot(T, Fv)
plt.title('FV = (1.05)^t')
plt.grid(True)
plt.show()

from sympy import symbols,  Lambda, simplify

# สร้างตัวแปรสัญลักษณ์
i, t, n = symbols('i t n', positive=True)

# นิยามฟังก์ชันคณิตศาสตร์การเงินแบบ symbolic ด้วย Lambda

pv = Lambda((i, t), 1 / (1 + i)**t)            # Present Value: PV(i, t)
fv = Lambda((i, t), (1 + i)**t)                # Future Value: FV(i, t)
a_n = Lambda((i, n), (1 - (1 + i)**(-n)) / i)  # Present value of ordinary annuity
# Present value of annuity-due
a_n_due = Lambda((i, n), ((1 - (1 + i)**(-n)) / i) * (1 + i)) 
s_n = Lambda((i, n), ((1 + i)**n - 1) / i)     # Future value of ordinary annuity
# Future value of annuity-due
s_n_due = Lambda((i, n), (((1 + i)**n - 1) / i) * (1 + i))   

# ทดสอบแสดงนิยาม
print('PV(i, t) =', simplify(pv(i, t)))
print('FV(i, t) =', simplify(fv(i, t)))
print('a_n(i, n) =', simplify(a_n(i, n)))
print('a_n_due(i, n) =', simplify(a_n_due(i, n)))
print('s_n(i, n) =', simplify(s_n(i, n)))
print('s_n_due(i, n) =', simplify(s_n_due(i, n)))

PV(i, t) = (i + 1)**(-t)
FV(i, t) = (i + 1)**t
a_n(i, n) = 1/i - 1/(i*(i + 1)**n)
a_n_due(i, n) = (i + 1)**(1 - n)*((i + 1)**n - 1)/i
s_n(i, n) = ((i + 1)**n - 1)/i
s_n_due(i, n) = (i + 1)*((i + 1)**n - 1)/i

Lambda() และ lambdify() ดูคล้ายกัน แต่ทำงานต่างกัน อย่างสิ้นเชิง

สรุปเปรียบเทียบ

ฟังก์ชัน	Lambda() (ของ SymPy)	lambdify() (ของ SymPy)
ประเภท	symbolic function	numeric function wrapper
การประเมินค่า	ยังคงอยู่ในโลกสัญลักษณ์ (symbolic)	แปลงเป็น ฟังก์ชัน Python ปกติ (หรือ NumPy)
ใช้กับอะไร	งาน symbolic เช่นนิยามฟังก์ชันในสูตร	งาน plotting, คำนวณตัวเลข, หรือใช้ร่วมกับ NumPy
Return type	sympy.Lambda	ฟังก์ชัน Python (def หรือ lambda แบบ runtime)

1. Lambda() นิยามฟังก์ชันเชิงสัญลักษณ์ (symbolic)

from sympy import symbols, Lambda
x = symbols('x')
f = Lambda(x, x**2 + 1)

f   # ค่าx ส่งไปยังฟังก์ชัน f = x^2+1

\(\displaystyle \left( x \mapsto x^{2} + 1 \right)\)

f(x)  # ใส่ตัวแปรเชิงสัญลักษณ์ x เข้าไปในฟังก์ชัน f

\(\displaystyle x^{2} + 1\)

f(3)        # ใส่เลข 3 ลงไปยังฟังก์ชัน 3

\(\displaystyle 10\)

f(3) ทำงานได้เพราะ 3 ถูกแปลงเป็น symbolic Integer(3) โดยอัตโนมัติ

2. lambdify() แปลงเป็นฟังก์ชัน Python/NumPy สำหรับคำนวณจริง

from sympy import lambdify
f_num = lambdify(x, x**2 + 1)
f_num 

<function _lambdifygenerated(x)>

f_num(x)

\(\displaystyle x^{2} + 1\)

f_num(3)

10

ใช้กับ np.linspace(), plotting, numerical methods ได้ทันที

x_vals = np.linspace(-10, 10, 5)
print(f_num(x_vals))

[101.  26.   1.  26. 101.]

แต่ ถ้าเป็นฟังก์ชันที่สร้างจาก Lambda จะไม่สามารถใช้งานได้

f(x_vals) 

Warningหมายเหตุ

ผู้เขียนไม่ได้แสดงค่าความผิดพลาด (error) ในหนังสือนี้เนื่องจากเป็นข้อความที่ยาวเกินไป ให้ผู้อ่านลองเขียนคำสั่งและดูผลที่เกิดขึ้นด้วยตนเอง

ฟังก์ชัน f ที่สร้างขึ้นไม่รองรับอาเรย์ x_vals ทำให้ไม่สามารถวัดวาดกราฟด้วย matplotlib ได้

# Lambda แบบ numeric สำหรับ plot
expr = x**2 -x +2
f_num = lambdify(x, expr, 'numpy')
x_vals = np.linspace(-10, 10, 100)
y_vals = f_num(x_vals)

plt.plot(x_vals, y_vals)
plt.title('Graph of x² - x + 2')
plt.grid()
plt.show()

สำหรับฟังก์ชันที่ซิมไพอื่นๆ ที่เกี่ยวข้องจะทยอยนำเสนอในบทต่อๆ ไป

[1]

จลีพร โกลากุล และ จุฬาลงกรณ์มหาวิทยาลัย. คณะพาณิชยศาสตร์และการบัญชี, คณิตศาสตร์การเงิน, พิมพ์ครั้งที่ 2. กรุงเทพฯ: คณะพาณิชยศาสตร์และการบัญชี จุฬาลงกรณ์มหาวิทยาลัย, 1984.

[2]

ประสิทธิ์ พยัคฆพงษ์, คณิตศาสตร์การเงินและการลงทุน, พิมพ์ครั้งที่ 1. กรุงเทพฯ: สำนักพิมพ์มหาวิทยาลัยเกษตรศาสตร์, 2004.

[3]

S. G. Kellison, The Theory of interest. ใน Irwin series in insurance and economic security. Homewood, Ill: R. D. Irwin, 1970.

[4]

มานพ วราภักดิ์, ทฤษฎีดอกเบี้ย = Theory of interest. กรุงเทพฯ: สำนักพิมพ์แห่งจุฬาลงกรณ์มหาวิทยาลัย, 2006.

[5]

A. Meurer และคณะ, “SymPy: symbolic computing in Python”, PeerJ Computer Science, ปี 3, น. e103, ม.ค. 2017, doi: 10.7717/peerj-cs.103.

[6]

J. D. Hunter, “Matplotlib: A 2D graphics environment”, Computing in Science & Engineering, ปี 9, ฉบับที่ 3, น. 90–95, 2007, doi: 10.1109/MCSE.2007.55.