Tunoblog - NooB

ร้านกาแฟหกรด

2007-11-25T15:07:00.000+07:00

ไปเจอร้านกาแฟนี้ใน San Francisco ชื่อร้านมันตลกมากจนต้องเอามาให้ดู!

หัดออกเสียงแบบชาว California: เดาเสียง s z จากตัวสะกด

2007-06-11T10:21:00.000+07:00

ไม่ได้เขียนอะไรใน blog นี้ประมาณเวลาตั้งครรภ์ได้ ตอนนี้ใกล้จะกลับไทยแล้ว ก็ขอเขียนซักหน่อยละกัน :P

เนื่องด้วยภาษาอังกฤษที่เราเรียนในเมืองไทย เน้นให้อ่านออก เขียนได้ แต่ไม่ได้ให้ออกเสียงถูก พอมีโอกาสมาอยู่เมืองนอกแล้ว มันก็น่าจะฝึกส่วนที่ขาดหายไปใช่มะ แล้วก็สำเนียงภาษาอังกฤษของคนแถวนี้ (California) เค้าถือว่ามาตรฐานของ American English ด้วย ไหน ๆ มาอยู่ Stanford แล้ว ก็ลงเรียนวิชา Pronunciation ซะเลย :D ตอนแรกก็ไม่นึกหรอกว่ามันจะน่าสนใจขนาดนี้ เรียน ๆ ไป รู้สึกว่ามีสิ่งที่ไม่รู้เยอะแฮะ (แต่เรียนจบคอร์สแล้ว สำเนียงก็เหมือน ๆ เดิมอะนะ)

คิดว่าหลาย ๆ คนที่เรียนอังกฤษในเมืองไทยคงยังไม่เคยรู้เรื่องพวกนี้ ก็เลยจะเอามาฝากกันนี่แหละ (American English อย่างเดียวนะ)

เสียง s กับ z

คิดว่าทุกคนคงรู้อยู่แล้วว่า s มีเสียงเหมือน "ซ" หรือ "ส" ในภาษาไทย ส่วนตัว z เนี่ย ถึงเราจะไม่มีตัวอักษรที่ออกเสียงเหมือนกัน แต่คิดว่าตัวนี้ไม่น่าจะเป็นปัญหากับคนไทย ถ้าใครไม่รู้ว่า z ออกเสียงยังไง ก็ทำเสียง s (ไม่ได้ออกจากกล่องเสียง) แล้วพยายามเติมเสียงจากกล่องเสียง มันก็จะเป็น z เอง (อันนี้ง่าย)

แล้วเมื่อไหร่ใช้ s เมื่อไหร่ใช้ z หละ?

จะว่าไปมันก็เป็นเรื่องแปลก (คนที่รู้ก็คงไม่แปลกหรอก) ที่คำที่สะกดด้วยตัว s อ่านออกมาเป็น z เยอะมาก กฎสำหรับออกเสียง z เวลาเห็นตัว s ก็มีหลัก ๆ คือ

s ใน -s ที่ใช้เป็นตัวสุดท้ายของคำ ตามหลังเสียง voiced consonant (ไว้จะพูดถึงอีกที) เช่น pens
s ใน -es ท้ายคำที่เป็นพหูพจน์ (ให้ออกเสียงว่า อิซซ ด้วย z)
คำว่า is his Ms.
-sn't -sm เช่น anarchism

ส่วนกฎสำหรับออกเสียง s เวลาเห็นตัว s ก็มีคร่าว ๆ คือ

ss
s ที่ขึ้นต้นคำ และไม่ได้ตามด้วย h, ch
s ที่ลงท้าย prefix เช่น misapprehend disavow
s หลังสระเสียงสั้น (ยกเว้น is his Ms.) เช่น this promise pus
s ใน -s ที่ใช้เป็นตัวสุดท้ายของคำ ตามหลังเสียง voiceless consonant
s หลังพยัญชนะ หน้าสระ เช่น insensitive absinthe lapse alongside forsake
-s? เมื่อ ? เป็นพยัญชนะ voiceless เช่น anarchist
คำ 1 พยางค์ที่ลงท้ายด้วย -ase กับ -oose

นอกจากกฎพวกนี้ ก็คงต้องจำกันแล้วหละ ตัวอย่างที่ต้องจำเช่น:

s หลังสระเสียงยาวใน verb มักจะเป็น z เช่น realise refuse lose ease appease please แต่ loose grease lease cease crease increase decrease decease ใช้เสียง s
s หลังสระเสียงยาวในคำที่ไม่มีรูป verb มักจะเป็น s เช่น dose verbose close(adj) แต่ cheese disease ใช้เสียง z
คำบางคำอ่านต่างกันเมื่อเป็น noun กับ verb เช่น use กับ house ใช้ s เมื่อเป็น noun ใช้ z เมื่อเป็น verb
close ที่แปลว่าใกล้ (adjective กับ adverb) ใช้เสียง s ส่วน close ที่แปลว่าปิด (noun กับ verb) ใช้เสียง z
douse louse mouse ใช้เสียง s แต่ rouse spouse ใช้เสียง z
precise กับ concise ใช้เสียง s ส่วน incise exercise ฯลฯ ใช้เสียง z (ข้อสังเกตุ: precise กับ concise ไม่มีรูป verb)
garrison ใช้เสียง s แต่ visage ใช้เสียง z

เสียง "ซ" หรือ "ส" ที่มาจาก c หรือ sc ให้ออกเสียงเป็น s ทั้งหมด ส่วนที่มาจากตัว z ให้ออกเป็น z ทั้งหมด ยกเว้นคำ Italian (pizza, mezzo, ...) ให้ออกเป็นเสียง s

ตัวอย่าง: เสียงสระเหมือนกัน ทางซ้ายเสียง s ทางขวาเสียง z

place - plays
ice - eyes
miss - Ms.
price - prize
hence - hens
dense - dens
rice - rise
race - raise
race - rays
race - raze
loose - lose
goose - goos
hiss - his
use(noun) - use(verb)
face - phase
bus - buzz
ass - as
lense - lens
(lense กับ lens ความหมายเหมือนกันนะ)
decease - disease
(s ใน decease ใช้เสียง s ส่วน s ทั้งสองที่ใน disease ใช้เสียง z)
close(adj) - close(v)
close(adj) - clothes(n)

ตัวอย่างเปรียบเทียบตัวสะกด ทางซ้ายเสียง s ทางขวาเสียง z (เสียงอื่น ๆ ก็ต่างกัน):

racist - racism
purpose - propose
(purpose สระเสียงสั้น propose สระเสียงยาว)
promise - compromise
(promise สระเสียงสั้น compromise สระเสียงยาว)
analysis - analyses
(analyses เป็นรูปพหูพจน์ ... s ตัวแรกเป็นเสียง s ในทั้งสองคำนะ)
crease - ease
its - is
this - his
intense - intends
laps - labs
motes - modes
docks - dogs
strifes - strives

เรื่อง Stanford

2006-09-27T12:45:00.000+07:00

จะบอกว่า ถ้าจะดูเรื่องเกี่ยวกะชีวิตนู้บสแตนฟอร์ดเนี่ย ให้ไปดูที่ Another Tunoblog แทน ขี้เกียจ update สองที่หนะ

เด็กบ้านนอก - นู้บ

2006-09-21T14:38:00.000+07:00

เผื่อคนที่ไม่รู้ ตอนนี้อยู่ที่ 119 Quillen Court, #500, Stanford CA 94305 นะ วันจันทร์จะเปิดเทอมแล้ว

ไปอยู่ในที่ใหม่ มันก็มีอะไรต้องศึกษาใหม่เยอะนะ ... สถานที่ก็ใหญ่ เดินทางก็ลำบาก ถึงจะฟรีก็เหอะ รู้สึกมันบ้านนอกบ้านนอกไงก็ไม่รู้

ไม่ค่อยมีเวลาเขียนเท่าไหร่เลย ช่วงนี้มีงานมีเหตุการณ์มากมาย ... ไว้มีเวลาแล้วจะมาเขียนอีกเยอะ ๆ ละกัน

ป.ล. เพิ่งรู้ว่า IE มันไม่ยอมให้เขียนสระอาติดกันหลาย ๆ ตัวใน Edit Box อะ แย่จัง

Siam Paragon

2006-08-10T23:40:00.000+07:00

คำอ่าน "Siam Paragon" เป็นภาษาไทยเนี่ย ...

สยามภาระก้น
สยามปลาร้าก้อน (เพี้ยนนิดหน่อย)

มีมากกว่านี้อีกปะ บอกหน่อย

Programming: Space-Time Relation

2006-07-02T20:41:00.000+07:00

ขอเริ่มต้น post ของวันนี้ด้วยการขอโทษก่อนละกัน วันนี้ (จริง ๆ เมื่อวานด้วย) ไม่ได้ไปเยี่ยมบัณฑิตจุฬา ฯ ที่ไปซ้อมรับปริญญา เพราะมีเหตุการณ์สำคัญเกิดขึ้นที่บ้าน ที่คนทั่ว ๆ ไปคงเรียกว่าปัญหาครอบครัวหนะ

แล้วก็ ... เตือนกันอีกครั้งนะ ... ถ้าจะดู post เก่า ๆ ให้มันเป็นลำดับดี ๆ ไปดูที่นี่

Tunoblog Summarized

มันจะมี link มาที่หน้าของแต่ละ post ใน Tunoblog อันนี้

โปรโมตเสร็จ ก็ขอเข้าเรื่องละกัน คราวนี้จะพูดถึงความสัมพันธ์ระหว่าง ความเร็วของ algorithm กับเนื้อที่ memory ที่จะต้องใช้

สำหรับปัญหาปัญหานึง เราอาจจะมีวิธีแก้หลาย ๆ แบบ ซึ่งสำหรับนักเขียนโปรแกรมเนี่ย เค้ามักถามกันว่า "บิ๊กโอ (Big-O = O ใหญ่น่ะแหละ) เท่าไหร่?"

ใครที่ยังไม่รู้จัก O ตัวนี้ ก็ขอพูดคร่าว ๆ ละกัน

O(g) = { f | f(x) เพิ่มไม่เร็วกว่า g(x) เมื่อ x มีค่ามาก ๆ }

จริง ๆ นิยามแบบชัด ๆ มันก็มีอยู่อะนะ แต่ขี้เกียจยกมา ไปดูเอาเองจาก Wikipedia ละกัน :P

มาต่อกันเรื่องหลัก คราวนี้มาสนใจเรื่อง Space-Time ดีกว่า ...

ทฤษฎีสัมพัทธภาพ

ม่ายช่ายและ :P ... จะพูดถึง Big-O ของเวลา กับ เนื้อที่ memory ที่ algorithm ใช้ตะหาก

Sorting Algorithm

ปัญหาการเรียงข้อมูลเนี่ย เป็นปัญหาสุดคลาสสิก ที่น่าเอามาพูดถึงที่สุด วิธีการเรียงที่นิยมสอนกัน มักจะมีอยู่เท่านี้ (ขาดเกินบ้างนิดหน่อย)

Selection Sort - ใช้เวลา O(n²) เมื่อมีข้อมูล n ตัว
Bubble Sort - ใช้เวลา O(n²)
Insertion Sort - ใช้เวลา O(n²)
Shell Sort - ใช้เวลา O(n^1.5) (จริง ๆ มี O(n log²n) นะ ดูที่นี่)
Merge Sort - ใช้เวลา O(n log n)
Quick Sort - ใช้เวลา O(n log n) (เฉลี่ย)
Heap Sort - ใช้เวลา O(n log n)
Bucket Sort - ใช้เวลา O(m + n)
Radix Sort - ใช้เวลา O(n log m)

เมื่อ n คือจำนวนข้อมูล และ m คือขนาดของ domain ของข้อมูล จะเห็นว่า 7 วิธีแรก ทำงานเร็วกว่า 2 วิธีสุดท้ายในกรณีที่ m มากกว่า n มาก ๆ

หนังสือทั่ว ๆ ไป มักจะไม่พูดถึงขนาดของ memory ที่ต้องใช้ เพราะว่า ไม่มีิอันไหนใช้เกิน O(n) ซึ่งเป็นขนาดของ input แต่เราจะลองมองดูซักนิดนะ ว่ามันเป็นยังไง

Selection Sort - ใช้เนื้อที่เพิ่ม O(1)
Bubble Sort - ใช้เนื้อที่เพิ่ม O(1)
Insertion Sort - ใช้เนื้อที่เพิ่ม O(1)
Shell Sort - ใช้เนื้อที่เพิ่ม O(1)
Merge Sort - ใช้เนื้อที่เพิ่ม O(n)
Quick Sort - ใช้เนื้อที่เพิ่ม O(log n) (เฉลี่ย)
Heap Sort - ใช้เนื้อที่เพิ่ม O(1)
Bucket Sort - ใช้เนื้อที่เพิ่ม O(m)
Radix Sort - ใช้เนื้อที่เพิ่ม O(1)

ดู ๆ ไปเหมือน Heap Sort น่าจะดีที่สุด แต่จริง ๆ แล้ว มันมีอะไรมากกว่านี้นิดนึง มาลองดูละเอียดดีกว่า ว่าแต่ละวิธี ต้องการสิ่งอะไรที่ต่าง ๆ กัน (แบบคร่าว ๆ)

Selection Sort - ลูป 2 ชั้น และตัวแปรพักข้อมูลสำหรับการสลับ
Bubble Sort - ลูป 2 ชั้น และตัวแปรพักข้อมูลสำหรับการสลับ
Insertion Sort - ลูป 2 ชั้น และตัวแปรพักข้อมูลสำหรับการแทรก
Shell Sort (กรณีเวลา O(n log²n)) - ลูป 3 ชั้น ตัวแปรสำหรับสร้างลำดับ 2 ตัว และตัวแปรพักข้อมูลสำหรับการสลับ หรือ แทรก
Merge Sort - Recursive 2 ครั้ง ลูป 1 ชั้นที่มีตัวนับ 2 ตัว กับ array พักข้อมูลความยาว n และลูปคัดลอกค่าจาก array พักข้อมูล
Quick Sort - ลูป 1 ชั้นที่มีตัวนับ 2 ตัว ตัวแปรพักข้อมูลสำหรับการสลับ และ Recursive 2 ครั้ง
Heap Sort - ลูป 2 ชั้น 2 ลูป และตัวแปรพักข้อมูลสำหรับการแทรก
Bucket Sort - ลูปกำหนดค่าเริ่มต้น (ใช้เวลา O(m)) ลูปรับ input และลูปแสดง output (ใช้เวลา O(n))
Radix Sort (ฐาน 2) - ลูป 2 ชั้น ชั้นนอกทำซ้ำ log₂m ครั้ง ชั้นในมีตัวนับ 2 ตัว

ถ้าคิดความซับซ้อนของโปรแกรม เป็นเนื้อที่อีกประเภท เราก็พอจะคิดได้ว่า ถ้าใช้เนื้อที่มาก มันก็ทำงานเร็วนะ

Dynamic Programming - Fibonacci Function

อันนี้ คิดว่า หลาย ๆ คนคงคุ้นเคยและรู้อยู่แล้ว หน้าตามันก็ประมาณนี้ (ภาษา C ละกัน)

int fib(int n) { return n <= 1 ? 1 : fib(n - 1) + fib(n - 2); }

จะเห็นว่า code สั้นมาก ดังนั้น จากหลักของเรา พอจะเดาได้ว่า น่าจะมีวิธีทำให้มันทำงานเร็วกว่านี้ แต่ code ยาวกว่านี้ หรือมีตัวแปรเพิ่ม

ลองดูก่อน ว่า เขียนโปรแกรมแบบนี้ ใช้เวลาทำงานเท่าไหร่ ... คำตอบค่อนข้างง่ายนะ เวลาก็คือ O(fib(n)) น่ะแหละ (ว่าไปก็คือ O(αⁿ) เมื่อ α = golden ratio น่ะแหละ)

มันกินเวลาน่าดูเลยนะเนี่ย ลองพยายามทำให้มันเร็วขึ้นสิ ... วิธีง่าย ๆ ก็คือ กำหนดตัวแปรเพิ่มเป็น array ความยาว n แล้วก็คิดค่าไล่ตั้งแต่ f(0) ถึง f(n) ไง หยั่งงี้ f(...) ตัวที่เคยคิดแล้ว ก็ไม่ต้องคิดซ้ำ

int fib(int n) { return a[n] > 0 ? a[n] : a[n] = fib(n - 1) + fib(n - 2); }

แล้วกำหนดค่าเริ่มต้นให้ a[0] = 1, a[1] = 1 และ a[อื่น ๆ] = -1

จริง ๆ มันประหยัดเนื้อที่ได้อีกนะ แต่คราวนี้โปรแกรมจะซับซ้อนละ ...

int fib(int n)

int f, last1, last2;

if (n <= 1) return 1;

last1 = 1;

last2 = 1;

for (--n; n > 0; --n)

f = last1 + last2;

last2 = last1;

last1 = f;

return f;

}

จะเห็นว่า เหลือตัวแปรแค่ 3 ตัว (คือ memory O(1)) แลกกับ code ที่ยาวขึ้นอีกนิดนึง

จริง ๆ ยังทำให้มันเร็วกว่านี้ได้อีกแหละ แต่คราวนี้ code จะยาวขึ้นเยอะเลย แล้วจะเร็วขึ้นเฉพาะเมื่อ n เยอะมาก ๆ ๆ ๆ ๆ เท่านั้น

เอาเป็นว่า หยุดแค่นี้ก่อนดีกว่า

Programming: Stack and Recursion

2006-06-30T23:31:00.000+07:00

ไม่ยอมเขียนมาซะนาน ขอกลับมาทำบ้างซักครั้งละกัน ... คิดถึงจัง ความรู้สึกนี้ :D

คราวนี้จะพูดถึงเรื่องการเขียนโปรแกรมซักหน่อยนะ คาดว่าจะเป็นประโยชน์กับ programmer รุ่นเด็ก ๆ บ้างนะ

Stack and Recursion

หลาย ๆ คนคงรู้อยู่แล้วว่าทั้งสองอย่างนี้มันคืออะไร และมันเกี่ยวกันยังไง ... ใครไม่รู้อ่านต่อละกัน :P

Stack

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

Recursion

การทำซ้ำ ๆ ที่เกิดจากการฟังก์ชันที่เรียกกันเป็นวง เช่น f เรียก g แล้ว g เรียก h แล้ว h เรียก f ไปเรื่อย ๆ
สิ่งที่จำเป็นในการเขียนโปรแกรมแบบ Recursive ก็คือ จะต้องมีเงื่อนไขการหยุด

แล้วสองอย่างนี้ มันเกี่ยวข้องกันยังไงหละ?

จริง ๆ อยากให้ไปอ่านเรื่องที่ทำ Virtual Machine จัง แต่มันคงจะยาวไปเนอะ ... สรุปเลยละกัน :P ง่าย ๆ ก็คือ ... ทุกครั้งที่เรียกฟังก์ชัน เราต้องเพิ่มข้อมูลบางอย่างใน Stack ของ CPU แล้วพอฟังก์ชันทำงานเสร็จ เราก็จะเอาของพวกนั้นออก

แปลว่า ... ที่เราสามารถเขียนโปรแกรมแบบ recursive ได้เนี่ย ก็เพราะว่า CPU มันมี Stack อยู่

และก็แปลว่า ... เราสามารถสร้าง Stack ขึ้นเอง แล้วก็ไม่ต้องไปรบกวน Stack ของ CPU ได้เหมือนกัน

ลองดูตัวอย่างเลยละกัน สมมติว่าเรามีฟังก์ชันที่เขียนแบบ recursive ตัวนึง

 function f(x)

begin
if x <= 0 then return 0;

else return 2x - 1 + f(x - 1);

end

ถ้าเรามี Stack เราจะเขียนแบบไม่ recursive ได้เป็น

 function f(x)

begin
push x onto Stack;

  push "not done" onto Stack;

  while Stack is not empty

do

assign op ← Top of Stack;

Remove Top of Stack;

assign x ← Top of Stack;
Remove Top of Stack;
if op = "not done" then

begin

push x onto Stack;

 push "done" onto Stack;

if x <= 0 then do nothing;

 else

 begin

 push x - 1 onto Stack;

push "not done" onto Stack;
end
end

 else if op = "done" then

 begin

if x <= 0 then assign ReturnValue ← 0;
else assign ReturnValue ← 2x - 1 + ReturnValue;
end

  end while

return ReturnValue;

end

จะเห็นว่า มันยาวขึ้นมาก -_-'' จริง ๆ จะทำให้สั้นกว่านี้ก็ได้อีกเยอะหนะนะ แต่นี่เป็นตัวอย่างการแปลงแบบตรงไปตรงมา ฟังก์ชันอะไรเราก็แปลงแบบนี้ได้

แอบอัพเดท

2006-06-30T17:07:00.000+07:00

โทษทีที่ยังไม่ได้เอารูปตอนไปยุโรปมาลงให้ จะเอามาให้ดูจริง ๆ แหละ แต่รอก่อนนะ ตอนนี้ขอแอบกลับไปเขียนเรื่องบ้า ๆ ต่อก่อน

ฟันคุด

2006-06-27T22:18:00.000+07:00

ไปผ่าฟันคุดมาเมื่อวันศุกร์ที่แล้วหนะ . . . ผ่าข้างล่างสอง ถอนข้างบนสอง

ก่อนหน้านี้ มีคนขู่ไว้เพียบเลย - -'' พอทำเอง มันก็ไม่ได้น่ากลัวขนาดนั้นซะหน่อย

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

พอถึงเวลาจริง ที่เจ็บที่สุดก็เห็นจะเป็นเข็มฉีดยาชานี่แหละ (มันก็ไม่ได้เจ็บมากหรอก บริจาคเลือดยังเจ็บกว่าอีก)

เริ่มแรก เค้าฉีดยาชาเสร็จแล้วก็รอแป๊บนึง แล้วก็เอาคีมมางัดแงะดึงฟันข้างบนออก เดี๋ยวเดียวเสร็จเลย รู้สึกว่าอะไร ๆ มันก็เร็วกว่าที่คิดนะ

แต่อีกสองซี่ที่ต้องทำให้เป็นชิ้น ๆ เนี่ย ใช้เวลานานกว่าที่คิดแฮะ

ช่วงที่รู้สึกเสียว ๆ ก็มีนะ ช่วงแรกคือ ตอนที่หมอกำลังขัดเนื้อฟันข้างขวาออกเนี่ย เค้าออกแรงเยอะมาก จนรู้สึกว่ามันตึงที่ข้างนอกเลย

อีกช่วงนึงก็ ... จริง ๆ ไม่ได้รู้สึกเจ็บหรือเสียวฟันอะนะ เป็นความเสียวทางความคิดหนะ คือประมาณว่า ผู้ช่วยหมอเค้าไม่ใส่แว่นแล้วมองเห็นไหมไม่ชัด (สีมันคล้าย ๆ น้ำลาย) หมอก็ต่อว่า ว่าถ้ามองไม่ชัด คราวหน้าต้องใส่แว่นมานะ ไม่งั้นไม่ต้องมาช่วย - -'' เสียวมั้ยหละ

แล้วหลังจากนั้นแป๊บเดียว หมอก็บอกอีกว่า ไหมเนี่ย ผู้ช่วยดึงไม่แน่น ... แล้วหมอก็ทำอะไรอีกก็ดูไม่รู้เรื่อง อาจจะเอาออก เย็บใหม่ก็ได้ (ยังไงตอนนี้ก็ดูไม่ออกแล้ว)

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

วันแรกหลังจากทำ ก็ไม่เจ็บนะ แค่รำคาญว่าเวลากินอะไร เศษมันจะติด ๆ แล้วเอาออกไม่ได้ แล้วก็เจ็บนิดหน่อยเวลากลืน เพราะว่ามีแผลที่ลิ้นนิดนึง

วันที่สองก็ รู้สึกเหมือนวันแรก ... ไม่ค่อยรู้สึกว่ามันจะดีขึ้นแฮะ - -''

วันที่สามเนี่ย เริ่มรู้สึกดีขึ้นละ แต่ก็ยังกินอะไรที่ต้องเคี้ยวไม่ได้หนะ ยังกินแต่ไข่ตุ๋น มันฝรั่งบด แล้วก็โจ๊ก

วันนี้วันที่สี่แล้ว ... ทำไมมันรู้สึกเจ็บ ๆ อะ T_T ... ความเจ็บมันมีการหน่วงเวลาด้วยแฮะ ...

กลับมาละ

2006-05-21T11:26:00.000+07:00

หลังจากวันจันทร์ที่แปดแล้ว ก็หาเน็ตไม่ได้เลยอ่า เอาเป็นว่า สรุปการไปเยือนเมืองนอกเอาทีเดียวเลยละกัน ... อ้อ ยังไม่ได้เอาภาพจากกล้องมาลงหนะ อ่านแห้ง ๆ ไปก่อนละกัน :P

ก็ ... ต่อจากตอนที่แล้ว ก็ไปโรงงานกะโรงแรม สลับกันไปเรื่อย ๆ หละ จนวันที่สิบสอง ก็ขึ้นเครื่องบินไป Venezia จากสนามบิน Marco Polo ก็มีคนมารับไปโรงแรมแถว ๆ Padova ชื่อว่า Ibis

ที่โรงแรมนี้ ลิฟท์ก็แปลกไปอีกแบบ คือมันไม่มีปุ่มเปิดประตู (โรงแรมที่แล้วไม่มีปุ่มปิด)

สภาพส่วนใหญ่ในโรงแรมนี้ ดีกว่าโรงแรมที่แล้วนะ แต่ว่า ... มันไม่มีเน็ต T_T

เย็นวันศุกร์ ได้ไปแวะซุปเปอร์มาร์เก็ตใกล้ ๆ โรงแรมด้วยหละ รู้สึกว่าของมันแพงจัง ... เดินอยู่ในนั้นพอประมาณ ก็ซื้อน้ำเปล่ามา กับขนมนิด ๆ หน่อย ๆ

พอวันเสาร์ ก็ไปเดินเล่นในเมือง Padova มีร้านเสื้อผ้า เครื่องแต่งกาย เยอะมาก แล้วก็มีตลาดนัดด้วย ดูคล้าย ๆ เมืองไทยเลยแต่ว่าบรรยากาศมันดีจัง ติดอยู่ตรงที่น้ำดื่มมันแพง ... เดิน ๆ แล้วหิวน้ำ ก็ไม่ค่อยอยากซื้อ

ตอนกลางวันกินข้าวที่ Pizzeria อะไรก็ไม่รู้ จำชื่อไม่ได้ สั่งพิซซ่ากินกับพ่อคนละถาด (ราคาถาดละแปดยูโร) ถาดมันใหญ่กว่าที่คิดแฮะ แต่ก็กินจนหมดได้หละน่า!

หลังจากนั้นก็เดิน ๆ ไปเรื่อย ๆ ไม่ได้ซื้ออะไรเลย :( ก็มันไม่มีอะไรน่าซื้อหนิ ): ขึ้นรถเมล์กลับโรงแรม แล้วก็กินข้าวเย็นที่โรงแรม ... จบวัน

วันอาทิตย์ ทุกอย่างปิดหมด รถเมล์ไม่วิ่ง ถ้าจะไปไหน ต้องเรียกแท็กซี่ราคาสุดโหด ก็เลยดิ้น ๆ อยู่แค่ในโรงแรม T_T นอนแต่หัวค่ำ เตรียมไปทำงานเช้าวันจันทร์

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

นั่งต่อไปอีกประมาณครึ่งชั่วโมง คราวนี้ทางขวามือไม่มีภูเขาแล้ว แต่เป็นเมืองแทน มองเมืองจากตรงนี้ก็สวยดีแฮะ

แล้วอีกประมาณสิบห้านาที ก็ถึงที่หมาย ... โรงงานอีกแห่ง

คุย ๆ กะเค้า ถึงประมาณบ่ายสาม ก็ต้องกลับ Venezia แล้ว เพราะว่าจะต้องขึ้นเครื่องบินกลับไป Roma เพื่อจะไปต่อเที่ยวบินไปยัง Frankfurt

กลับไปถึง Roma ก็ไม่มีโรงแรมพักในเมืองอีก ต้องออกจากเมือง ไปพักโรงแรมใน Pomezia (คนละโรงแรมกับครั้งแรกนะ) ปุ่มในลิฟท์ของโรงแรมนี้เนี่ย ... คราวนี้ มันมีเลข 0 ถึง 9 เรียงเหมือนเครื่องคิดเลขเลย แต่ตึกมันมีไม่ถึง 9 ชั้นอะ ...

นอน ตื่น วันอังคารละ คราวนี้ บินจากสนามบิน Fiumicino ไปสนามบิน Frankfurt

เห็นภาษาเยอรมันแล้ว รู้สึกว่าอ่านยากกว่าอิตาลีเยอะเลย (คือ เดาความหมายไม่ค่อยได้เลย) คำที่รู้ก็เลยมีน้อยกว่า ... คือ ได้ประมาณเนี้ย

eingang = ทางเข้า
ausgang = ทางออก
toiletten = ส้วม
fahrkarten = ตั๋ว
bahnhof = สถานีรถราง/รถไฟ
haupt = หลัก (head, main)
platz = place
markt = market

โรงแรมที่พัก ชื่อว่า Winter's Eurotel Boardinghouse อยู่ในเมือง Offenbach ที่ไม่ได้พักใน Frankfurt ก็เพราะว่าจองโรงแรมใน Frankfurt ไม่ทัน มันเต็มหมดเลย (หรือไม่ก็แพงสุด ๆ) ที่นี่ มีอินเทอร์เน็ตแบบไร้สายนะ แต่ว่า ราคายี่สิบสี่ยูโรครึ่ง ต่อ ยี่สิบสี่ชั่วโมง เลยไม่เอา

วันพุธ ตื่นเช้าหน่อย ไปดูงาน Achema 2006 ละ ... ในนี้ ถ่ายรูปไม่ค่อยได้หนะ เลยไม่มีรูปมาโชว์เยอะเท่าไหร่

งานนี้ใหญ่มากเลย สถานที่จัดงานเรียกว่า Messe Frankfurt มี Hall ทั้งหมดสิบ Hall แต่ละ Hall มีขนาดเท่าศูนย์ ฯ สิริกิติ์เลยมั้ง แล้วยังให้เดินได้ Hall ละหลาย ๆ ชั้นด้วย ... เดินยังไงจะครบเนี่ย

ค่าบัตรเข้างาน เค้าคิดคนละยี่สิบสามยูโร งานเปิดวันละเก้าชั่วโมง คือตั้งแต่เก้าโมงเช้า ถึงหกโมงเย็น ดังนั้น ค่าเข้าชมงาน ถ้าอยู่ตลอดเก้าชั่วโมง ก็ตกเฉลี่ยชั่วโมงละ 2.56 ยูโร (ประมาณนาทีละสองบาท)

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

จริง ๆ วัฒนธรรมการมัดจำภาชนะเนี่ย มันก็มีหลายประเทศแล้วแหละ ... น่าแปลกเหมือนกัน ที่อิตาลีเค้าไม่มีแบบนี้

ตอนเย็น พองานปิด ก็เดินไปที่ Frankfurt Hauptbahnhof แล้วขึ้นรถไฟสาย S9 ไปที่ Offenbach Marktplatz กะจะหาของกิน ที่ไหนได้ เค้าปิดกันเกือบหมดแล้ว ... เหลือ KFC เปิดอยู่ ไปกินก็ได้ - -''

วันพฤหัสก็ ไปดูงานอีกวัน ไม่มีไรมากหรอก ก็อยู่ในงานทั้งวัน ตอนเย็นก็ไปหาของกิน แต่คราวนี้ ไม่ได้ไป KFC ละ เพราะว่าออกจากงานก่อนเวลาปิดนิดนึง ร้านอาหารอื่นเค้ายังไม่ปิด วันนี้ไปกินขาหมูเยอรมันที่ร้าน ... ลืมชื่อไปแล้ว :P

วันศุกร์ ไปเที่ยวละ คราวนี้ เริ่มเดินจาก Frankfurt Hauptbahnhof ไปยัง Hauptwache แถวนี้ร้านขายของเยอะมากเลย มี Department Store แปดชั้นด้วย ... ของที่ขายก็เหมือน ๆ ร้านในกรุงเทพ ฯ นี่แหละ ... ที่ต่างจากห้างของเมืองเราก็มีบันไดเลื่อนนี่แหละ ... ชั้นนึงมันต่อกับบันไดเลื่อนแปดอันหนะ สะดวกดี ... (ถ้าไม่เข้าใจ รอดูภาพละกัน)

อยากจะซื้อของกลับไปฝากหลาย ๆ อย่างนะ แต่มันมีแต่ช็อกโกแล็ตอะ - -''

วันเสาร์แล้ว วันนี้จะกลับละ แต่ขอไปซื้อของฝากอีกนิดนึงก่อน ... เครื่องบินเค้าเรียกเข้าตอนบ่ายสองสิบห้านาที บังเอิญว่าไปถึงสนามบินแต่เช้า ก็เลยมีเวลาเดินหาของนานหน่อย ... แย่จัง มีเวลาเยอะ แต่ของมันดันมีน้อย ... ไป ๆ มา ๆ ก็มีแต่ช็อกโกแล็ตอะ

บ่ายสามนิด ๆ เครื่องบินก็เริ่มปลดเปลื้อง ... บนเครื่องบินคราวนี้ ฉายหนังสองเรื่อง เรื่องแรกคือ Prime อีกเรื่องคือ King Kong

... หมดละ ถึงกรุงเทพ ฯ ซะที!

วันนี้ก็ยาวอีกแล้ว

2006-05-08T23:50:00.000+07:00

ตื่นตอนเช้า กินอาหารเช้า แต่งตัว ... พอถึงเก้าโมงก็มีคนมารับไปโรงงาน

ถ่ายรูปโรงงานเค้าได้ซักสิบกว่า ๆ รูป กล้องดันแบตหมด - -'' ... ช่างมัน พรุ่งนี้ค่อยไปถ่ายใหม่ละกัน (จริง ๆ แบตมันก็อยู่ใกล้ ๆ แหละ แต่ไม่มีโอกาสไปหยิบ)

ในโรงงานเค้ามีตู้ขายกาแฟร้อนด้วย หยอดได้แต่เหรียญนะ ... ใกล้ ๆ ตู้ก็มีป้ายห้ามสูบบุหรี่ (ถ้าสูบ จะถูกปรับตั้งแต่ 28.5 ถึง 285 ยูโร) แต่คนงานเค้ามาสูบตรงนี้เพียบเลย ... ก็มันสูบกันทุกคนหนิเนอะ

พอบ่ายโมง เค้าก็พาไปกินข้าวกลางวัน เป็นโรงอาหารของโรงงานแหละ แต่อาหารก็พอใช้ได้นะ ... (ดีกว่าข้าวกลางวันของสาธิตจุฬาฯ ฝ่ายประถม แน่ ๆ)

ประมาณบ่ายสอง ก็กลับไปฟังเค้าบรรยายเรื่องเครื่องมือ เอา drawing มาให้ดูเพียบเลย ... เริ่มรู้สึกว่าตัวเองกะเหรี่ยงแฮะ ไม่รู้จักเครื่องหมายเค้าเลย (แต่พอฟัง ๆ แล้วก็เริ่มจะเข้าใจบ้างหละ)

ก่อนจะไปกินข้าวเย็น เรื่องสุดท้ายที่เค้าบรรยายก็คือ Plasma Sterilizer ซึ่งผู้ผลิตรายที่ดังที่สุดคือ Johnson & Johnson ทำอยู่เจ้าเดียวมาสิบปีแล้ว เพิ่งจะมีคนอื่นเริ่มทำก็ปีที่แล้วเนี่ยแหละ การทำงานของมันก็เข้าใจไม่ยากนะ แต่ทำยากจัง เค้าบอกว่า ต้องใช้ High Vacuum Pump เพื่อทำความดันภายใน chamber ให้ได้ต่ำถึง 0.01 millibar สัมบูรณ์ จากนั้นก็พยายามทำให้อิเล็กตรอน หลุดออกจากโมเลกุลของอากาศที่ยังเหลืออยู่ โมเลกุลมันก็จะไวต่อสนามไฟฟ้าเพราะมันมีประจุ ส่วนอิเล็กตรอนที่หลุดออกไป มันก็ไวเหมือนกัน พอของพวกนี้วิ่งไปชนกับสารอินทรีย์ พันธะมันก็จะแตกออกง่าย ๆ เค้าก็เลยใช้วิธีนี้ฆ่าเชื้อ ... เพื่อจะทำให้อิเล็กตรอนมันหลุดง่าย ๆ เค้าก็ใส่ก๊าซที่มีความเสถียรต่ำ เพิ่มลงไปด้วย (อันนี้เค้าใช้ H₂O₂)

ข้อดีของวิธีนี้ก็คือ ใช้อุณหภูมิต่ำ คือ ประมาณ 40 - 55 °C เท่านั้น เลยใช้กับพลาสติกหรือวัสดุไม่ทนความร้อนได้ แต่ข้อเสียก็คือ ของที่ใส่เข้าไปต้องแห้งจัด ๆ

ความรู้ที่ได้เพิ่มตรงนี้มีสองเรื่อง คือ

เหตุผลที่ต้องให้ของของเรา แห้งจัด ๆ ก็เพราะว่า ที่ความดัน 0.01 mbar สัมบูรณ์เนี่ย จุดเดือดของน้ำจะต่ำมาก (เกือบ 0°C) น้ำทั้งหมดจะกลายเป็นไอ ทำให้ปริมาณก๊าซใน chamber เพิ่มขึ้น ซึ่งก็แปลว่า ความดันจะเพิ่มด้วย มันก็จะไม่ใช่ 0.01 mbar แล้ว ตัว vacuum pump ต้องดูดเอาพวกนี้ออกให้หมดด้วย กระบวนการแบบนี้จะกินแรง pump มาก ๆ บางครั้งเครื่องอาจจะหยุดทำงานไปเลย แล้วแจ้งเตือนว่าความชื้นสูงเกินไป
สถานะของก๊าซที่มีประจุเนี่ย เรียกว่า plasma (กะเหรี่ยงมั้ยเนี่ย ไม่รู้มาก่อน :P)

ถึงตอนเย็นเค้าก็พาไปกินข้าวเย็น จะบอกว่า สองทุ่มแล้วแหละ แต่ฟ้ายังไม่มืดเลยนะ

ที่ร้านอาหาร เค้าก็สอนภาษาอิตาลีให้นิด ๆ หน่อย ๆ เอาสนุก ส่วนใหญ่คือ จะแปลเมนูภาษาอิตาลีให้ฟัง (ร้านนี้ไม่มีเมนูภาษาอังกฤษ) จำได้นิดเดียวเอง ประมาณเนี้ย ...

acqua = water
antipasto = appetizer
zucchero = sugar

salmone = salmon
melone = melon
limone = lemon

fritto = fried
misto = mixed

mare = sea
pesce = fish
pescatore = fisherman
calamari = squid(s)
patata = potato
funghi = mushroom(s)

อ้อ ... แล้วก็ calcium เนี่ย เค้าอ่านว่า "คัลชุ่ม" แหละ

กินเสร็จก็กลับโรงแรมเลย ... ตอนนี้ก็ เลยเที่ยงคืนแล้วอ่า ... ไปนอนละ

วันนี้ยาวจัง

2006-05-07T16:38:00.000+07:00

กะจะเอารูปมาให้ดูด้วย แต่ว่าลืมเอาสายต่อกล้องมา เลยเอาลงเครื่องคอมพ์ไม่ได้ T_T เล่าให้ฟังเป็นตัวอักษรอย่างเดียวก่อนละกัน

ประมาณเที่ยงคืนครึ่ง วันนี้ ขึ้นเครื่องบิน สายการบินไทย ประตูยี่สิบสี่ ปลายทาง กรุงโรมนะครับ นั่งรอจนเที่ยงคืนห้าสิบห้า เครื่องบินก็เริ่มเปลื้องผ้า (Take Off)

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

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

ตรงที่ตรวจหนังสือเดินทางเนี่ย คนแน่นมากกกก ... กว่าจะออกจากสนามบินได้ ประมาณชั่วโมงนึงแหนะ ... จะบอกว่า ห้องน้ำในสนามบิน Fiumicino เนี่ย แย่กว่าดอนเมืองพอควรเลย

ออกมา ก็มีคนขับรถมารับ ... รู้สึกไม่ค่อยคุ้นเคยกับรถชิดขวาเลยแฮะ ... นั่งรถประมาณครึ่งชั่วโมงก็ถึงโรงแรม Hotel Centrale ใน Pomezia

เนื่องจาก Pomezia เป็นย่านอุตสาหกรรม ก็เลยไม่มีที่ท่องเที่ยวให้ดูเลย ... แต่ที่แย่กว่านั้น วันนี้วันอาทิตย์ครับ ... เมืองหยั่งกะเมืองร้างแหนะ มีแต่ตึก ไม่มีคน ไม่มีร้านขายของ ... จริง ๆ มีอยู่ร้านนึงใกล้ ๆ โรงแรม แต่ว่ามันปิดวันอาทิตย์หนะ

ส่วน ตัวโรงแรม Hotel Centrale เนี่ย ก็ไม่ใช่โรงแรมหรูหราอะไรเลย ไว้หาสายต่อกับกล้องได้แล้วจะเอารูปให้ดู ลิฟท์ยังมีแบบที่กดปุ่มแล้วไฟไม่ขึ้น ข้างในก็ไม่มีจอบอกว่าอยู่ชั้นไหนแล้ว ...

แต่สิ่งแปลก ๆ เท่ ๆ ก็มีอยู่บ้างนะ คือ ลิฟท์เค้า มีชั้น 0 กับ -1 ด้วยอะ ... เขียนหยั่งงี้บนปุ่มให้กดเลยนะ

แล้วก็ ในห้องพักสำหรับสองคนเนี่ย ... ประตูห้องน้ำไม่มีล็อก

และที่ขาดไม่ได้ ... มันมี Internet ให้ใช้ด้วย !!! มีได้ไงไม่รู้

ตอนนี้ก็ ... สี่โมงยี่สิบสามละ (เหลือบไปเห็นนาฬิกาของเครื่องคอมพ์ ... 9:38 PM แล้วนี่หว่า) พอดีกว่า ไปคุย msn ละ ไว้มีอะไรจะมาบอกเรื่อย ๆ นะ

กำลังจะไปยุโรป

2006-05-02T17:39:00.000+07:00

วันที่ 6 - 20 เดือนนี้ จะไป Rome กับ Frankfurt หละ ไว้จะถ่ายรูปมาให้ดูกันบ้าง ... (กลับมา จะ update ละ)

สวัสดีปีใหม่ไทย

2006-04-13T19:43:00.000+07:00

สุขสันต์วันสงกรานต์จ้าาาา!!!

อยู่เชียงใหม่หละ เล่นน้ำที่คูเมือง หนุกดี

คนชอบ คนไม่ชอบ ...

2006-02-05T11:57:00.000+07:00

คนที่ชอบเรา = คนที่พอใจในสิ่งที่เราทำ
คนที่ไม่ชอบเรา = คนที่ไม่พอใจในสิ่งที่เราทำ
คนที่รู้สึกเฉย ๆ กับเรา = คนที่ไม่คิดว่าต้องสนใจการกระทำของเรา

ระดับความพอใจที่ X รู้สึกต่อ Y

ความพอใจจากประสบการณ์ตรง: Y ช่วย X
ความพอใจจากการวิเคราะห์: X รู้สึกว่า Y ทำสิ่งที่ X เห็นว่าดี

คำว่า "ช่วย" เอง ก็มีหลายลักษณะ เช่น

เป็นที่พี่งทางใจ
ช่วยแก้ปัญหา
ให้เงิน
ซ่อมถนนแถวบ้าน
พัฒนาชุมชนแถบใกล้เคียง
ฯลฯ

ส่วน "ข้อมูลที่ทำให้พอใจ" จากการวิเคราะห์ ก็มีหลายแบบ เช่น

ทำให้คนทั้งโลกมีความสุขมากขึ้น
ทำให้คนหลาย ๆ คน รวยขึ้น
ทำให้คนที่เราไม่ชอบ เสียหาย
ปราบยาเสพติดได้
สร้างงานให้ชนชั้นล่าง
ทำให้เศรษฐกิจดีขึ้น
ฯลฯ

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

ความพอใจของคนหมู่มาก

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

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

วิธีควบคุมสื่อที่เข้าถึงคนส่วนใหญ่ได้ ก็มีมากมายหลายอย่าง เช่น

เป็นเจ้าของสื่อเอง
ควบคุมสื่ออื่นทางตรง (ซื้อ)
ควบคุมผู้ที่ทำงานให้สื่ออื่น

วิธีการ "ควบคุมคน" สามารถทำได้ง่ายกว่าการทำให้คนกลุ่มใหญ่พอใจ ดังนั้น แนวทางหนึ่งในการทำให้คนพอใจ ก็คือ

ใช้คนที่เราควบคุมได้ ไปเผยแพร่ข้อมูล (ที่อาจจะไม่จริง) เพื่อให้คนกลุ่มใหญ่พอใจ

ข้อมูลดึงอารมณ์

วิธีการสร้างข้อมูลสนับสนุนหรือบ่อนทำลาย มักจะเน้นที่การดึงอารมณ์ ตัวอย่างการสร้างภาพขอความเห็นใจ เช่น

กลุ่มคนที่บ้าคลั่ง กำลังด่าทอ สาปแช่งเรา
เด็ก คนแก่ คนป่วย คนพิการ คนจน มาให้กำลังใจเรา

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

ประชาธิปไตย

ประเด็นสำคัญของประชาธิปไตยก็คือ จำนวนคนที่ชอบเรา ดังนั้น วิธีที่กล่าวไว้ จึงเป็นวิธีที่นักการเมือง ในประเทศประชาธิปไตย นิยมมากที่สุด

แล้ว สิ่งที่ประชาชนควรกระทำหละ?

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

แต่ ถ้าทุกคนคิด "ถูกต้องที่สุด" เหมือนกัน (และสิ่งที่ถูกต้องที่สุดมีเพียงหนึ่งเดียว) การเลือกตั้งทุกครั้งก็คงจบลงที่ มีผู้สมัครรับเลือกตั้งเพียงผู้เดียวเท่านั้นที่ได้คะแนนไม่เป็นศูนย์

แน่นอนว่า สิ่งนี้ไม่สามารถเกิดขึ้นจริงได้ เพราะสิ่งที่ "ถูกต้องที่สุด" มันไม่มีนิยามที่ชัดเจน แต่ละคนก็จะมองแตกต่างกัน สิ่งที่ประชาชนพอจะทำได้ก็คือ พยายามเลือกสิ่งที่ "น่าจะถูกต้องที่สุด" ซึ่งตัวเลือกของแต่ละคน ก็มีสิทธิ์ที่จะแตกต่างกัน

สรุปก็คือ เราควรจะถามตัวเองเสมอ ๆ ด้วยเหตุผล เพื่อเตือนตัวเองให้ตัดสินใจใกล้เคียง "อุดมคติ" มากที่สุด ตัวอย่างคำถามก็เช่น

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

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

ผู้สนับสนุนส่วนเกิน

คนที่เชี่ยวชาญเรื่องเกี่ยวกับ Y มักจะไม่ยอมรับ X เมื่อ X เป็นอะไรซักอย่างใน Y

(ที่ใช้คำว่า "มักจะ" ก็เพราะว่า มันไม่ใช่ทุกครั้ง)

ตัวอย่างเช่น

คนที่ดูหนังมามาก ๆ มักจะวิจารณ์หนังเรื่องใหม่ ๆ ในทางลบ
คนที่เห็นเสื้อบอลมามาก ๆ จะไม่ชอบเสื้อบอลรุ่นใหม่
ฯลฯ

สาเหตุที่เป็นอย่างนี้ ก็อาจจะเป็นเพราะ ผู้ที่เชี่ยวชาญเรื่องเกี่ยวกับ Y มักจะเคยรู้จักสิ่งที่ดีกว่า X หรือถ้าผู้นั้นเคยทำสิ่งที่เกี่ยวกับ Y เองโดยตรง ก็อาจจะไม่อยากยอมรับคนที่เก่งกว่า

(อย่างไรก็ตาม การไม่ยอมรับ ไม่ใช่สิ่งที่ผิด)

เรื่องที่น่าแปลกก็คือ ข้อความตรงข้ามของประโยคข้างบน ก็เป็นจริงค่อนข้างบ่อย

คนที่ไม่เชี่ยวชาญเรื่องเกี่ยวกับ Y มักจะยอมรับ X เมื่อ X เป็นอะไรซักอย่างใน Y

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

(การยอมรับ ก็ไม่ใช่สิ่งที่ผิด)

ผลลัพธ์อย่างนึงของประโยคนี้ก็คือ คนที่ไม่ได้ใส่ใจการเมือง มีแนวโน้มจะยอมรับรัฐบาล

เมื่อผนวกกับ ความกลัวความเปลี่ยนแปลง ซึ่งเป็นธรรมชาติของมนุษย์อีกอย่าง เราจึงรู้ว่า

คนที่ไม่ได้ใส่ใจในการเมือง มีแนวโน้มที่จะยอมรับรัฐบาล และไม่คิดล้มล้างรัฐบาล

คนเหล่านี้ เป็น "ผู้สนับสนุนส่วนเกิน" ของรัฐบาล

รัฐบาลที่ฉลาด จะเห็นช่องว่างตรงนี้ แล้วพยายามดึงคนกลุ่มนี้เป็นพวกให้มากที่สุด เพราะว่า มีปริมาณมาก และคล้อยตามง่าย

อย่างไรก็ตาม ผู้สนับสนุนส่วนเกิน ไม่ใช่ผู้ที่ขัดขวางแนวทางของประชาธิปไตย แต่เป็นส่วนประกอบที่เกิดขึ้นจาก ธรรมชาติของประชาธิปไตย

คนเดินขบวน

คนส่วนใหญ่ มักจะมีหน้าที่ประจำของตัวเองอยู่แล้ว การที่จะต้องละทิ้งหน้าที่ตัวเองเพื่อไปทำอะไรซักอย่าง ที่มัน "ไม่ปกติ" แสดงว่าสิ่งที่ไปทำนั้น จะต้องสำคัญมาก ๆ รัฐบาลควรมองพวกที่เดินขบวนเป็นข้อมูลที่ต้องสนใจ

การตั้งตัวเป็นศัตรูกับพวกที่เดินขบวน แล้วไม่รับฟังสิ่งใด ๆ จากคนเหล่านี้ ถือว่าเป็นสิ่งที่ไม่สมควรกระทำ รัฐบาลใด ๆ ควรจะเข้าใจว่า ปกติแล้ว คนจะไม่พยายามมาเหนื่อยในเรื่องแบบนี้ ถ้ามีขบวนเกิดขึ้น รัฐบาลควรจะถามว่า เขามาเดินขบวนกันทำไม จะได้ไปแก้ปัญหาให้ได้

การสลายกลุ่มผู้ประท้วง โดยการจ้างกลุ่มคนก่อความไม่สงบ (เช่น จ้างหญิงโสเภณีมาตีคนแก่ จ้างชาวบ้านมาแสดงการเผารูปผู้นำกลุ่มเดินขบวน ฯลฯ) เป็นสิ่งที่เลวร้ายยิ่งกว่าการไม่ฟังยิ่งนัก

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

ถึงแม้ประชาธิปไตยจะเน้นสิทธิความเท่าเทียมกันของบุคคล แต่ตัวตนของผู้เดินขบวนก็เป็นข้อมูลที่ไม่ควรละเลย โดยเฉพาะ ในกรณีที่ผู้เดินขบวน เป็นคนมีอายุ มีฐานะการงาน มีครอบครัว สิ่งนี้แสดงว่า ถึงแม้จะมีภาระรับผิดชอบมากมาย ยังยอม "เสี่ยงชีวิต" มาเดินขบวน

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

ฮา...

2006-01-29T02:15:00.000+07:00

อ่านอันข้างล่างแล้วหมั่นไส้ตัวเองแฮะ

เกือบโกหก ... ?

2006-01-28T00:59:00.000+07:00

ประเด็นมันอยู่ที่ว่า หลาย ๆ คน คิดว่า คนที่จะเข้าวิศวะจุฬา ฯ ได้เนี่ย จะต้องขยันเรียนสุด ๆ (อย่างน้อยก็ ตอน ม. ปลาย) และคนที่จะได้เกียรตินิยมอันดับ 1 เนี่ย มันต้องขยันโคตร ๆ ๆ ๆ

เรื่อง 2 เรื่องต่อไปนี้ เป็นเหตุการณ์ตัวอย่าง (จริง ๆ มีมากกว่า 2 ครั้ง) ซึ่งอาจจะไม่ได้ตรงกับเหตุการณ์จริง 100% นะ

เรื่องที่ 1

เพื่อนผมคนนึง เคยเป็นอันดับต้น ๆ ของโรงเรียนตอนมัธยม เค้าอยู่วิศวะจุฬา ฯ เหมือนกัน (ตอนนั้นยังเรียนอยู่) แต่เกรดเค้าไม่ค่อยดี (คือ ใกล้ ๆ 3 ... บางคนก็บอกว่าดีแล้ว) พอไปคุยกะแม่เค้า แม่เค้าถามเกรดผม ... พอบอกไปปุ๊บ (ตอนนั้น 3.85) ก็ได้คำพูดตอบกลับมาทันทีว่า

อ่านหนังสือทบทวนทุกวันเลยสิ ดูอย่างเพื่อนไว้บ้างนะ

ฮ่วย ... พูดไม่ออก ... เพื่อนผมก็พูดไม่ออกด้วยอะ ก็เค้ารู้แหละ ว่าผมเป็นไง ให้เอาอย่างผมก็ยิ่งซวยสิ ... สุดท้ายก็ได้แค่ ผงกหัวแล้วพูด "ครับ ๆ" อย่างเดียว

เรื่องที่ 2

มีแม่ของเด็กม.ปลายคนนึง (คือ เค้ารู้จักกับญาติผมหละ) ถามว่า

อยู่วิศวะจุฬา ฯ ได้เนี่ย ต้องขยันมาก ๆ เลยสิ

จะให้ปฏิเสธหรอ? ... คือ ในใจก็รู้ตัวว่า ไม่เคยขยันเรียนอย่างที่คนอื่น ๆ เค้าพูดกัน แต่ไงดีหละ ... ก็เอาเป็นว่า สิ่งที่เราทำ ๆ ไป คนอื่นคงเรียกได้ว่า "ขยันมาก ๆ" หละมั้ง

เลยตอบแบบคลุมเครือไป ประมาณว่า

ครับ ตอนเอ็นทรานซ์เนี่ย ก็ต้องดูหนังสือเยอะ

ในใจก็แอบคิดว่า ไอ้คำว่า "เยอะ" เนี่ย ... มันไม่มีนิยามที่เฉพาะเจาะจง คงไม่เรียกว่าโกหกนะ ... แต่แล้ว เค้าก็ถามต่อมาว่า

ดูหนังสือก่อนสอบกี่เดือนหละ?

เวรกรรม ... จะตอบว่าสัปดาห์เดียวได้มั้ยหละเนี่ย ... ขอเลี่ยง ๆ อีกหน่อยละกันนะ

ก็ ... เตรียมตัวสอบเกือบทั้งปีหละครับ

"เตรียมตัวสอบ" เนี่ย คิดในใจว่า รวมเรื่องสมัครสอบไปด้วยละกัน คิดว่า ตั้งแต่เตรียมตัวสอบครั้งแรก ถึงการสอบครั้งที่สอง มันคงเรียกว่า "เกือบทั้งปี" ได้มั้ง ...

ยัง ยัง ... ยังไม่รอด ...

แล้วดูหนังสือวิชาเลขยังไงหรอ?

แป่วววว ... เล่นบอกวิชามางี้ ... ไม่ได้ดูอะ ... อ้อ ๆ แต่ ที่โรงเรียนมีโจทย์ (การบ้านงี่เง่า ๆ หนะ) ให้ทำเรื่อย ๆ หนิ

ก็ทำโจทย์เยอะ ๆ หละครับ

ตอนนี้ ในใจก็คิดว่า แค่มากกว่า 0 คงเรียกว่า "เยอะ ๆ" ได้มั้ง ... แต่มันเริ่มขัดกับอุดมการณ์ตัวเองแล้วอะ ไม่เคยคิดเลย ว่าจะบอกให้คนอื่นท่องรูปแบบโจทย์ แต่เค้าต้องคิดงั้นแน่เลย และแล้ว เค้าก็บอกว่า

เห็นมั้ยลูก ทำโจทย์เยอะ ๆ นะ เอาให้ครบทุกแบบเลย

- -'' ... ซะงั้น ... นี่มันเรียนผิดวิธีเลยนะ ...

งาน TAM 2006

2006-01-16T15:53:00.000+07:00

ไปมาเมื่อวันเสาร์ จะบอกว่า

TAM 2006 ห่วยแตก!!

ไม่มีอะไรน่าสนใจเลยอะ

อาวละ ... สรุป blog

2006-01-08T21:59:00.000+07:00

blog ที่เกิดใหม่ตอนปีใหม่ มีดังนี้...

Another Tunoblog - blog เรื่องไร้สาระ

Tunology - blog วิชาการ
(ใครที่อ่านสิ่งที่เคยเขียนไว้ที่นี่ (Tunoblog) ไม่ค่อยรู้เรื่อง ลองไปดูใหม่ที่ Tunology นะ อาจจะรู้เรื่องมากขึ้น)

Tunosong - blog เกี่ยวกะดนตรี

แต่ยังไม่เลิกเขียนอันนี้นะ แค่จะ update น้อยลง (เยอะเลย)

อัตราการ update ของทุก blog รวมกัน ก็คงจะน้อยกว่า blog นี้ในอดีตอยู่ดี :P

ไปเล่นมาเพียบเลย ...

2006-01-04T19:26:00.000+07:00

จะย้ายเรื่องวิชาการไปที่ Tunology แล้วนะ ส่วน Tunoblog อันนี้ ก็คงจะซีเรียสน้อยลงละ

Another Tunoblog เขียนเป็นภาษาอังกฤษนะ

แล้วก็ เรื่องดนตรี กับเพลงที่เอาให้ฟัง จะย้ายไปอยู่ที่ Tunosong หละ

ของ blogsource ไม่เอาแล้ว ห่วยกว่า blogger อะ ...

แล้วอยู่ดี ๆ ใจ๋ก็มาบอกว่า ให้ไปทำที่ multiply.com ... มันมีเนื้อที่ไม่จำกัดอะ ...

ย้ายอีกทีดีมั้ยเนี่ย

สวัสดีปีใหม่ครับ

2006-01-01T02:15:00.000+07:00

สวัสดี .. ปี .. ใหม่แล้ว .... ผองไทย .. จงแคล้ว .. ปวงภัย .... นะ

ไปเล่นมา ...

2005-12-28T19:12:00.000+07:00

http://tunococ.blogsource.com/

ตามกระแสเก่านิด ๆ ... เขียนภาษาอังกฤษมั่ง

ม่ายหวายแล้ววววววว!!!

2005-12-27T13:51:00.000+07:00

เขียนบ่อย ๆ ไม่ไหวแล้วอะ ... งานมหาศาล ... หยั่งงี้ยังเรียกว่าว่างงานได้มั้ยเนี่ย

แต่ยังไม่เลิกเขียนนะ!

ถึงคราวต้องสร้าง Virtual Machine แล้ว (พื้นฐาน)

2005-11-21T18:49:00.000+07:00

เพื่อให้เห็นภาพ ว่าที่ผ่าน ๆ มา มันเป็นอะไร คราวนี้ มาลองสร้าง Virtual Machine กันเถอะ ... มาสรุปสิ่งที่ Virtual Machine ควรจะมีก่อน ... ครั้งนี้คิดสำหรับ process เดียวก่อนนะ

Memory Units

เพื่อให้สามารถสร้าง memory module ได้ เราต้องกำหนดไว้ก่อนว่า แต่ละ word มีขนาดเท่าไหร่ ... สมมติเลยละกันนะ ว่า

ตำแหน่งของ memory 1 ตำแหน่ง จะเก็บข้อมูลได้ 1 byte
ขนาดของ instruction = 4 byte

Process Space

PC - Program Counter
Memory - แบ่งเป็น

Stack

SP - Stack Pointer
BP - Base Pointer

Heap

MA - Memory Address
AC - Accumulator
FP - Frame Pointer

และ operation ที่เกี่ยวกับ memory พื้นฐาน ก็คือ

load: AC ← mem[MA]
store: mem[MA] ← AC
push X: SP ← SP - 4; mem[SP] ← X
pop X: X ← mem[SP]; SP ← SP + 4

Instruction Set

ก่อนอื่น ตกลงกันก่อนว่า ส่วนของ OPCODE เราจะยังไม่ใส่ตัวเลขลงไป แต่สมมติว่ามันกินเนื้อที่ 4 byte (เพื่อให้ง่ายเวลา implement จริงเป็นวงจรด้วย) instruction set ที่เราต้องทำ มีสามกลุ่ม คือ

Fundamental Instructions

PUSH X

คำสั่งนี้ พิเศษกว่าคำสั่งอื่นตรงที่มันมี operand ด้วย ... ดังนั้น ขนาดของคำสั่งนี้จะต้องรวม X ลงไปด้วย ... เราจะกำหนดให้ 4 byte แรกเป็น opcode และ 4 byte หลังคือ X รวมกันเป็น 8 byte ต่อการ PUSH 1 ครั้ง
การทำงาน: push X

PBASE

การทำงาน: push BP

LOAD

การทำงาน: pop MA; load; push AC

STORE

การทำงาน: pop AC; pop MA; store

JMP

การทำงาน: pop PC

JPOS

การทำงาน: pop AC; if AC > 0, pop PC, else pop AC

JNEG

การทำงาน: pop AC; if AC < 0, pop PC, else pop AC

การทำงาน: pop AC; if AC = 0, pop PC, else pop AC

JNZ

การทำงาน: pop AC; if AC ≠ 0, pop PC, else pop AC

CALL

การทำงาน: pop AC; push PC + 4; push BP; BP ← SP; PC ← AC

RETURN

การทำงาน: pop AC; SP ← BP; pop BP; pop PC; push AC

Dynamic Allocation Instructions

คำสั่งในกลุ่มนี้มีสองคำสั่งคือ ALLOC กับ FREE การทำงานของมันจะพิเศษหน่อย เพราะมันเป็น OS-Level Instruction ดังนั้น จะไม่สามารถ implement เป็น hardware ได้ตรง ๆ

ALLOC

การทำงาน: pop AC; AC ← malloc(AC); push AC

FREE

การทำงาน: pop AC; free(AC)

Arithmetic and Logical Instructions

พวกนี้ จะมีเยอะเท่าไหร่ก็ได้ ... หลัก ๆ จะมีสองกลุ่มคือ unary กับ binary แต่ถ้าจะทำเพิ่ม ก็ทำได้เรื่อย ๆ นะ

NEG

การทำงาน: pop AC; push -AC

ADD

การทำงาน: pop MA; pop AC; push AC + MA

SUB

การทำงาน: pop MA; pop AC; push AC - MA

MUL

การทำงาน: pop MA; pop AC; push AC * MA

DIV

การทำงาน: pop MA; pop AC; push AC / MA

MOD

การทำงาน: pop MA; pop AC; push AC mod MA

ส่วนคำสั่งที่เป็นด้าน logic เราจะถือว่า 0 = false และ ค่าอื่น ๆ = true นะ (แต่ค่า true ที่เป็น output ของ operation จะกำหนดให้เป็น 1 เลย)

NOT

การทำงาน: pop AC; push ¬AC

AND

การทำงาน: pop MA; pop AC; push AC ∧ MA

การทำงาน: pop MA; pop AC; push AC ∨ MA

IFF

การทำงาน: pop MA; pop AC; push AC ↔ MA

XOR

การทำงาน: pop MA; pop AC; push ¬(AC ↔ MA)

NAND

การทำงาน: pop MA; pop AC; push ¬(AC ∧ MA)

NOR

การทำงาน: pop MA; pop AC; push ¬(AC ∨ MA)

แล้วจะมาต่อเรื่อง Floating Point อีกทีนะ

มาลองทำ Assembler กัน (Process Space)

2005-11-20T19:40:00.000+07:00

ลองสมมติว่า เราเขียนโปรแกรมมา คอมไพล์เสร็จ มันเป็นก้อน object code หน้าตาคงที่ ...

คำสั่ง JMP กับ CALL หละ? ตำแหน่งของการกระโดดมันคงที่หนิ ... แสดงว่า ถ้าเราเอา code เราไปวางไว้ที่อื่น (คือ address เริ่มต้นเปลี่ยนไป) มันก็จะทำงานไม่ถูกน่ะสิ!!!

Frame Pointer

ทางแก้ก็คือ แก้ที่ CPU ของเรา ให้ทุกครั้งที่ทำคำสั่งที่เกี่ยวกับ memory ให้เอาเลขที่ได้ ไปบวกกับ FP ก่อน แค่นี้ก็เรียบร้อย ... ว่าแต่ FP นี่มันจะเก็บไว้ที่ไหนหละ? ... ก็กำหนด Register ขึ้นมาอีกตัวสิ

Process Space

ดังนั้น เพื่อให้การทำงานในแต่ละ process ถูกต้อง เราจะเก็บค่า FP ปะติดกับ object code ไว้สำหรับแต่ละ process ... ค่า FP นั้น จะรู้ในเวลาที่ load โปรแกรมลงใน memory

พอถึงเวลาที่ process นั้นจะทำงาน เราก็เพียงแค่ load ค่า FP ของ process นั้นกลับคืนมา การทำงานก็จะถูกต้องแล้ว

Cross-Process Communication

แล้ว เราจะทำให้ process ต่าง ๆ ติดต่อกันได้ยังไงหละ?

วิธีที่เค้านิยมทำกัน จะมีอยู่ 2 แบบคือ

Messaging - ติดต่อผ่าน OS
Shared Memory - ขอ OS ให้เปิดช่องการติดต่อโดยตรง

จริง ๆ ทั้งสองวิธีก็ต้องพึ่ง OS ทั้งคู่ แต่วิธีแรกจะต้องพึ่ง "OS Instruction" มากกว่า

รายละเอียดจริง ๆ ของสองอย่างนี้ จะยังไม่พูดถึงตอนนี้ละกัน ... ไว้หลังจากทำ Virtual Machine กับ Assembler ได้ก่อน

มาลองทำ Assembler กัน (Return Value)

2005-11-19T18:44:00.000+07:00

Return Value Problem

สมมติว่า มี code ภาษา C แบบนี้


 int Succ(int a)
 {
  return a + 1;
 }

พอแปลงเป็นภาษา Assembly จะได้

 Succ:
  REF a -2
  PUSH a
  LOAD
  PUSH 1
  ADD
  RETURN

ไม่มีปัญหา แต่ถ้าในฟังก์ชัน มีตัวแปรภายในอยู่หละ?

 int Double(int a)
 {
  int x = a;
  return a + x;
 }

ลองแปลงเป็น Assembly ดู

 Double:
  REF a -2

 VAR 1

REF x 1

 PVAR x

 PVAR a

 LOAD

 STORE

 PVAR a

 LOAD

 PVAR x

 LOAD

ADD

???
???

  RETURN

ที่ใส่ ??? ไว้ก็คือ เราจะ RETURN เลยไม่ได้ เพราะเรายังไม่ได้เรียก FVAR แต่ถ้าเราเรียก FVAR เนี่ย ค่าที่เราต้องการจะ RETURN มันก็จะหายไป เราจะทำยังไงหละ?

เรารู้ว่า ค่าที่จะถูก RETURN ออกไป จะต้องอยู่ในตำแหน่ง BP - 1 แน่ ๆ ดังนั้น เราก็สามารถแก้ปัญหานี้ได้โดย กำหนดตัวแปรที่ตำแหน่ง BP - 1 ให้มันเกินไว้ตัวนึง จะได้เป็น

 Double:
  REF a -2

PUSH 0
REF rv 1

 VAR 1

REF x 2

 PVAR x

 PVAR a

 LOAD

 STORE

PVAR rv

 PVAR a

 LOAD

 PVAR x

 LOAD

ADD

STORE
FVAR

  RETURN

แต่ ... แบบนี้มันยุ่งยากจัง ... เรากำหนดคำสั่งใหม่มันจะง่ายกว่านะ ... ก็สมมติซะว่าคำสั่ง RETURN มันจะรวม FVAR ไปด้วยเลย แบบนี้

RETURN

POP ค่า Return Code ออกมาเก็บไว้ก่อน
ถ้า SP ≠ BP ก็ POP ค่าอื่น ๆ ทิ้งไปเรื่อย ๆ จนกว่า SP = BP
POP ค่ามาใส่ไว้ใน BP
POP อีกค่ามาใส่ไว้ใน PC
PUSH ค่า Return Code ที่เก็บไว้ คืนลงไปใน Stack

ข้อดีของการทำแบบนี้ ไม่ใช่แค่เราลดคำสั่ง FVAR ได้แล้ว แต่เรายังประหยัดที่สำหรับ return value ไป 1 ที่ พร้อมกับป้องกันการ POP ไม่หมดได้ด้วย ... code ใหม่ของเราจะเหลือแค่นี้

 Double:
  REF a -2

 VAR 1

REF x 1

 PVAR x

 PVAR a

 LOAD

 STORE

 PVAR a

 LOAD

 PVAR x

 LOAD

ADD

  RETURN

มาลองทำ Assembler กัน (Literal)

2005-11-18T16:47:00.000+07:00

Literal

ลองดู code ภาษา C ข้างล่างนี้

 int main()
 {
  char *msg = "ABC";
  printf("%s\n", msg);
  return 0;
 }

เราจะแปลงมันเป็นภาษา assembly ได้แบบนี้


 main:
  VAR 1
  REF msg 1

PVAR msg

 PUSH literal0

 STORE

 PUSH literal1

 PVAR msg

LOAD

 PUSH printf

 CALL

FVAR

 PUSH 0

 RETURN

literal0:

"ABC"

 literal1: "%s\n"

 printf:

...

สมมติว่า string "ABC" และ "%s\n" ใช้เนื้อที่ตัวละ 1 word เราจะได้ object code สุดท้ายแบบนี้


 0000h: PUSH 0

 0002h: PBASE

 0004h: PUSH 1

0006h: SUB

 0008h: PUSH 0024h

 000Ah: STORE

 000Ch: PUSH 0025h

 000Eh: PBASE

 0010h: PUSH 1

0012h: SUB

 0014h: LOAD

 0016h: PUSH 0026h

 0018h: CALL

 001Ah: PUSH 0

 001Ch: MUL

 001Eh: ADD

 0020h: PUSH 0

0022h: RETURN

 0024h: "ABC"

0025h: "%s\n"
0026h: ...

มาลองทำ Assembler กัน (พื้นฐาน)

2005-11-17T02:52:00.000+07:00

จริง ๆ แล้ว ภาษา assembly มันก็ภาษาเครื่องแหละ แต่มันเขียนสะดวกกว่านิดนึง ... อะไรที่เราควรจะกำหนดเพิ่มไว้ก่อนหละ? ก็เรื่อง label กับ ตัวแปรไง

Local Variables (อีกแล้ว)

สมมติว่า เราจะเขียนว่า

void f()

  int x;

int y;

x = 0;

y = x + 500;

เดิมเราจะเขียนว่า

f:
VAR 2
PBASE
PUSH 1
SUB
PUSH 0
STORE
PBASE
PUSH 2
SUB
PBASE
PUSH 1
SUB
LOAD
PUSH 500
ADD
STORE
...
FVAR
PUSH ค่ามั่ว ๆ อะไรก็ได้
RETURN

จะเห็นว่า การอ้างถึงตัว y จะต้องใช้ 3 คำสั่ง คือ

PBASE
PUSH 2
SUB

เพื่อลดเรื่องยุ่งพวกนี้ เราก็กำหนดภาษาใหม่ แบบนี้

f:
VAR 2
REF x 1 (บอกให้ x = BP - 1)
REF y 2 (บอกให้ y = BP - 2)
PVAR x
PUSH 0
STORE
PVAR y
PVAR x
LOAD
PUSH 500
ADD
STORE
...
FVAR
PUSH ค่ามั่ว ๆ อะไรก็ได้
RETURN

Labels

เราใช้ Label ไปหลายทีแล้วโดยที่ไม่ได้พูดถึง ... จริง ๆ แล้ว การจะกระโดดไปที่ label ต่าง ๆ จำเป็นจะต้องรู้ address ของ label เหล่านั้น ...

ดังนั้น Assembler ของเรา จะต้องมีความสามารถในการ แปลง label เหล่านั้น ให้เป็น address จริง ๆ

สมมติว่ามี code แบบนี้

  int f()

  int x;

  int y;

  do {

  x = ReadFromSomewhere();

y = ReadFromSomewhere();

  } while (x != y);

  return 0;

}

จะเขียนเป็น Assembly ได้แบบนี้

f:

VAR 2
REF x 1

REF y 2

loop:

PVAR x

PUSH ReadFromSomewhere
CALL

PVAR y

PUSH ReadFromSomewhere
CALL

PVAR x

LOAD

  PVAR y

  LOAD

SUB

PUSH loop

JNZ

FVAR
PUSH 0
RETURN

ซึ่ง ตอนที่แปลเป็นภาษาเครื่อง เราจะต้องรู้ 3 อย่างคือ

ตำแหน่งเริ่มต้นของ f → สมมติว่าเป็น 1234h
ตำแหน่งเริ่มต้นของ ReadFromSomewhere → สมมติว่าเป็น 5678h
ขนาดของ instruction → สมมติว่าเป็น 2

จากตำแหน่งเริ่มต้นของ f และขนาดของ instruction เราจะสามารถหาตำแหน่งของ loop ได้ ทำให้สามารถแปล assembly ข้างบนเป็นภาษาเครื่องได้ ดังนี้

  1234h: PUSH

  1236h: PUSH

1238h:

PBASE

123Ah:

PUSH 1

123Ch:

SUB

123Eh: PUSH 5678h
1240h:

CALL

1242h:

PBASE

1244h:

PUSH 2

1246h:

SUB

1248h: PUSH 5678h
124Ah:

CALL

124Ch:

PBASE

124Eh:

PUSH 1

1250h:

SUB

1252h:

LOAD

1254h:

PBASE

1256h:

PUSH 2

1258h:

SUB

125Ah: LOAD
125Ch: SUB
125Eh: PUSH 1238h
1260h:

JNZ

1262h: PUSH 0
1264h: RETURN

คราวหน้า มาดูเรื่อง Literal กันนะ

มาลองออกแบบ Abstract Instruction Set กัน (ตอนต่อ)

2005-11-16T23:37:00.000+07:00

ต่อจาก มาลองออกแบบ Abstract Instruction Set กัน (ตอนแรก) เลยนะ

ครั้งนี้ จะพูดถึงการคำสั่งอย่างย่อ ... เรียกว่า เป็น Higher-Level Assembly ละกัน ... เราจะพัฒนาคำสั่งไปเรื่อย ๆ แบบนี้ จนมันเป็นภาษาชั้นสูงไปเลย

Local Variables

เราสามารถจองตัวแปรบน stack ได้ด้วยคำสั่ง PUSH เช่น สมมติว่าเรามี code ภาษา C แบบนี้

void f()

int x;

int y;

x = 0;

y = x + 500;

...

}

เมื่อเราเรียกคำสั่ง f เราจะจองเนื้อที่บน stack ให้กับตัวแปร x และ y ได้ด้วยคำสั่ง PUSH แล้วเมื่อเราจะใช้ตัวแปรพวกนี้ เราก็อ้างถึงจากตำแหน่ง BP (x คือ BP และ y คือ BP - 1) ...

f:
PUSH ค่าเริ่มต้นของ x
PUSH ค่าเริ่มต้นของ y
PBASE
PUSH 0
STORE
PBASE
PUSH 1
ADD
PBASE
LOAD
PUSH 500
ADD
STORE
...
POP
POP
PUSH ค่าอะไรก็ได้สำหรับ return
RETURN

แต่เอ๊ะ ... คราวที่แล้วบอกว่า ไม่มีคำสั่ง "POP" หนิ ... แล้วเราจะทำให้มัน POP ได้ไงหละ? ... มันก็ต้องอ้อม ๆ หน่อยแหละ ใช้ความรู้ที่ว่า อะไรคูณ 0 ก็ได้ 0 แล้วก็ อะไรบวก 0 ก็ได้ตัวเดิม เราจะสร้างคำสั่ง POP ได้จาก

PUSH 0
MUL
ADD

แล้วถ้ามี POP หลาย ๆ ตัวติดกัน เราก็แค่เพิ่ม MUL ตรงกลางเข้าไป เช่น

จาก
POP
POP
POP

กลายเป็น

PUSH 0
MUL
MUL
MUL
ADD

Abbreviated Form

เพื่อให้เขียนง่าย แทนที่เราจะเขียน PUSH ซ้ำ ๆ สำหรับตัวแปรหลาย ๆ ตัว เราจะเขียนว่า

VAR n

เพื่อหมายถึงการ PUSH เปล่า ๆ ไป n ครั้ง เป็นเนื้อที่ของตัวแปร n ตัว ส่วนการ POP เราก็จะเขียนว่า

FVAR

(ย่อมาจาก Free VAR) เพื่อหมายถึง PUSH 0, MUL, MUL, MUL, ..., ADD ที่มีจำนวน MUL เท่ากับ n ของคำสั่ง ALLOC ก่อนหน้านี้

Dynamic Allocation

เนื่องจาก ... การจองเนื้อที่สำหรับตัวแปรบน heap เป็นสิ่งที่ทำกันบ่อยมาก ๆ เราก็เลย สมมติว่ามีคำสั่งสำหรับทำงานนี้เลยละกัน

ALLOC

การทำงานคือ

POP ค่าบนสุดของ Stack ออกมา ให้เป็นขนาด memory block ที่ต้องการ
ไปค้นหาเนื้อที่ว่างจาก heap
PUSH ค่า address คืนลงไปใน Stack

เพื่อให้การคืน memory ทำได้ง่ายขึ้น เราจะจองเนื้อที่ให้เกินที่ขอไปนิดนึง เพื่อใส่ขนาดของ block ไว้ข้างหน้า address ที่คืนออกมา ผลก็คือ คำสั่ง

FREE

จะต้องการ POP ค่าจาก stack เพียงค่าเดียว คือ address

ตัวอย่างเช่น

void f()

int* x;

x = new int;

...

}

f:
VAR 1 (สมมติว่าขนาดของ pointer = 1)
PBASE
PUSH 1 (สมมติว่าขนาดของ int = 1)
ALLOC
STORE
...
FVAR
PUSH ค่าอะไรก็ได้สำหรับ return
RETURN

สรุปคำสั่งตอนนี้

จริง ๆ คำสั่ง ALLOC กับ FREE มันไม่ใช่คำสั่งพื้นฐานที่ CPU ควรจะมีหรอกนะ มันเป็น OS-level Instruction หนะ วิธีสร้าง ALLOC กับ FREE จริง ๆ ไว้จะบอกทีหลัง แต่ตอนนี้สมมติว่ามีให้ใช้เลยละกัน

Minimal Instruction Set + ALLOC & FREE

PUSH
PBASE
LOAD
STORE
JPOS
CALL
RETURN
NAND
NEG
ADD
MUL
ALLOC
FREE

Abbreviations
JMP
JNEG
JZ
JNZ
NOT
AND
OR
XOR
IFF
SUB
DIV
MOD
VAR
FVAR
...

แล้วจะมาเพิ่ม abbreviation อีกเรื่อย ๆ นะ

มาลองออกแบบ Abstract Instruction Set กัน (ตอนแรก)

2005-11-15T01:26:00.000+07:00

ขอโทษล่วงหน้า ถ้าทำให้ใครบางคนอ่านเรื่องนี้ไม่รู้เรื่องตั้งแต่ต้น ...

บังเอิญว่า อยากจะเอาเรื่องเกี่ยวกับการออกแบบ Instruction Set ของ CPU มาให้ดู ๆ กันบ้างหนะ

Abstract Instruction Set

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

Chosen Design: Stack Machine

Stack Machine เป็นแนวคิดที่ว่า Operation ทั้งหลาย ทำบน Stack ... คิดว่าแบบนี้น่าจะทำให้ลดจำนวนคำสั่งลงได้เยอะ

ข้อเสียก็คือ การจะทำอะไรอย่างนึง มันต้องมีหลายคำสั่งน่ะสิ แล้วก็ การทำ Pipelining จะยากด้วย แต่ขอไม่สนเรื่องนี้ก่อน

เหตุผลสนับสนุนอีกอย่างนึงที่ทำให้เลือก Operation on Stack ก็คือ เวลาทำ compiler ให้แปล source code เป็น machine code เนี่ย มันจะค่อนข้างง่ายและตรงมาก (แต่ประสิทธิภาพก็ไม่ได้ดีเท่าไหร่แหละ)

First Two Opcodes: PUSH and POP

เวลาจะทำ Stack ใคร ๆ ก็ต้องคิดถึง Push กับ Pop แน่ ๆ เราก็กำหนดเลยละกันว่า เราจะมีสองคำสั่งนี้

ผลก็คือ เราสามารถสร้างให้คำสั่งอื่น ๆ ไม่รับ operand เองโดยตรงได้ เช่น

คำสั่ง A = B + C

Instruction Set ทั่วไป
ADD A, B, C

Stack-based Operation ของเรา
PUSH B
PUSH C
ADD
POP A

ว่าแต่ว่า ... เราจะระบุสิ่งที่จะ PUSH กับ POP ได้ยังไงหละ?

Types of Operands

เนื่องจากเราจะลดความซับซ้อนให้เหลือน้อยที่สุด เราจะยอมให้มี operand ได้แค่แบบเดียวแบบ คือ

Immediate

ไว้จะมาอธิบาย ว่า addressing แบบอื่น สามารถทำได้จากสองแบบนี้ แต่เราต้องพึ่งคำสั่งอื่น ๆ เช่น LOAD กับ ADD

Required Registers

เราจะให้มี register เพียง 3 ตัว ที่สามารถยุ่งเกี่ยวได้ด้วย machine instruction คือ

Program Counter (PC) = Address ของคำสั่งปัจจุบัน
Base Pointer (BP) = Address แรกของ Local Variable ปัจจุบัน
Stack Pointer (SP) = Address ของ Top-of-stack

โดยทั้งสามตัวนี้ ควรจะใช้ Address Space เดียวกัน (Virtual ก็ได้)

สมมติว่า SP จะลดค่าเมื่อ PUSH และเพิ่มค่าเมื่อ POP นะ (ทำตามแบบที่เค้านิยมกัน)

Indirect Indexing: PBASE

เนื่องจาก Base Pointer (BP) เป็น register ที่ควรจะสามารถนำค่าไปบวก-ลบได้ ดังนั้น เราจึงควรจะสร้างคำสั่งที่ใช้อ่านค่า BP ดังนี้

PBASE = Push ค่าของ BP ขึ้น Stack

LOAD and STORE

เราจะกำหนดให้ คำสั่ง LOAD จะใช้ operand เป็นตัวบนสุดของ stack ตัวเดียว มีการทำงานคือ

เอาค่าบนสุดของ stack ไปเป็น address อ้างอิง memory
อ่านค่าจาก memory ในตำแหน่งนั้น
เอาค่าที่อ่านได้ มาแทนที่ในตำแหน่งบนสุดของ stack (ที่เคยเป็น address)

ส่วนคำสั่ง STORE จะใช้ operand 2 ตัว มีการทำงานคือ

POP ตัวแรกออกจาก stack ใช้เป็น address อ้างอิง memory
POP ตัวที่สองออกจาก stack ใช้เป็นค่าที่จะเขียนลง memory
เขียนค่าที่ได้ (จากการ POP ครั้งที่สอง) ลงใน memory (address ได้จากการ POP ครั้งแรก)

จะว่าไป ... LOAD มันก็คือ PUSH แล้ว STORE มันก็คือ POP น่ะแหละ

สังเกตดี ๆ หละ ว่า จริง ๆ เราไม่ต้องมีคำสั่ง POP นะ!!!

Logical Functions: NOT, AND, OR, XOR, IFF

ถึงแม้ว่า จริง ๆ แล้วเราสามารถใช้แค่ NAND หรือ NOR เพียงอย่างเดียวได้ แต่ตรงนี้ ไม่ขอประหยัดจำนวน Opcode นะ เพราะว่ามันไม่ได้เป็นสาระสำคัญเท่าไหร่ (ถ้าอยากจะสร้างแบบประหยัด ให้มันมีแต่ NAND หรือมีแต่ NOR เวลาทำ compiler ก็จะเหนื่อยหน่อย เท่านั้นเอง)

Arithmetic Functions: NEG, ADD, SUB, MUL, DIV, MOD, EXP, LOG, ...

พวกนี้ก็เหมือนกัน ... จริง ๆ มีแค่ NEG ADD แล้วก็ MUL ก็น่าจะพอแล้ว แต่การประหยัดจำนวนคำสั่งตรงนี้ ก็ไม่ใช่สาระสำคัญเหมือนกัน ดังนั้นเราจะถือว่า คำสั่งพวกนี้ มีหมดเลย ก็แล้วกัน

Classical Modes of Addressing

เนื่องจาก Operand เรา มีแต่แบบ Immediate การอ้างถึง Operand ในลักษณะอื่น ๆ แบบที่เครื่องทั่ว ๆ ไปเค้าทำได้ มันจะต้องใช้หลายคำสั่งหน่อยนะ เช่น

Target: Value at memory address X
Abbreviation: [X]
How to PUSH that?
PUSH X
LOAD

Target: Value at memory address BP + X
Abbreviation: [BP + X]
How to PUSH that?
PBASE
PUSH X
ADD
LOAD

Target: Value at memory address (BP + value at X)
Abbreviation: [BP + [X]]
How to PUSH that?
PBASE
PUSH X
LOAD
ADD
LOAD

Target (in C): Array[Index]
Abbreviation: [BP + array + [BP + index]]
How to PUSH that?
PBASE
PUSH array
ADD
PBASE
PUSH index
ADD
LOAD
ADD
LOAD

Simple Branch Instructions: JMP, JPOS, JNEG, JZ, JNZ

JMP: POP → PC
JPOS: POP → เก็บไว้ แล้ว POP อีกที ถ้าได้ค่าเป็นเลขบวก (มากกว่า 0) ถึงจะกระโดดไปยัง address ที่เก็บไว้
JNEG: คล้าย ๆ กับ JPOS แต่จะกระโดดถ้าค่าที่ POP ออกมาครั้งที่ 2 เป็นเลขติดลบ
JZ: POP → เก็บไว้ แล้วก็ POP อีกที ถ้าได้ค่าเป็น 0 ถึงจะโดดไปยัง address ที่เก็บไว้
JNZ: คล้าย ๆ กับ JZ แต่เงื่อนไขการกระโดดตรงกันข้าม

จริง ๆ จะมีแต่ JPOS ก็ได้แหละ ที่ไม่ตัดตัวอื่นออก ก็เพราะว่ามันไม่ใช่สาระสำคัญ (อีกแล้ว)

Subroutine: CALL, RETURN

คำสั่ง CALL จะวุ่น ๆ หน่อย เพราะมีการทำงานหลายขั้น คือ

POP ค่า address ที่จะกระโดดไป เก็บไว้
PUSH ค่า PC + 1 ไว้
PUSH ค่า BP ไว้
กำหนดค่าให้ BP = SP
กำหนดค่าให้ PC = address ที่ POP ไว้ตอนแรก (ซึ่งก็คือ การกระโดดนั่นเอง)

ส่วนคำสั่ง RETURN จะทำงานกลับกันกับ CALL คือ

POP ค่า Return Code ออกมาเก็บไว้ก่อน
POP ค่ามาใส่ไว้ใน BP
POP อีกค่ามาใส่ไว้ใน PC (ซึ่งก็คือ การกระโดดกลับ)
PUSH ค่า Return Code คืนลงไปใน Stack

จริง ๆ แล้ว ตอนที่ RETURN จะไม่เผื่อที่สำหรับ Return Code ก็ได้ แต่อันนี้เผื่อไว้เพื่อความสะดวกหนะ

Local Variable and Parameters

ถ้าต้องการส่งผ่าน parameter ให้กับ function เราก็จะใช้วิธี PUSH ใส่ stack ไว้ก่อน เช่น

PUSH A
PUSH B
PUSH CustomAdd
CALL

ถ้า BP หลัง CALL = x
SP ก่อน CALL จะ = x + 1
ตำแหน่งของ B ก็เลย = x + 2
และ ตำแหน่งของ A ก็ = x + 3

สรุปก็คือ parameter ตัวที่ PUSH มาหลังสุด (ไม่นับ address ของฟังก์ชัน ซึ่งในตัวอย่างนี้คือ CustomAdd) จะมี address เป็น BP + 2

CustomAdd:

PBASE
PUSH 2
SUB
LOAD
PBASE
PUSH 3
SUB
LOAD
ADD
RETURN

สรุปคำสั่ง

ชุดคำสั่งเล็กสุด
PUSH
PBASE
LOAD
STORE
JPOS
CALL
RETURN
NAND
NEG
ADD
MUL

คำสั่งลดความเหนื่อย
JMP
JNEG
JZ
JNZ
NOT
AND
OR
XOR
IFF
SUB
DIV
MOD
...

ตอนนี้เราก็ได้ Instruction Set คร่าว ๆ แล้ว แต่เราไม่พูดถึงขนาดของข้อมูลในแต่ละช่องของ Stack เลยนะเนี่ย ... ก็เลยเรียกว่า Abstract Instruction Set ไงหละ

การบวกลบเลขจำนวนเต็มไม่ติดลบ

2005-11-14T00:37:00.000+07:00

เนื่องจาก การคิดเลขในฐานอะไรก็เหมือนกันหมด แต่เราอยากทำในกรณีที่มันเป็นฐาน 2 เพราะว่า คอมพิวเตอร์มันเป็นฐานสอง ... มาดูกันว่า การบวกเลขฐานสอง ทำกันยังไงนะ

จริง ๆ แล้ว ก็เหมือนกับฐาน 10 น่ะแหละ แต่มันง่ายกว่าด้วยซ้ำ เพราะว่า ผลลัพธ์มีแค่ 0 กับ 1 ดังนั้น ความเป็นไปได้ทั้งหมดของการบวกกันในแต่ละหลัก คือ ... (ตัวทด ใช้สีแดงนะ)

กรณีที่ไม่มีตัวทด (ตัวทด = 0)
0 + 0 = 00
0 + 1 = 01
1 + 0 = 01
1 + 1 = 10

กรณีที่มีตัวทด (ตัวทด = 1)
1 + 0 + 0 = 01
1 + 0 + 1 = 10
1 + 1 + 0 = 10
1 + 1 + 1 = 11

พอได้การบวกทุกแบบแล้ว เราก็ลองเอามาใช้ดู

ตอนนี้ก็บวกเป็นละ ... แล้วการลบหละ?

เลขจำนวนเต็มไม่ติดลบ

2005-11-13T23:59:00.000+07:00

ที่ผ่าน ๆ มา เราก็รู้กันไปเรียบร้อยแล้วเรื่อง การแปลงฐานเลข คราวนี้ก็ ขอตั้งข้อกำหนดเบื้องต้นไว้นิดนึงนะ คือ

ข้อมูลในคอมพิวเตอร์ จะอยู่ในรูปลำดับของเลขฐานสอง ที่มีความยาวจำกัด
ความยาวของลำดับ = จำนวน bit ของข้อมูล

แล้วก็ ขอกำหนดคำที่จะใช้เพื่อให้คุยกันง่ายขึ้น คือ

ข้อมูล n bit = เลขฐานสอง n หลัก

จำนวนเต็มไม่ติดลบ ที่สามารถแทนได้ด้วย n bit

คิดด้วยหลักการง่าย ๆ ว่า ข้อมูล 1 bit สามารถเป็นได้ 2 แบบ คือ 0 กับ 1 ดังนั้น

ข้อมูล n bit สามารถเป็นได้ 2ⁿ แบบที่แตกต่างกัน

เนื่องจาก จำนวนเต็มที่ไม่ติดลบ 2ⁿ ตัวแรก ก็คือ

0, 1, 2, ..., 2ⁿ - 1

ดังนั้น ข้อมูล n bit จะสามารถแทนจำนวนเต็มไม่ติดลบที่มีค่าน้อยกว่า 2ⁿ ได้ 1 ตัว

Byte

1 byte = 8 bits

ดังนั้น ข้อมูล 1 byte จะแทนจำนวนเต็มไม่ติดลบที่มีค่าน้อยกว่า 2⁸ ได้ 1 ตัว

หมายเหตุ: แทนที่จะมองว่า 1 byte = เลขฐานสอง 8 หลัก เราอาจจะมองว่า 1 byte = เลขโดดฐาน 256 ก็ได้

เลขฐาน 16

ในโปรแกรมคอมพิวเตอร์พวกที่ให้เห็นค่าใน memory เรามักจะเห็นเลขฐาน 16 กันบ่อยพอควร แล้วมันก็จะอยู่เป็นคู่ ๆ ด้วย สาเหตุที่เค้านิยมเขียนเลขฐาน 16 อยู่เป็นคู่ ๆ ก็เพราะว่า มันสั้นกว่าการเขียนเป็นเลขฐานสอง แล้วที่มันใช้ได้ก็เพราะว่า

2⁴ = 16 → เลขฐาน 16 ยาว 1 หลัก = ข้อมูล 4 bit
16 × 16 = 256 → เลขฐาน 16 ยาว 2 หลัก = ข้อมูล 1 byte

ดังนั้น

เลขฐาน 16 ยาว 2 หลัก = 1 byte

ตัวอย่าง

1010₂ = A₁₆ = 10
1101₂ = D₁₆ = 13
1010 1101₂ = AD₁₆ = 173

ความนิยมอีกเรื่อง

เนื่องจาก การจะเขียนฐานเลขห้อย ๆ เนี่ย บางทีมันทำยาก (เช่น ในคอมพิวเตอร์สมัยก่อน หรือในหน้าจอของเครื่องอะไรก็ตามที่เป็น Text Mode) เค้าเลยนิยมเอา h ห้อยท้ายแทน (h มาจาก hexadecimal ← hexa + dec = 6 + 10) ส่วนเลขฐานสอง บางที่ก็เอา b ห้อยท้ายแทนการห้อยสอง เช่น

ADh = 173
11011010b = DAh = 218

จริง ๆ เครื่องหมายอื่น ๆ ก็มีอีก ไว้จะค่อย ๆ เอามาให้ดูบ้างละกันนะ

เลขฐานสอง - ทำไมต้อง 2

2005-11-12T23:47:00.000+07:00

ทำไมคอมพิวเตอร์ถึงนิยมใช้เลขฐาน 2 ???

เอามาให้ดูเล่น ๆ ขำ ๆ นะ อย่าซีเรียสมาก แต่บางอันมันก็มีเค้านะ

ทางฟิสิกส์

ประจุมีสองขั้ว คือ บวกกับลบ เกิดจากอนุภาคสองชนิดคือ Electron และ Proton
แหล่งกำเนิดไฟฟ้ามีสองขั้ว วงจร Digital ก็เลยทำได้ง่ายที่สุดเมื่อสนใจศักย์ไฟฟ้าเพียง 2 ระดับ

ทางคณิตศาสตร์

เลขฐาน 1 ใช้ไม่ได้ (เพราะ d(i) = 1 สำหรับทุก i) เลขฐาน 2 ก็เลยเป็นฐานต่ำสุดที่ใช้ได้
complement ทำง่ายดี
วิธีหารเลขฐาน 2 ไม่มีการคูณในขั้นตอน
2 เป็นจำนวนเฉพาะตัวแรก (อันนี้ไม่ค่อยเกี่ยวแล้ว :P)
สมการพหุนามกำลังต่ำที่สุดที่สามารถมีคำตอบเป็นจำนวนเชิงซ้อน คือ 2
สูตรเส้นรอบวงของวงกลมคือ สองπr และสูตรพื้นที่ก็คือ πr^สอง (เริ่มนอกเรื่องมากขึ้น)

ด้านอื่น ๆ (หลุดเรื่องไปแล้ว)

สิ่งมีชีวิตทุกสายพันธุ์ยกเว้นคน มีเพศไม่เกิน 2 เพศ (หรืออย่างน้อย เราก็รู้แค่นี้ ... สัตว์มันอาจจะรู้กันเองก็ได้เนอะ)
อวัยวะของเรา มันจะมีเป็นคู่ ๆ
ประสาทการมองเห็นของเรา เป็นภาพสองมิติ สองภาพ
ภาค สอง ของ The Lord of the Rings ชื่อว่า The Two Towers
"น้องพลับขอสอง" (... พี่พลับขอเท่าไหร่อะวาว?)
ปาท่องโก๋ แซนด์วิช แฮมเบอร์เกอร์
ยังไม่มีเพลงชื่อว่า สามรัก สี่รัก ... n รัก นอกจาก 2
โจ้หญิงทำโทรศัพท์หายไปแล้วสองเครื่อง
http://tunococ.blogspot.com/ กับ http://www.geocities.com/tunaococ/ อยู่กันเป็นคู่

คราวนี้เพ้อเจ้อมากไปละ :D ไว้จะมาเจาะเรื่อง 1's complement กับ 2's complement กันอีกทีนะ

การแปลงฐานเลข - ส่วนทศนิยม

2005-11-11T23:04:00.000+07:00

ต่อเลยละกันนะ ... คราวนี้สมมติว่าค่า X ของเรา เป็นจำนวนจริงบวก มีส่วนจำนวนเต็มและส่วนทศนิยมอยู่ เราจะแยกสองส่วนนี้ออกจากกัน โดยสมมติให้

X = W + F

เมื่อ W ∈ Z⁺ ∪ {0} และ F ∈ [0, 1)

คราวนี้ สมมติให้ s เป็นการเขียนค่า X ในระบบเลขฐาน n เราจะรู้ว่า

X = Σ_i∈Z s(i) nⁱ

ถ้ากำหนดให้

W = Σ_i∈Z s_w(i) nⁱ
F = Σ_i∈Z s_f(i) nⁱ

สมการแรก จะเขียนได้เป็น

W + F = Σ_i∈Z [s_w(i) + s_f(i)] nⁱ

จากตอนที่แล้ว (การแปลงฐานเลข - จำนวนเต็ม) ที่เรารู้ว่า s_w(i) = 0 เมื่อ i < 0

และเนื่องจาก 0 ≤ F < 1 ทำให้รู้ว่า s_f(i) = 0 เมื่อ i ≥ 0

ดังนั้น เราจะแยกคิด s_w(i) กับ s_f(i) ได้ ...

วิธีการหา s_w(i) ก็รู้แล้ว เราจะสนใจแต่ s_f(i) นะ ... เริ่มจากสมการนี้

F = Σ_i<0 s_f(i) nⁱ
F = Σ_i>0 s_f(-i) n^-i

คูณตลอดด้วย n จะได้

nF = Σ_i>0 s_f(-i) n^-i+1

เพราะว่าเรารู้ว่า s_f(-i) ทุกตัว มีค่าไม่เกิน n - 1 ดังนั้น

Σ_i>1 s_f(-i) n^-i+1 ≤ Σ_i≥2 (n - 1) n^-i+1
Σ_i≥1 (n - 1) n^-i = 1

เราจึงแยกส่วนจำนวนเต็มกับส่วนทศนิยมได้ ดังนี้

nF = s_f(-1) + Σ_i>1 s_f(-i) n^-i+1

ผลรวมใน Σ ทางขวา จะอยู่ในช่วง [0, 1) ดังนั้น s_f(-1) = nF mod 1

ได้มาตัวนึงละ ... ทำต่อนะ ... เอา s_f(-1) ลบออกจากทั้งสองข้าง

nF - s_f(-1) = Σ_i>1 s_f(-i) n^-i+1

ค่าทั้งสองข้างของสมการ จะมีค่าอยู่ในช่วง [0, 1) เราก็เอา n คูณเข้าไปอีกที แล้วแยกส่วนเต็มกับเศษออกจากกันอีกที

n[nF - s_f(-1)] = Σ_i>1 s_f(-i) n^-i+2
n[nF - s_f(-1)] = Σ_i>0 s_f(-i - 1) n^-i+1
n[nF - s_f(-1)] = s_f(-2) + Σ_i>1 s_f(-i - 1) n^-i+1

พจน์ที่ติด Σ อยู่ด้านขวา ก็จะรวมกันได้ไม่ถึง 1 อีก ... ดังนั้น s_f(-2) = n[nF - s_f(-1)] mod 1

ถ้าเราทำซ้ำ ๆ ไปเรื่อย ๆ เราก็จะหาค่า s_f(-i) ได้ทั้งหมด

การแปลงฐานเลข - จำนวนเต็ม

2005-11-10T23:12:00.000+07:00

คราวที่แล้ว พูดถึง d_n กับ s ไปแล้ว เราก็รู้แล้วหละ ว่าค่าของเลขในระบบฐานต่าง ๆ กัน มันคิดยังไง คราวนี้เราจะมาดูการแปลงกลับมั่งนะ

ในตอนนี้ จะพูดถึงกรณีที่ไม่มีทศนิยม (จำนวนเต็ม) อย่างเดียวก่อน ...

สมมติว่าเรามีค่า X อยู่

เราอยากรู้ว่า ในระบบเลขฐาน n เราจะหาค่า s(i) ต่าง ๆ ได้ยังไง ... ความสัมพันธ์ของ X กับ s ก็คือ

X = Σ_i≥0 s(i) nⁱ

เริ่มต้นโดย หาค่า s(0) ก่อน โดยพิจารณาที่ mod n

X ≡ Σ_i≥0 s(i) nⁱ (mod n)
X ≡ s(0) (mod n)

ถ้าเราให้ s(i) ทุกตัวอยู่ในช่วง 0 ถึง n - 1 เราจะรู้ทันทีว่า s(0) = X mod n

พอรู้แล้ว เราก็เอา s(0) ลบออกจากสองข้างของสมการตั้งต้น ได้เป็นแบบนี้

X - s(0) = Σ_i≥1 s(i) nⁱ = n Σ_i≥0 s(i + 1) nⁱ

แสดงว่า ทั้งสองข้างของสมการ หารด้วย n ลงตัว ... เราก็หารซะ

(X - s(0)) / n = Σ_i≥0 s(i + 1) nⁱ

พิจารณาที่ mod n อีกครั้ง เราจะเห็นว่า

(X - s(0)) / n ≡ Σ_i≥0 s(i + 1) nⁱ (mod n)
(X - s(0)) / n ≡ s(1) (mod n)

เราก็จะสรุปได้ว่า s(1) = [(X - s(0)) / n] mod n

สังเกตว่า ถ้าเราทำซ้ำไปเรื่อย ๆ เราก็จะหา s(i) ได้ทั้งหมด

จะว่าไป ... มันก็มีส่วนคล้าย ๆ Taylor Series กับ Newton Polynomial นะเนี่ย (ลองดู Discrete vs Continuous: Taylor Series และ Newton Polynomial สิ)

เลขฐาน - มันเป็นไงในคณิตศาสตร์

2005-11-09T22:33:00.000+07:00

คราวนี้ ขอเปิดตัวเรื่องใหม่ ที่สามารถเขียนตอนละสั้น ๆ ได้ :P

ก็ ... ไหน ๆ ผมก็จะเรียน Computer Science อยู่แล้ว เริ่มสังเกตว่า ... ทำไมไม่ค่อยเขียนเรื่องคอมพิวเตอร์มั่งเลย!!!

ตอนนี้เลยขอเริ่มล่ะนะ ... เกริ่นเรื่องเลขฐานก่อน

ระบบเลขฐาน n

เลขโดดในระบบเลขฐาน n คือ 0, 1, 2, ..., n - 1 เช่น

ในระบบเลขฐาน 2 เราจะมีเลขโดด 2 ตัว คือ 0 กับ 1

ในระบบเลขฐาน 16 เราจะมีเลขโดด 16 ตัว คือ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 และ 15

ความนิยม ... ตัว A B C D E F

ก็ไม่มีอะไรหรอก เพียงแต่ว่า เวลาเค้าเขียนเลขฐาน 16 กัน มันจะสะดวกกว่า ถ้าให้

A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

เพราะเวลาเขียนจริง ๆ มันใช้เนื้อที่หลักเดียว ... เราไม่ต้องมาคอยเว้นวรรค เพื่อให้มันชัดเจน เช่น

"10 15 2"

ก็จะกลายเป็น

"AF2"

ทำให้เขียนได้สั้นลง

ค่าประจำหลัก

เพื่อให้ง่ายต่อการเขียน เราจะเขียนค่าประจำหลักที่ i ว่า d_n(i) โดยที่

d_n(i) = nⁱ

ดังนั้น ค่าประจำหลักที่ 0 ก็คือ 1 ไม่ว่า n จะเป็นเท่าไหร่

ตัวเลข

เราจะมองตัวเลขที่เราเขียน ๆ กัน เป็นฟังก์ชันของเลขหลัก ชื่อว่า s(i) แบบนี้

ถ้าเขียน s = "123" จะแปลว่า
s(0) = 3
s(1) = 2
s(2) = 1
s(อื่น ๆ) = 0

ถ้าเขียน s = "2.345" จะแปลว่า

s(0) = 2
s(-1) = 3
s(-2) = 4
s(-3) = 5
s(อื่น ๆ) = 0

ค่าจริง ๆ ของตัวเลข

ค่าจริง ๆ ของตัวเลข s บนฐาน n ก็คือ

Σ_i∈Z s(i) d_n(i)

ซึ่ง ... ถ้ามอง s กับ d_n เป็นเวกเตอร์ มันก็คือ

s ⋅ d_n

นั่นเอง

โจทย์คลายเครียด

2005-11-08T22:04:00.000+07:00

ขออภัยเป็นอย่างยิ่ง ที่ไม่สามารถ update ได้เป็นเวลานานมาาาาาาาก ... T_T

เพื่อให้สามารถชดเชยส่วนที่หายไปได้ ... ขอเขียนเรื่องละสั้น ๆ แล้วก็ เนื้อหาน้อย ๆ หน่อยนะ

คราวนี้ ได้โจทย์มาทาง E-mail ... โจทย์มีอยู่ว่า

กำหนดให้
A₁ = 1
A₂ = 2
และ A_n = A_n-1 + A_n-2
จงพิสูจน์ว่า A_n < (7/4)ⁿ เมื่อ n ≥ 1

พิสูจน์ด้วยการอุปนัยทางคณิตศาสตร์

ลองแทนค่ากรณีเริ่มต้น คือ n = 1 และ n = 2 จะเห็นว่า

A₁ = 1 < 7/4
A₂ = 2 < 49/16

คราวนี้ สมมติว่า A_n < (7/4)ⁿ สำหรับทุก n ที่ 1 ≤ n < k เราจะรู้ว่า

A_k = A_k-1 + A_k-2
A_k < (7/4)^k-1 + (7/4)^k-2
A_k < (7/4)^k-2(7/4 + 1)
A_k < (7/4)^k-2(11/4)

เนื่องจาก 11/4 = 44/16 < 49/16 = (7/4)² ดังนั้น

A_k < (7/4)^k-2(7/4)² = (7/4)^k

แสดงว่า A_n < (7/4)ⁿ เป็นจริงเมื่อ n = k ด้วย

เราก็เลยสรุปได้ว่า มันเป็นจริงสำหรับทุก n ≥ 1

Suffixes: -ascence, -iscence

2005-11-07T02:58:00.000+07:00

คราวที่แล้ว พูดถึง -escence ไปแล้ว คราวนี้ เก็บตกอีกนิดนึงละกัน

-ascence

จะว่าไป suffix ตัวนี้ มีแค่คำเดียวเอง คือ nascence (อีกตัวนึง เกิดจากเอา re- ไปเติม) แต่ความหมายก็คล้าย ๆ กันกับ -escence นะ ... ดูเลยดีกว่า

nascence [n] = event of being born
nascent [adj] = coming into existence

re'nascence [n] = revival of learning and culture
re'nascent [adj] = surging or sweeping back again

แล้วก็ มาดู suffix อีกตัว

-iscence

สำหรับ suffix ตัวนี้ มีคำอยู่ทั้งหมด 4 คำนะ คือ...

con'cupiscence ← 'concubine [n] = ภรรยาไม่จดทะเบียน | เมียน้อย

con'cupiscent [adj] = having sexual lust = libidinous, lustful, lecherous, salacious
con'cupiscence [n] = sexual desire
con'cupiscible [adj] = exciting desire

de'hiscence

de'hisce [v] = burst or split open
de'hiscent [adj] = (ผล/ฝัก/ฯลฯ) เปิดออกเพื่อปล่อยเมล็ด (หรือสปอร์) เมื่อถึงเวลา
de'hiscence [n] = การเปิดออก เพื่อปล่อยเมล็ด (หรือสปอร์)

inde'hiscence

inde'hiscent [adj] = ไม่ dehiscent
inde'hiscence [n] = ความ indehiscent

remi'niscence ← re'mind

remi'nisce [v] = นึกถึงอดีต
remi'niscent (of) [adj] = ทำให้นึกถึง
remi'niscence [n] = การระลึกถึงอดีต
remi'niscential [adj] = เกี่ยวกับความทรงจำ

Suffix: -escence

2005-11-06T02:24:00.000+07:00

คำที่ลงท้ายด้วย -escence ทั้งหมด เป็นคำนาม มีความหมายประมาณว่า "การค่อย ๆ เป็น" หรือ "กำลังจะเป็น" โดยคำส่วนใหญ่ จะมีรูป adjective เป็น -escent

ที่เอามาให้ดูนี่ จริง ๆ ไม่หมดนะ แต่ก็ส่วนใหญ่หละ ... ส่วนคำเกี่ยวข้องที่ใส่ให้เนี่ย จริง ๆ อาจจะไม่ได้เป็นที่มาที่ถูกต้อง แต่มันก็พอจะช่วยจำได้หละนะ

acqui'escence ← acquit

ac'quit [v] = exculpate, exonerate
acqui'esce [v] = เห็นด้วย โดยไม่โต้แย้ง (และอาจจะสนับสนุน)
acqui'escent [adj] = willing to acquiesce
acqui'escence [n] = การ acquiesce

ado'lescence ← adult

ado'lescent [adj] = กำลังจะเป็นผู้ใหญ่
ado'lescent [n] = วัยรุ่น
adolesce [v] = เข้าสู่ช่วงวัยรุ่น
ado'lescence [n] = ช่วงวัยรุ่น

arbo'rescence ← arbor/arbour [n] = ต้นไม้ (ที่ไม่เป็นพุ่ม)

arbo'rescent [adj] = มีกิ่งก้านสาขา เหมือนต้นไม้ = ar'boreal, ar'boreous, arboresque, arboriform
arbo'rescence [n] = สภาวะ arborescent (มักใช้กับการตกผลึก)

coalescence ← coalition

coalition [n] = กลุ่มคน, องค์กร | การรวม (สิ่งที่ต่างกัน) เข้าด้วยกัน
coalesce [v] = เติบโตด้วยกัน | อยู่ร่วมกัน
coalescent [adj] = coalescing
coalescence [n] = การรวม (สิ่งที่ต่างกัน) เข้าด้วยกัน

con'crescence ← concrete

concrete [v] = ฉาบซีเมนต์ | ทำให้แข็งขึ้น, ทำให้แน่นขึ้น, coalesce
con'crescence [n] = การก่อตัวจากอนุภาคเล็ก ๆ หลาย ๆ อนุภาค มาเกาะเข้าด้วยกัน

conva'lescence

conva'lesce [v] = ฟื้นฟูจากความเจ็บป่วย
conva'lescent [n] = ผู้ป่วยที่กำลังรักษาตัวอยู่
conva'lescent [adj] = การ convalesce | เกี่ยวกับ convalescent [n]
conva'lescence [n] = recovery, recuperation

deca'lescence ← -cal- = ความร้อน

deca'lescence [n] = ชื่อปรากฏการณ์ เมื่อโลหะได้รับความร้อนแล้วอุณหภูมิไม่เพิ่ม เพราะพลังงานที่ได้รับ สูญเสียไปในการเปลี่ยนแปลงโครงสร้างผลึก

defer'vescence ← de-, fever

defer'vesce [v] = ไข้ลด
defer'vescence [n] = การลดลงของไข้

deli'quescence ← de-, liquid

deli'quesce [v] = สลายตัว | ละลายหายไป
deli'quescent [adj] = (มักใช้กับเกลือ) ละลายเมื่อได้รับความชื้นในอากาศ
deli'quescence [n] = การ deliquesce

detu'mescence ← de-, tumor

tumor [n] = เนื้องอก
tumid [adj] = บวม | โตเกินความจำเป็น, ผิดปกติ → tumidity [n]
detu'mescence [n] = การหดตัวของส่วน/สิ่งที่บวม

effer'vescence ← effuse [v] = เท | ไหล | emit, give out

effervesce [v] = ทำให้เกิดฟอง, ตีให้เป็นฟอง
effer'vescent [adj] = มีฟอง, เป็นฟองได้ง่าย | (เครื่องดื่มหรือน้ำ) มี CO₂ อยู่เยอะ, (น้ำหวาน) อัดลม | กระตือรือร้น, สดชื่น
effer'vescence [n] = การ effervesce | คุณสมบัติการทำให้เกิดฟอง

efflo'rescence ← -flor- = ดอกไม้

efflo'resce [v] = เบ่งบาน, ผลิดอกออกผล | ตกผลึก
efflo'rescence [n] = ช่วงเวลาที่มีการผลิดอกออกผลมากที่สุด | ผื่นแดงบนผิวหนัง | สารผง ๆ บนผิวหน้า
efflo'rescent [adj] = กำลังผลิดอก = abloom, flowering

eva'nescence ← evade, evite

eva'nesce [v] = ค่อย ๆ จางหายไป
eva'nescent [adj] = กำลังจะหายไป
eva'nescence [n] = การ evanesce

ex'crescence ← excursive [adj] = ท่าทางจะหลุดประเด็น, (เนื้อหา) ครอบคลุมหลายเรื่อง

ex'crescent [adj] = กำลังโตผิดปกติ
ex'crescence [n] = สิ่งที่ยื่น/บวมออกมา | ส่วนของร่างกายที่โตผิดปกติ

flo'rescence ← -flor- = ดอกไม้

flo'rescent [adj] = blossoming = efflorescent
flo'rescence [n] = ช่วงเวลากำลังผลิดอก = efflorescence

fluo'rescence ← fluor [n] = CaF₂ (สามารถเปล่งแสงได้เมื่อโดน UV)

fluo'rescent [adj] = เปล่งแสงได้
fluo'rescence [n] = แสงที่มองเห็นได้ ซึ่งเกิดจากการดูดซับแสงที่ตามองไม่เห็น

inca'lescence ← -cal- = ความร้อน

inca'lescent [adj] = กำลังร้อนขึ้น, ความร้อนกำลังเพิ่มขึ้น
inca'lescence [n] = คุณสมบัติการรับความร้อน

incan'descence ← candent [adj] = เปล่งแสงเมื่อได้รับความร้อน

incan'descent [adj] = candent | เร้าอารมณ์
incan'descence [n] = การเปล่งแสงเมื่อได้รับความร้อน | แสงที่เกิดจาก incandescence

inflo'rescence ← -flor- = ดอกไม้

inflo'rescence [n] = florescence | ส่วนที่เป็นดอก

infruc'tescence ← -fruct- = ผลไม้

infruc'tescence [n] = ช่วงออกผล

intu'mescence ← tumor

intumesce [v] = ลอยขึ้นเป็นฟอง (จากการให้ความร้อน) | ขยาย/โตอย่างผิดปกติ = swell, tumefy
intumescent [adj] = swelling up, expanding
intumescence [n] = การบวมเนื่องจากการอุดตันของของเหลว | การบวมเมื่อโดนความร้อน

iri'descence ← irised [adj] = มีหลากสี เหมือนรุ้ง

iri'descent [adj] = มีสีต่างกัน เมื่อให้แสงต่างกัน หรือมองจากมุมต่างกัน | หลากสี
iri'descence [n] = เปล่งแสงขาวนวลจาง ๆ

juve'nescence ← juvenile

juvenile [n] = เด็ก
juvenile [adj] = เด็ก
juve'nescent [adj] = กำลัง (โตขึ้น) เป็นเด็ก
juve'nescence [n] = การย่างเข้าสู่วัยเด็ก

lumi'nescence ← luminous [adj] = เปล่งแสง

lumi'nescent [adj] = เปล่งแสงได้โดยไม่ต้องให้ความร้อน
lumi'nescence [n] = การเปล่งแสงโดยไม่ต้องใช้ความร้อน | แสงจาก luminescence

obmu'tescence ← mute [adj] = เงียบ | พูดไม่ได้

obmu'tescence [n] = การปิดปากเงียบ ไม่พูด

obso'lescence ← obso'lete

obso'lesce [v] = become obsolete
obso'lescent [adj] = becoming obsolete
obso'lescence [n] = การ obsolesce

opa'lescence ← opal

opa'lescent [adj] = iridescent
opa'lescence [n] = iridescence

phospho'rescence ← phosphorus

phospho'resce [v] = exhibit phosphorescence
phospho'rescence [n] = phosphorescence

pu'bescence ← puberty

pu'bescent [adj] = อยู่ในช่วงที่ต่อมสืบพันธุ์เริ่มทำงาน
pu'bescence [n] = ช่วงที่ต่อมสืบพันธุ์เริ่มทำงาน

pu'trescence ← putrid, putrefaction

putrid [adj] = เน่า, ส่งกลิ่นเหม็น
putre'fy [v] = become putrid
pu'trescent [adj] = becoming putrid
pu'trescence [n] = การ putrefy | ช่วงเวลาที่กำลัง putrefy

qui'escence ← quiet

qui'esce [v] = become quiet
qui'escent [adj] = quiet, inactive
qui'escence [n] = ความเงียบสงบ (อาจจะชั่วคราว)

recru'descence ← re'cur, re'cursion

recru'desce [v] = เกิดขึ้น (อีกครั้ง), (แผล) เปิด
recru'descent [adj] = recrudescing
recru'descence [n] = การกลับคืนมา หลังจากหายไปหรือลดลง

rejuve'nescence ← re'juvenate, juvenile

rejuve'nescent [adj] = becoming rejuvenated | causing to become rejuvenated
rejuve'nescence [n] = การสร้างผนังเซลล์ใหม่ | การกลับไปเป็นเด็ก

se'nescence ← senior

se'nesce [v] = grow old
se'nescent [adj] = growing old
se'nescence [v] = การแก่ตัวลง

tu'mescence ← tumor, tumid

tumesce [v] = ขยาย/โต อย่างผิดปกติ = intumesce, swell, tumefy
tu'mescent [adj] = บวม/โต อย่างผิดปกติ = tumid, turgid, swollen
tu'mescence [n] = อาการบวมเนื่องจากการคั่งของของเหลว (เช่นเลือด) ในเนื้อเยื่อ = tumidity

Center of Mass & Centroid - ทฤษฎีบทของ Pappus

2005-11-05T20:37:00.000+07:00

ทฤษฎีบทของ Pappus ที่กำลังจะบอกเนี่ย (คือ จริง ๆ เค้าคิดไว้หลายอัน) เป็นทฤษฎีพื้นฐานที่สำคัญมาก ในการหาปริมาณ n มิติของรูปเรขาคณิต เช่น ความยาว พื้นที่ ปริมาตร ฯลฯ เค้าบอกไว้ว่า ...

สมมติว่า เรามีเซต X ซึ่งอยู่ใน Rⁿ และมีปริมาณใน n มิติเท่ากับ A
แล้วเราเอา X ไปไว้ใน Rⁿ⁺¹

จับ X เคลื่อนที่ ในแนวตั้งฉากกับตัว X เอง เพื่อกวาดปริมาณใน n + 1 มิติ
บริเวณที่ X กวาดผ่าน จะมีปริมาณใน n + 1 มิติ เท่ากับ As
เมื่อ s = ระยะทางที่ centroid ของ X เคลื่อนที่

หวังว่า ไม่งงนะ :D

Direct Application

ดูตัวอย่างประกอบเลยละกัน ... อันนี้ค่อนข้างชัดเจนนะ

ดูทฤษฎีมันไม่ค่อยจะมีประโยชน์เลยเนอะ :P ... ลองดูอีกอันซิ

อันนี้ก็ ... ดูมีประโยชน์ขึ้นนิดนึงละ ... ไหนลองเอามาหาพื้นที่ผิวของรูป 3 มิติมั่งสิ

พื้นที่ผิวของกรวย ...

แล้วก็ เอามาหาปริมาตรมั่ง ... คราวนี้ X ต้องเป็น 2 มิตินะ

ตรงกับสูตร "(1/3) × ปริมาตรทรงกระบอก" เลย เห็นมั้ยว่า สูตรเรขาคณิตหลาย ๆ สูตร สามารถคิดได้ง่าย ๆ ด้วยทฤษฎีบทของ Pappus อันนี้

Reverse Use

เมื่อกี๊ ยกตัวอย่างไปแล้ว 4 ตัวอย่าง ทุกอันจะใช้ปริมาณใน n มิติ กับระยะการเคลื่อนที่ของ centroid เพื่อหาปริมาณใน n + 1 มิติ แต่จริง ๆ เราจะใช้กลับกันก็ได้ คือ ใช้หาตำแหน่ง centroid แทน

ตัวอย่างเช่น เรารู้อยู่แล้วว่า

ส่วนโค้งครึ่งวงกลม มีความยาว = πr
พื้นที่ผิวของทรงกลม = 4πr²

เราจะสามารถหา centroid ของส่วนโค้งครึ่งวงกลม ได้แบบนี้ ...

เอาตัวอย่างให้ดูอีกอันละกัน

พื้นที่ของครึ่งวงกลม = (1/2)πr²
ปริมาตรของทรงกลม = (4/3)πr³

เราจะหา centroid ของแผ่นครึ่งวงกลม ได้แบบนี้

จริง ๆ ที่เอาเรื่องนี้มาให้ดูเนี่ย เน้นที่ แนวการใช้กลับทางหนะ ... คือ ... อยากให้สังเกตกันว่า เมื่อเราคิดสมการอะไรได้ มันก็อาจจะมีวิธีใช้ในทางย้อนกลับ ซึ่งช่วยให้เราแก้ปัญหาบางอย่าง ได้ง่ายกว่าการคิดตรง ๆ

แนวคิดย้อนกลับ ก่อนนี้ก็เคยเอามาให้ดูไปแล้วเต็ม ๆ คือ ในเรื่อง ตามหาความหมายของ Determinant: Reverse Use - Height กับ ตามหาความหมายของ Determinant: Kramer's Rule นะ

Discrete vs Continuous: Taylor Series และ Newton Polynomial

2005-11-04T00:44:00.000+07:00

Taylor Series

สมมติว่า เรามีฟังก์ชัน f ซึ่งต่อเนื่อง และมีอนุพันธ์ทุกอันดับที่ x₀

เราก็จะรู้ค่า f(x₀) f'(x₀) f''(x₀) ... ไปเรื่อย ๆ

คราวนี้ ถ้าเราอยากจะหาฟังก์ชัน f(x) ในรูปของพหุนาม เราจะใช้สมการนี้

f(x) = Σ_n≥0 f⁽ⁿ⁾(x₀)(x - x₀)ⁿ/n!

อนุกรมทางด้านขวาของสมการ เราเรียกว่า อนุกรมเทย์เลอร์ (Taylor Series)

ทำไมอนุกรมเทย์เลอร์ เท่ากับ f(x)?

เริ่มต้นเนี่ย เราก็สมมติว่า

f(x) = Σ_n≥0 a_n (x - x₀)ⁿ

แล้วหาค่า a_n ทุกตัว

พอเราแทนค่า x = x₀ เข้าไป จะเห็นว่า f(x₀) = a₀

เมื่อเราหาอนุพันธ์ทั้งสองข้าง เราจะได้ว่า

f'(x) = Σ_n≥1 na_n (x - x₀)^{n - 1}
= Σ_n≥0 (n + 1) a_n+1 (x - x₀)ⁿ

ซึ่งทำให้ f'(x₀) = a₁

หาอนุพันธ์อีกที จะได้

f''(x) = Σ_n≥1 n(n + 1) a_n (x - x₀)^{n - 1}
= Σ_n≥0 (n + 1)(n + 2) a_n+1 (x - x₀)ⁿ

ซึ่งทำให้ f''(x₀) = 2a₂

ทำไปเรื่อย ๆ เราจะสรุปได้ว่า

f⁽ⁿ⁾(x₀) = n! a_n
a_n = f⁽ⁿ⁾(x₀) / n!

ดังนั้น

f(x) = Σ_n≥0 f⁽ⁿ⁾(x₀)(x - x₀)ⁿ/n!

Newton Polynomial

ถ้าเรารู้ค่า f(x₀) Δf(x₀) Δ²f(x₀) ...

เราจะสามารถหาฟังก์ชัน f(x) ในรูปของพหุนามได้โดยสมการนี้

f(x) = Σ_n≥0 Δⁿf(x₀) (x - x₀)ⁿ/n!

เราเรียกสมการนี้ว่า สูตรผลต่างล่วงหน้าของนิวตัน (Newton's Forward Difference Formula)

วิธีพิสูจน์สูตรนี้ ก็ทำเหมือนเมื่อกี๊แหละ คือเราจะหาค่าของ Δⁿf(x₀) แต่ละตัวได้โดยการหาผลต่าง คือ

สมมติให้ f(x) = Σ_n≥0 a_n(x - x₀)ⁿ

เราก็จะหาค่า a_n ต่าง ๆ ได้ด้วยวิธีเหมือน ๆ กันกับกรณีของอนุกรมเทย์เลอร์ แบบนี้...

f(x₀) = a₀
Δf(x₀) = a₁
Δ²f(x₀) = 2a₂
...
Δⁿf(x₀) = n! a_n

ดังนั้น

a_n = Δⁿf(x₀) / n!

ซึ่งเมื่อแทนค่าลงไปในสมการที่เราตั้งขึ้น ก็จะได้สูตรนี้

f(x) = Σ_n≥0 Δⁿf(x₀) (x - x₀)ⁿ/n!

Abstraction

เราจะเห็นว่า การพิสูจน์สูตรทั้งสอง มีขั้นตอนที่เหมือนกันทุกประการ แต่มีการกำหนดสูตรเริ่มต้นที่ต่างกัน ซึ่งทำให้ การแปลง ที่ใช้ในการหาสัมประสิทธิ์ aⁿ ต้องเป็นคนละตัวกัน

ถ้าจะมองขั้นตอนทั้งหมด ให้เป็นกรณีทั่วไปมากขึ้น เราก็จะทำได้ดังนี้ ...

สมมติว่า มีการแปลงเชิงเส้น T และฟังก์ชัน s_n(x) ซึ่งมีคุณสมบัติดังนี้

s₀(0) = k
s_n(0) = 0 ; n > 0
Ts₀(x) = 0
Ts_n(x) = c_n s_n-1(x) ; n > 0
โดยที่ c_n ไม่เป็นฟังก์ชันของ x

เราจะสามารถสมมติฟังก์ชัน f(x) ให้เป็นแบบนี้ได้

f(x) = Σ_n≥0 a_n s_n(x)

เพราะ เมื่อเราแทนค่า x = 0 ลงไป เราจะหาค่า a₀ ได้ ...

f(0) = k a₀

ส่วนค่า a_n ตัวอื่น ๆ ก็สามารถหาได้โดยการใส่ T เข้าไปทั้งสองข้างของสมการที่เราสมมติขึ้น

Tf(x) = Σ_n≥0 a_n Ts_n(x)
Tf(x) = a₀Ts₀(x) + Σ_n≥1 a_n Ts_n(x)
Tf(x) = 0 + Σ_n≥1 a_n c_n s_n-1(x)
Tf(x) = Σ_n≥0 a_n+1 c_n+1 s_n(x)

พอเราแทนค่า x = 0 ก็จะได้ว่า

Tf(0) = a₁c₁k
a₁ = Tf(0) / c₁k

ส่วนค่า a₂ ก็จะหาได้โดยการใส่ T เข้าไปอีกที ที่สมการ Tf(x) = Σ_n≥0 a_n+1 c_n+1 s_n(x) จะได้ว่า

T²f(x) = Σ_n≥0 a_n+1 c_n+1 Ts_n(x)
T²f(x) = a₁c₁Ts₀(x) + Σ_n≥1 a_n+1 c_n+1 Ts_n(x)
T²f(x) = 0 + Σ_n≥1 a_n+1 c_n+1 c_n s_n-1(x)
T²f(x) = Σ_n≥0 a_n+2 c_n+2 c_n+1 s_n(x)

T²f(0) = a₂c₂c₁k
a₂ = T²f(0) / c₁c₂k

สังเกตดู จะเห็นว่า ถ้าทำไปเรื่อย ๆ เราก็จะหาค่า a_n ได้ทุกค่า ดังนี้

a_n = Tⁿf(0) / c₁c₂c₃...c_nk

ถ้ากำหนดให้ c₀ = k และเขียนผลคูณของ c_i ต่าง ๆ ด้วยเครื่องหมาย Π ก็จะได้ว่า

a_n = Tⁿf(0) / C(n)

เมื่อ C(n) = Π_0≤i≤n c_i

สรุปก็คือ

f(x) = Σ_n≥0 Tⁿf(0) s_n(x) / C(n)

กรณีของอนุกรมเทย์เลอร์

s_n(x) = xⁿ
T = d/dx
c₀ = 1
c_n = n ; n ≥ 1
C(n) = n!

กรณีของพหุนามนิวตัน

s_n(x) = xⁿ
T = Δ
c₀ = 1
c_n = n ; n ≥ 1
C(n) = n!

Transformation: Linear Transformation

2005-11-03T18:55:00.000+07:00

ปริภูมิเวกเตอร์ (Vector Space)

ปริภูมิเวกเตอร์ จะถูกนิยามด้วย 6 สิ่ง คือ

เซตของเวกเตอร์ V
การบวกของเวกเตอร์ +_V
การคูณเวกเตอร์ด้วยสัมประสิทธ์ *_V
เซตของสัมประสิทธิ์ F
การบวกของสัมประสิทธ์ +_F
การคูณของสัมประสิทธ์ *_F

โดยที่ (F, +_F, *_F) มีคุณสมบัติเป็น ฟิลด์ (Field) คือ

ถ้า x, y ∈ F แล้ว x +_F y ∈ F และ x *_F y ∈ F
ถ้า x, y, z ∈ F แล้ว x +_F (y +_F z) = (x +_F y) +_F z และ x *_F (y *_F z) = (x *_F y) *_F z
ถ้า x, y ∈ F แล้ว x +_F y = y +_F x และ x *_F y = y *_F x
มีสมาชิก 0_F ∈ F เพียงตัวเดียว ที่ทำให้ x +_F 0_F = x
มีสมาชิก 1_F ∈ F เพียงตัวเดียว ที่ทำให้ x *_F 1_F = x
ถ้า x ∈ F แล้ว จะมี (-x) ∈ F เพียงตัวเดียว ที่ทำให้ x +_F (-x) = 0_F
ถ้า x ∈ F - { 0_F } แล้ว จะมี (1/x) ∈ F เพียงตัวเดียว ที่ทำให้ x *_F (1/x) = 1_F

และเงื่อนไขต่อไปนี้ เป็นจริง

ถ้า x, y ∈ V และ c ∈ F แล้ว x +_V y ∈ V และ c *_V x ∈ V
ถ้า x, y, z ∈ V แล้ว x +_V (y +_V z) = (x +_V y) +_V z
ถ้า x, y ∈ V แล้ว x +_V y = y +_V x
มีสมาชิก 0_V ∈ V เพียงตัวเดียว ที่ทำให้ x +_V 0_V = x
ถ้า x ∈ V แล้ว จะมี (-x) ∈ V เพียงตัวเดียว ที่ทำให้ x +_V (-x) = 0_V
ถ้า x ∈ V และ a, b ∈ F แล้ว a *_V (b *_V x) = (a *_F b) *_V x
ถ้า x ∈ V แล้ว 1_F *_V x = x
ถ้า x, y ∈ V และ c ∈ F แล้ว c *_V (x +_V y) = (c *_V x) +_V (c *_V y)
ถ้า x ∈ V และ a, b ∈ F แล้ว (a +_F b) *_V x = (a *_V x) +_V (b *_V x)

ความนิยม

เนื่องจาก การคูณและบวกที่ห้อย V กับ F จะทำได้เฉพาะกับสมาชิกที่มาจากเซตต่างกัน เราสามารถตัดตัวห้อยทิ้ง แล้วก็ยังเข้าใจถูกต้องอยู่
เราสามารถตัดเครื่องหมายการคูณทิ้งได้ด้วย โดยใช้การเขียนติดกันแทน
0_V เราจะใช้ตัวหนาเขียนแทน เป็น 0 เพื่อให้ สามารถเขียน 0 และ 1 แทน 0_F และ 1_F ได้ ตามลำดับ
เขียนแทน a + (-b) ด้วย a - b เพื่อให้สั้นลง
เขียนแทน a(1/b) ด้วย a/b เพื่อให้สั้นลง
เมื่อไม่เขียนวงเล็บ ให้คิดการคูณก่อนการบวก และคิดจากซ้ายไปขวาเสมอ
ตัวแปรที่เป็นสมาชิกของ V จะเขียนด้วยตัวหนา

การแปลงเชิงเส้น (Linear Transformation)

ถ้า f:V → W เป็นการแปลงเชิงเส้น (Linear Transformation) และ V กับ W เป็น ปริภูมิเวกเตอร์ ซึ่งมีฟิลด์ของสัมประสิทธิ์เดียวกันคือ F

สำหรับ x ∈ A และ y ∈ A ทุกตัว: f(x + y) = f(x) + f(y) ∈ B
สำหรับ x ∈ A และ c ∈ F: f(cx) = cf(x) ∈ B

สิ่งที่รู้ทันที คือ

f(0_V) = 0_W

เราก็เลย เขียนว่า 0 เฉย ๆ ได้ พิสูจน์ได้ ไม่ยากหรอก

Kernel และ Image

เมื่อไหร่ที่เราพูดถึง homomorphism (และ linear transformation) จะต้องมีคำศัพท์ที่เรายุ่งด้วย 2 คำ คือ Kernel และ Image เสมอ ๆ

kernel ของ f = { x ∈ V | f(x) = 0 }
image ของ f = { f(x) | x ∈ V }

ความจริงที่สิ่งสำคัญมาก ๆ อย่างนึงก็คือ kernel ของ f เป็น ปริภูมิเวกเตอร์ย่อย (Vector Subspace) ของ V ซึ่งก็คือ ถ้าเราเอา kernel ของ f ไปใส่แทน V ในเงื่อนไขต่าง ๆ ของปริภูมิเวกเตอร์ ที่เขียนไว้ข้างบน มันก็จะเป็นจริงทั้งหมดเช่นกัน

ตัวอย่าง: ให้ K = kernel ของ f

x, y ∈ K ⇒ f(x) = f(y) = 0
ดังนั้น f(x + y) = 0 + 0 = 0
แสดงว่า x + y ∈ K ด้วย

เงื่อนไขอื่น ๆ ก็พิสูจน์ได้ด้วยวิธีคล้าย ๆ กัน

Quotient Subspaces

เนื่องจาก ปริภูมิเวกเตอร์ มีคุณสมบัติการสลับที่การบวก ดังนั้น เราอาจจะมองว่า (V, +) เป็น กรุปอาบีเลียน (Abelian Group) ซึ่ง คุณสมบัตินี้ ทำให้ กรุปย่อย (Subgroup) ทุกอันของ V เป็น กรุปย่อยปกติ (Normal Subgroup) ด้วย (ใครอ่านอันนี้ไม่รู้เรื่อง ช่างมันไปก่อน)

ผลก็คือ เราจะสามารถหา coset (ไม่ต้องไปสนชื่อมันก็ได้) ต่อไปนี้ได้

q(x) = { k + x | k ∈ K }
เมื่อ x ∈ V

เพื่อความสะดวก เราจะเขียนแทน q(x) ด้วยสัญลักษณ์นี้

q(x) = K + x

คราวนี้ ถ้าเรานิยามการบวกและคูณ สำหรับ q(x) ต่าง ๆ ใหม่ แบบนี้

(K + x) + (K + y) = K + (x + y)
c(K + x) = K + cx

และให้เอกลักษณ์ของการบวก คือ

K + 0 = 0_K = K

เราจะพิสูจน์ได้ว่า เซตของ q(x) และเครื่องหมายบวกกับคูณแบบใหม่นี้ ก็เป็นปริภูมิเวกเตอร์เช่นกัน เรามักจะเขียนเซตของ q(x) ทั้งหมด ว่า V/K

Isomorphisms

Isomorphism ของ ปริภูมิเวกเตอร์ ก็คือ การแปลงเชิงเส้นที่มีคุณสมบัติ 1-1 และทั่วถึงน่ะแหละ

ปริภูมิเวกเตอร์ A และ B จะ Isomorphic กัน ก็ต่อเมื่อ มี isomorphism จาก A ไป B

ที่อยากจะบอกก็คือ V/K เนี่ย isomorphic กับ image ของ f นะ

พิสูจน์ยังไงน่ะหรอ? เราก็สร้าง isomorphism φ ขึ้นมาอันนึง แบบนี้

φ(K + x) = f(x)

คราวนี้ เราจะบอกว่า φ มันมีคุณสมบัติ 1-1 ได้โดย

สมมติว่า φ(K + x) = φ(K + y)
แสดงว่า f(x) = f(y)
ซึ่งทำให้ f(x) - f(y) = 0
f(x - y) = 0 = φ(K + (x - y))
แต่จากนิยามของ K เมื่อ f(x - y) = 0 แสดงว่า x - y ∈ K = 0_K
ทำให้ K + (x - y) = 0_K
(K + x) - (K + y) = 0_K
K + x = K + y

การพิสูจน์ว่า φ มีคุณสมบัติทั่วถึง จะง่ายกว่า คือทำแบบนี้

สมมติว่า y ∈ image ของ f
เราจะรู้ว่า ต้องมี x ∈ V ที่ทำให้ f(x) = y
ดังนั้น K + x ∈ V/K จะทำให้ φ(K + x) = y แน่นอน

คุณสมบัติอื่น ๆ ไม่พูดถึงแล้วนะ ไปพิสูจน์กันเอาเอง

Cardinal Numbers

สมมติว่า W = image ของ f เราจะรู้สิ่งที่สำคัญมาก ๆ ก็คือ

|V| = |K| × |W| = |K| × |V/K|

เมื่อ | ... | หมายถึง cardinal number

Dimensions

ใครที่เรียน linear algebra คงพอจะรู้ว่า dimension คืออะไรนะ

ยกตัวอย่างคร่าว ๆ ละกัน

dim R = 1
dim R² = 2
dim R³ = 3
...
dim Rⁿ = n

dim span( { (1, 1), (1, 0) } ) = 2
dim span( { (1, 1, 1), (1, 1, 0), (1, 0, 0) } ) = 3
dim span( { (1, 1, 1), (1, 1, 0), (0, 0, 1) } = 2
dim span( { (1, 1, 1), (2, 2, 2), (3, 3, 3) } = 1

จะว่าไป dimension มันก็ คล้าย ๆ กับ เอาขนาดของเซต ใส่ log ฐาน c = |R| เลย ... เราก็เลยได้ความสัมพันธ์คล้าย ๆ กัน แบบนี้

จาก |V| = |K| × |W|

ใส่ log_c เมื่อ c = |R| เข้าไปทั้งสองข้าง จะได้

log_c|V| = log_c(|K| × |W|)
log_c|V| = log_c|K| + log_c|W|

dim V = dim K + dim W

พับกล่องลูกบาศก์

2005-11-02T13:57:00.000+07:00

เวลาเราจะพับกล่องลูกบาศก์ด้วยกระดาษเนี่ย รู้สึกเหมือน ตอนเด็ก ๆ เค้าจะบอกให้ตัดกระดาษมาแบบนี้

แต่จริง ๆ แล้วมันตัดแบบอื่นก็ได้นะ ... คือ ถ้าเราเอาเส้นตรง 4 ช่อง มาม้วน มันจะได้กล่องที่แหว่งไป 2 ด้าน ซึ่งทั้งสองด้านนั้น อยู่ตรงข้ามกัน เราสามารถเพิ่มด้านที่หายไปได้ โดยเอาไปติดกับขอบใดขอบนึง ...

ดังนั้น รูปของกระดาษที่ทำเป็นกล่องได้ จะสามารถคิดได้แบบนี้

รูปทั้งหมดที่เป็นไปได้ก็คือ

(ไปหมุน ๆ สลับ ๆ เอาเองนะ)

รูปต่อไปนี้ คือรูปที่มีเส้นแนวกลางยาว 3 และพับเป็นกล่องได้

แต่นอกจากรูปพวกนี้ ก็ยังมีอีก 2 แบบ ที่พับเป็นกล่องได้ คือ

วิธีคิดอย่างหยาบ ๆ ว่า รูปไหนสามารถทำได้บ้าง เราคิดแบบนี้

"หน้าแต่ละหน้า จะมีหน้าตรงข้ามได้เพียงหน้าเดียว"

สมมติว่า เราต้องการหาหน้าที่อยู่ตรงข้ามกับหน้า X เราจะใช้หลักการแบบนี้

ถ้ามีแผ่นที่อยู่ติดกับ X ด้านบน แผ่นที่อยู่เหนือ X 2 ช่องที่อยู่ใกล้กับ X มากที่สุด จะเป็นหน้าตรงข้ามของ X

เช่น ในรูปข้างล่างนี้ แผ่นสีฟ้ากับเขียว จะเป็นหน้าตรงข้ามกัน

ในทิศอื่น ๆ เราก็คิดแบบนี้เหมือนกัน

ลองเอารูปที่ทำได้ซักอันนึง มาวิเคราะห์ดูสิ

เมื่อเราวิเคราะห์รูปที่ไม่สามารถพับเป็นกล่องได้ เราจะพบว่า หน้าบางหน้าไม่มีหน้าตรงข้าม หรือ หน้าบางหน้ามีหน้าตรงข้ามมากกว่า 1

ในรูปข้างล่างนี่ หน้าสีแดง ไม่มีหน้าตรงข้าม

ส่วนในรูปข้างล่างนี้ หน้าสีฟ้า มีหน้าตรงข้ามมากกว่า 1

จบละ :D

การยกกำลังกับจำนวนเชิงซ้อน

2005-11-01T12:49:00.000+07:00

ก่อนเริ่ม

จำนวนเชิงซ้อนใด ๆ สามารถเขียนในรูป

a + ib และ re^iθ

ได้ โดยที่ค่า a b r และ θ เป็นจำนวนจริง

ค่า θ สามารถมีได้หลายค่า เพราะว่า

e^iθ = cos θ + i sin θ

ดังนั้น

e^iθ = e^{i(θ + 2πn)}

สำหรับจำนวนเต็ม n ใด ๆ

ต่อไปนี้ จะให้ y กับ z เป็นจำนวนเชิงซ้อน ซึ่ง y = a + ib และ z = re^iθ และ x เป็นจำนวนจริงนะ

การยกกำลังจำนวนจริงด้วยจำนวนเชิงซ้อน

x^y = x^{a + ib} = x^a x^ib = x^a (e^{ln x})^ib = x^a e^{ib ln x}

ถ้าให้ x > 0 แล้ว f(a, b) = x^a e^{ib ln x} เป็นฟังก์ชัน 1 ต่อ 1 รึเปล่า?

คำตอบก็คือ "ไม่" ...

เหตุผลแรก ... ถ้า x = 1 เราจะเห็นว่า x^a = 1 เสมอ ไม่ว่า a จะเป็นอะไร ดังนั้น f(a, b) จะเท่ากันสำหรับทุกค่า a

แล้วถ้าเพิ่มเงื่อนไขให้เป็น x ∈ R⁺ - { 1 } หละ?

ก็ยังไม่ได้อยู่ดี เพราะว่า e^{ib ln x} = e^{i(b ln x + 2πn)} ดังนั้น

ถ้าให้ b' ln x = b ln x + 2πn
b' = b + 2πn / ln x
e^{ib ln x} = e^{ib' ln x}

จะเห็นว่า สามารถทำให้ f(a, b') = f(a, b) ได้โดยที่ b' ≠ b

งั้น ... ถ้าเราเพิ่มอีกเงื่อนไขนึง คือ b ln x ∈ [0, 2π) หละ?

f(a, b) ก็จะเป็นฟังก์ชัน 1 ต่อ 1 แล้ว!

การยกกำลังจำนวนเชิงซ้อนด้วยจำนวนจริง

z^x = (re^iθ)^x = r^xe^iθx

f(x) = z^x อาจจะไม่เป็นฟังก์ชันนะ!

ทำไมน่ะเหรอ? ... ก็ เพราะว่า e^iθ = e^{i(θ + 2πn)} หนิ ลองเอาไปแทนใหม่ดู

f(x) = z^x = (re^{i(θ + 2πn)})^x = r^xe^{i(θx + 2πnx)}

พอเป็นหยั่งงี้ มันก็เริ่มดูเพี้ยน ๆ แล้วหละ ... z^x มีได้หลายค่า ขึ้นอยู่กับ n ... f(x) ไม่ใช่ฟังก์ชันแล้ว!

จริง ๆ มันก็ไม่แปลกเท่าไหร่นะ ... ก็ ตอนเราหาคำตอบของสมการ z² = 1 เรายังได้คำตอบ 2 ค่าเลยหนิ

แล้วเมื่อไหร่ f(x) จะเป็นฟังก์ชันหละ?

ถ้า x เป็นจำนวนเต็ม → nx เป็นจำนวนเต็ม
พอ nx เป็นจำนวนเต็มแล้ว → g(x) = e^{i(θx + 2πnx)} มีได้ค่าเดียว ก็เลยเป็นฟังก์ชัน
เนื่องจาก f(x) = r^xg(x) และ g(x) เป็นฟังก์ชัน → f(x) เป็นฟังก์ชัน

นี่ก็แปลว่า ถ้าให้ x เป็นจำนวนเต็ม z^x จะเป็นฟังก์ชัน นั่นเอง

แต่ เพื่อให้เขียนสะดวก เรามักจะสมมติให้ z^x เป็นฟังก์ชัน โดยเพิ่มข้อกำหนดอีกแบบเข้าไปเลย คือ

z = re^iθ เมื่อ 0 ≤ θ < 2π
และ z^x = r^xe^ixθ

ค่าของ iⁱ

เนื่องจาก i = e^iπ/2 ดังนั้น

iⁱ = (e^iπ/2)ⁱ = e^-π/2

อ๊ะ ... iⁱ = e^-π/2 = 0.207879576... !!!

ไม่ใช่ิสิ :P ... อย่าลืมว่า จริง ๆ แล้ว i = e^{i(π/2 + 2πn)} เมื่อ n เป็นจำนวนเต็มบวกใด ๆ ... คิดใหม่แบบติด n ก็จะได้

iⁱ = (e^{i(π/2 + 2πn)})ⁱ = e^{-π/2 - 2πn}

iⁱ ก็เลยมีได้หลายค่า ... แต่ทุกค่า เป็นจำนวนจริงนะ!

การยกกำลังจำนวนเชิงซ้อนด้วยจำนวนเชิงซ้อน

คราวนี้ มาลองหาค่า z^y กัน ...

z^y = (re^iθ)^{a + ib} = [r^a r^ib] (e^iθ)^{a + ib}
z^y = [r^a e^{ib ln r}] (e^{i(θ + 2πm)})^{a + ib}
z^y = r^a e^{i(b ln r + 2πn)} e^{i(θa + 2πma)} e^{-θb - 2πmb}
z^y = [r^ae^{-θb - 2πmb}] e^{i(b ln r + θa + 2πma + 2πn)}

จะเห็นว่า ค่าของ z^y จะมีได้หลายค่า อยากที่คาดเอาไว้ แต่คราวนี้ มีตัวแปรอิสระถึง 2 ตัว คือ m กับ n

ดังนั้น ถ้าเป็นไปได้ ก็ไม่ควรเอาจำนวนเชิงซ้อนมายกกำลังกันนะ :D

Halting Problem

2005-10-31T10:05:00.000+07:00

ปัญหา Halting Problem เนี่ย เป็นปัญหาสุดคลาสสิกอันนึงสำหรับคนที่เรียนคอมพิวเตอร์ โจทย์มีอยู่ว่า

เราจะสร้างโปรแกรม (หรือคำสั่ง) ชื่อว่า H ที่รับ input 2 ตัว คือ

X = โปรแกรม (คือ source code หรือ object code หรือ อะไรก็ได้)

Y = input (ทั้งหมด) ของโปรแกรม X

และมี output เป็น

"หยุด" ถ้า X(Y) หยุดการทำงานในเวลาจำกัด

"ไม่หยุด" ถ้า X(Y) ไม่หยุดการทำงาน (ก็คือ ติด loop หนะ)

โดยที่ H(X, Y) ทำงานเสร็จในเวลาจำกัด (นับเป็นจำนวนคำสั่งก็ได้) ได้รึเปล่า?

H(X, Y) ทำงานเสร็จในเวลาจำกัด แปลว่า H(H, (X, Y)) ให้คำตอบเป็น "หยุด" เสมอน่ะนะ

คำตอบของปัญหานี้ ก็มีคนตอบได้มานานแล้วหละ แต่วิธีการหาคำตอบเนี่ย น่าสนใจ ... เค้าใช้วิธีพิสูจน์แบบขัดแย้ง แบบนี้...

สมมติว่า H(X, Y) มีอยู่จริง เราจะสร้างโปรแกรม L(X) แบบนี้ได้

L(X)

If H(X, X) = "หยุด", then loop forever.
Else (if H(X, X) = "ไม่หยุด"), do nothing.

แปลว่า ถ้า H(X, X) ให้คำตอบเป็น "หยุด" H(L, X) จะเป็น "ไม่หยุด" แต่ถ้า H(X, X) ให้คำตอบเป็น "ไม่หยุด" H(L, X) จะเป็น "หยุด"

คราวนี้ เราก็ลองคิดดูว่า H(L, L) มันจะเป็นอะไร ...

ถ้า H(L, L) = "หยุด"

ตามนิยามของ H: L(L) ต้องหยุด
ตามนิยามของ L: แปลว่ามันไปตกที่ "Else, ..." ดังนั้น H(L, L) = "ไม่หยุด"

ถ้า H(L, L) = "ไม่หยุด"

ตามนิยามของ H: L(L) ต้องไม่หยุด
ตามนิยามของ L: แปลว่ามันไปตกที่ "If ..., then ..." ดังนั้น H(L, L) = "หยุด"

จะเห็นว่า ไม่ว่าจะสมมติให้ H(L, L) เป็นอะไร มันก็จะเกิดความขัดแย้งเสมอ แสดงว่า จริง ๆ แล้วเราไม่สามารถสร้าง H ได้นั่นเอง

ความพยายามสร้าง H(X, Y) ที่ใกล้เคียงที่สุด ก็คือ

H(X, Y) ตอบว่า "หยุด" ในเวลาจำกัด ถ้า X(Y) หยุดการทำงานในเวลาจำกัด
H(X, Y) ไม่สามารถตอบอะไรได้ และไม่หยุดการทำงาน ถ้า X(Y) ไม่หยุดการทำงาน

ซึ่ง H(X, Y) แบบนี้ ก็ไม่ต่างจากการปล่อยให้ X(Y) ทำงานเฉย ๆ

โยงกลับไปที่ภาษาอันดับหนึ่งนิดนึง เคยพูดไว้ในตอนท้ายเรื่อง ตรรกศาสตร์: Unification แล้วว่า

"จะว่าไป มันก็เทียบได้กับ halting problem น่ะแหละ (เทียบได้จริง ๆ นะ เหมือนกัันเด๊ะเลย)"

ก็เลยเอามาเทียบกันให้ดูอีกที ว่าทำไมมันเหมือนกัน ... อันนี้คือ ความเป็นจริงเกี่ยวกับการพิสูจน์ว่า ประพจน์เป็นจริงรึเปล่า เมื่อมีกฎต่าง ๆ ให้

"ถ้าประพจน์ที่ต้องการพิสูจน์เป็นจริง เมื่อได้ประพจน์ว่าง (จาก resolution) เราก็จะรู้ แต่ถ้ามันไม่จริง เราก็อาจจะต้องทำไปเรื่อย ๆ เรื่อย ๆ ... เหมือนกับ ไม่มีทางรู้เลย ว่ามันเป็นจริงรึเปล่า"

ส่วนในกรณีของ H(X, Y) ที่สามารถสร้างได้ ...

"ถ้า X(Y) หยุดการทำงาน เราก็จะได้คำตอบจาก H(X, Y) แต่ถ้า X(Y) ไม่หยุดการทำงาน H(X, Y) ก็จะทำงานไปเรื่อย ๆ ... ไม่มีทางรู้ว่ามันจะหยุดรึเปล่า"

จบละ

Transformation Matrix: ผลคูณภายใน

2005-10-30T16:33:00.000+07:00

เรื่องนี้เป็นภาคต่อของ Transformation Matrix: พื้นฐาน นะ ไม่ยากเหมือนตอนที่แล้ว ๆ มา

เราจะเริ่มที่เรื่องของ ผลคูณภายใน ก่อน แต่คราวนี้ จะคิดกรณีของจำนวนเชิงซ้อนด้วย

สมมติว่าเรามีเวกเตอร์ u อยู่ เราคิดว่า ค่าในแต่ละมิติของ u เป็นฟังก์ชันของเลขมิติ (เหมือนกับในตอน Discrete: ฟังก์ชัน เวกเตอร์ และเมตริกซ์) คือ

u = (u(1), u(2), u(3), ..., u(n))

แต่เดิม เราคิดว่าผลคูณภายในของ u กับ v ที่มีมิติเป็น n เท่ากัน คือ

u ⋅ v = Σ_1≤i≤n u(i)v(i)

ดังนั้น ขนาดของ u สามารถหาได้จาก (คราวนี้ขอเขียนว่า |u| นะ)

|u|² = u ⋅ u = Σ_1≤i≤n u(i)²

หรือก็คือ

|u| = (u ⋅ u)^1/2

แต่ ถ้าเกิด u(i) เป็นจำนวนเชิงซ้อนหละ ... u ⋅ u อาจจะไม่ใช่จำนวนจริงก็ได้ แล้ว |u| ก็อาจจะมีได้ 2 ค่าน่ะสิ (จากสมการ |u|² = u ⋅ u)

เราแก้ปัญหานี้ได้ โดยนิยามอะไรใหม่นิดนึง ... ถ้าเรากำหนดให้ สังยุกต์ (Conjugate) ของเวกเตอร์ เป็นแบบนี้

u^* = (u(1)^*, u(2)^*, u(3)^*, ..., u(n)^*)

พอเราหา u^* ⋅ u ผลก็คือ

u^* ⋅ u = Σ_1≤i≤n u(i)^*u(i)

จากความรู้เรื่องจำนวนเชิงซ้อน เรารู้ว่า ถ้า z เป็นจำนวนเชิงซ้อนใด ๆ แล้ว z^*z = |z|² เป็นจำนวนจริง ดังนั้น u^* ⋅ u ของเรา ก็จะเป็นจำนวนจริงด้วย

เราเลยนิยาม ผลคูณภายใน ใหม่ แบบนี้

u ⋅ v แบบใหม่ = u^* ⋅ v แบบเก่า

แต่ u ⋅ v แบบใหม่ มีคุณสมบัติต่างกับแบบเก่าด้วย คือ

u ⋅ v ≠ v ⋅ u (หมายถึง ไม่จำเป็นต้องเท่ากันเสมอไป)
แต่ u ⋅ v = (v ⋅ u)^* เสมอ

เมื่อคิดเวกเตอร์เป็นเมตริกซ์แนวตั้ง

ถ้าเรามอง u เป็นเมตริกซ์มิติ n × 1 เราก็ยังเขียนว่า

u = (u(1), u(2), u(3), ..., u(n))

ได้เหมือนเดิม ... แต่เดี๋ยวลองกำหนด u^* ใหม่ ให้เป็นแบบนี้

u^* = [u(1)^* u(2)^* u(3)^* ... u(n)^*]

หรือก็คือ

u^* แบบใหม่ = (u^*)^T แบบเก่า

พอเราหาผลคูณแบบเมตริกซ์ของ u^* กับ v ก็จะได้ผลเป็น เมตริกซ์มิติ 1 × 1 แบบนี้

u^*v = [u ⋅ v]

เพื่อให้เขียนง่ายขึ้น เราจะถือซะว่า เมตริกซ์มิติ 1 × 1 เป็นจำนวนเชิงซ้อนตัวเดียวเลยละกัน ... มันจะเป็น

u^*v = u ⋅ v

ผลคูณภายในของเมตริกซ์กับเมตริกซ์

เราลองใช้นิยามผลคูณภายในอย่างเดียวกันกับเมตริกซ์ดู เราจะหาขนาดของเมตริกซ์ได้รึเปล่านะ?

A ⋅ A = A^*A = ?

ถ้าเรามองว่า A เป็นเมตริกซ์ที่มีมิติ m × n ซึ่งประกอบด้วยเวกเตอร์แนวตั้ง แบบนี้

A = [A₁ : A₂ : A₃ : ... : A_m]

A^* จะเป็นเมตริกซ์ที่มีมิติ n × m หน้าตาแบบนี้

A^* = (A₁^* : A₂^* : A₃^* : ... : A_m^*)

เผื่อลืม: รูปการคูณเมตริกซ์

เอามาจาก Transformation Matrix: พื้นฐาน นะ

ดังนั้นค่าของ A^*A จะเป็นเมตริกซ์มิติ n × n แบบนี้

B = A^*A
B_i,j = A_i ⋅ A_j

เมื่อ B_i,j คือ ค่าในแถวที่ i หลักที่ j ของ B

คราวนี้ คุณสมบัติสำคัญก็คือ

A_i ⋅ A_j = (A_j ⋅ A_i)^*

ซึ่งทำให้

B_i,j = B_{j, i}^*

ซึ่งแปลว่า

B = B^*

เราเรียกเมตริกซ์ที่มีคุณสมบัตินี้ว่า เมตริกซ์เฮอร์มิเชียน (Hermitian Matrix)

ไป ๆ มา ๆ เราก็ไม่ได้ขนาดของ A แฮะ แต่ได้คุณสมบัติที่ว่า A ⋅ A เป็นเมตริกซ์เฮอร์มิเชียนแทน

แล้ว แต่ละค่า B_i,j มันมีความหมายว่ายังไงหละ?

ถ้าเวกเตอร์ A_i ตั้งฉากกันทุกคู่

ดังนั้น A_i ⋅ A_j จะเป็น 0 เมื่อ i ≠ j

มันก็แปลว่า B_i,j = 0 เมื่อ i ≠ j น่ะสิ

A ⋅ A ก็จะเป็น เมตริกซ์ทแยงมุม (Diagonal Matrix)!!!

เราจะเขียนได้ว่า ... (สัญลักษณ์แบบนี้ เอามาจาก Transformation Matrix: Eigenvalues & Eigenvectors "ตอนแรก" นะ)

A ⋅ A = [ B_1,1 \ B_2,2 \ B_3,3 \ ... \ B_n,n ]

เนื่องจาก B_i,i = A_i ⋅ A_i = |A_i|² เป็นจำนวนจริง ดังนั้น

A ⋅ A เป็นเมตริกซ์จำนวนจริงด้วย

เรื่องของ Determinant

ถ้า A เป็นเมตริกซ์จัตุรัส เราจะหา det(A) ได้

เนื่องจาก det(A) เกิดจากการเอาค่า A มาคูณกับบวกกัน ดังนั้น

det(A^*) = det(A)^*

ดังนั้น เราก็เลยรู้แน่ ๆ ว่า

det(A ⋅ A) เป็นจำนวนจริง

เพราะว่า

det(A ⋅ A) = det(A^*A) = det(A)^*det(A)

เป็นจำนวนจริงแน่นอน

ดังนั้น เราอาจจะนิยาม ขนาดของ A อีกแบบนึง ซึ่งเป็นจำนวนจริงไม่ติดลบเสมอ ดังนี้

|A| = det(A ⋅ A)^1/2

ซึ่งสิ่งที่เราได้เพิ่มมาอีกอย่างก็คือ ... A ไม่จำเป็นต้องเป็นเมตริกซ์จัตุรัสก็ได้น่ะสิ !!!

Transformation Matrix: Eigenvalues & Eigenvectors "การคำนวณ"

2005-10-29T22:50:00.000+07:00

พล่ามเรื่อง eigenvalue กับ eigenvector ไปเยอะละ แต่ยังไม่ได้บอกเลย ว่าเราจะหามันได้ยังไง :P คิดว่าถึงเวลาแล้วหละ มาลองดูกันดีกว่า

Analytical Solution

จำได้มั้ยว่า ใน Transformation Matrix: Eigenvalues & Eigenvectors "คุณสมบัติ" เรารู้มาอย่างนึงว่า

λ จะเป็น eigenvalue ของ A ก็ต่อเมื่อ det(A - λI) = 0

ดังนั้น เราก็ตั้งต้นด้วยสมการ

det(A - λI) = 0

สมการนี้ มักจะเรียกกันว่า "Characteristic Equation" ของปัญหาการหา eigenvalue และ eigenvector นี้ ส่วนพหุนาม P(λ) = det(A - λI) ก็จะเรียกว่า "Characteristic Polynomial"

ถ้า A มีมิติเป็น n × n เราจะรู้ว่า det(A - λI) เป็นพหุนามดีกรี n อย่างแน่นอน ดังนั้น เราจะสามารถหา eigenvalue λ ได้ n ตัว (นับตัวซ้ำด้วย)

คราวนี้ พอเราเอา λ แต่ละตัว ไปแทนใน

(A - λI)e = 0

จะได้ระบบสมการที่มี n สมการ และมีตัวแปร n ตัว ซึ่งมีคุณสมบัติ linear dependency (เพราะว่า det เป็น 0) ดังนั้น เซตของคำตอบจะมีจำนวนนับไม่ถ้วน ซึ่งก็ถูกต้อง เพราะว่า eigenvector มีจำนวนเป็นอนันต์

แต่ถ้าหาก λ ที่เลือกไปแทนในสมการ (A - λI)e = 0 นั้น ไม่ใช่รากซ้ำจากการแก้สมการ P(λ) = 0 เราจะรู้ว่า eigenvector ทั้งหมดที่ได้จะมีทิศขนานกัน

Eigenvalue ของเมตริกซ์สมมาตรที่มีสมาชิกเป็นจำนวนจริง เป็นจำนวนจริง

รู้สึกว่ากรณี A = A^T นี่จะพูดบ่อยจังเนอะ :D

วิธีพิสูจน์อันนี้ อาจจะดูแปลก ๆ หน่อย แต่ทุกขั้นตอนก็จำเป็นนะ เราจะเริ่มโดยสมมติว่า e เป็น eigenvector ที่อาจจะมีค่าที่ไม่ใช่จำนวนจริงก็ได้ เราจะพิสูจน์ว่า λ ซึ่งเป็น eigenvalue ของมัน ต้องเป็นจำนวนจริง

เราจะเขียน e^* เพื่อหมายถึง เมตริกซ์ conjugate transpose ของ e ซึ่งก็คือ เอาค่าในแต่ละมิติของ e^T ไปเปลี่ยนเป็น conjugate ของมัน

คราวนี้ ผลคูณภายในของเวกเตอร์เชิงซ้อน u กับ v ใด ๆ เราก็จะเขียนเป็น u^*v แทน u ⋅ v

เริ่มพิสูจน์โดยการหา e ⋅ Ae ...

e^*Ae = λ ||e||²

คราวนี้ ลองใส่ * เข้าไปทั้งสองข้าง

(e^*Ae)^* = (λ ||e||²)^*

ใช้คุณสมบัติที่ว่า (XY)^* = Y^*X^* กระจายเครื่องหมาย * ในฝั่งซ้าย ส่วนฝั่งขวา กระจายแค่ conjugate เข้าไปที่ λ เพราะว่า ||e||² เป็นจำนวนจริงอยู่แล้ว จะได้ว่า

e^*A^*e = λ^* ||e||²

แต่จากเงื่อนไขที่ว่า A เป็นเมตริกซ์จำนวนจริง และสมมาตร เราเลยรู้ว่า A = A^* ซึ่งทำให้

e^*Ae = λ^* ||e||²

ฝั่งซ้ายของสมการนี้ เท่ากับฝั่งซ้ายของสมการข้างบน (กลับไปดูสิ) พอจับมันมาเท่ากัน เราจะได้

λ ||e||² = λ^* ||e||²
λ = λ^*

สรุปได้แล้วว่า λ ต้องเป็นจำนวนจริง

ข้อจำกัดของ Analytical Solution

เนื่องจาก เราสามารถคำตอบเชิงวิเคราะห์ (Analytical Solution) ของสมการ P(λ) = 0 ได้ก็ต่อเมื่อ n ≤ 4 (ความจริงข้อนี้ พิสูจน์ยากมาก ๆ ... ขอยกมาเฉย ๆ ละกัน) ดังนั้น ในกรณีที่ n > 4 เราจะต้องหาวิธีทางตัวเลข (Numerical Method) เพื่อแก้สมการนี้

การหารากของสมการพหุนามแบบ numerical เนี่ย มันก็มีอยู่หลายวิธีแหละ แต่ ... จริง ๆ ถ้าเราจะหา numerical method อยู่แล้ว เราลองหาจากปัญหาต้นแบบได้มั้ย? แบบที่ไม่ต้องยุ่งกับ P(λ) หนะ

Numerical Solution

วิธีที่จะบอกเนี่ย เป็นหลักการเบื้องต้นนะ ในการใช้งานจริง ต้องมีการปรับปรุง เปลี่ยนแปลง อีกเยอะเลย

เริ่มละนะ ... สมมติว่าเรามีเวกเตอร์อะไรก็ไม่รู้ เส้นนึง ชื่อว่า u แล้วก็ สมมติว่า eigenvector ของเรา มีอยู่ n ตัว คือ e₁ e₂ e₃ ... e_n และ eigenvalue ก็คือ λ₁ λ₂ λ₃ ... λ_n ตามลำดับ

เนื่องจาก ตัวเลขห้อย e กับ λ มันจะเรียงกันยังไงก็ได้ เราก็สมมติซะว่า

λ₁ ≥ λ₂ ≥ λ₃ ≥ ... ≥ λ_n

ละกัน ... จากนั้น ก็สมมติว่า a_i เป็นผลจากการลองหาค่า Au แบบนี้

Au = a₁e₁ + a₂e₂ + a₃e₃ + ... + a_ne_n

สมมติว่า a₁ ≠ 0 ก่อนนะ คราวนี้ เราลองเอา A ใส่เข้าไปอีกที ทั้งสองข้างของสมการ ผลจะเป็น

A²u = λ₁a₁e₁ + λ₂a₂e₂ + λ₃a₃e₃ + ... + λ_na_ne_n

ถ้าเอา A ใส่ซ้ำไปเรื่อย ๆ มันจะเป็น ...

A^p+1u = λ₁^pa₁e₁ + λ₂^pa₂e₂ + λ₃^pa₃e₃ + ... + λ_n^pa_ne_n

คราวนี้ ถ้าหาก λ₁ > λ₂ ... ลองดึง λ₁ ออกมาจากสัมประสิทธิ์ทุกตัวสิ

A^p+1u = λ₁^p(a₁e₁ + (λ₂/λ₁)^pa₂e₂ + (λ₃/λ₁)^pa₃e₃ + ... + (λ_n/λ₁)^pa_ne_n)

พอเราให้ p → ∞ แล้ว เราจะเห็นว่า (λ_i/λ₁)^p เป็น 0 หมดทุกตัวยกเว้นเมื่อ i = 1 ดังนั้นข้อสรุปของเราก็คือ

A^p+1u ≈ λ₁^pa₁e₁

แสดงว่า การเอา A คูณซ้ำ ๆ ไปเรื่อย ๆ จะทำให้เราได้ e₁ ออกมาเอง

แต่ ถ้าหาก λ₁ = λ₂ = λ₃ = ... = λ_m หละ? (m ≤ n นะ) ... เราก็ดึงตัวร่วมออกจากทุกตัวได้อยู่ดีนะ มันจะเป็นงี้

จาก A^p+1u = λ₁^p(a₁e₁ + (λ₂/λ₁)^pa₂e₂ + (λ₃/λ₁)^pa₃e₃ + ... + (λ_n/λ₁)^pa_ne_n)

แต่ λ₁ = λ₂ = λ₃ = ... = λ_m > λ_m+1 (ถ้า m = n ก็ถือซะว่า λ_n+1 = 0 ไปเลย) ดังนั้น

A^p+1u = λ₁^p(a₁e₁ + a₂e₂ + a₃e₃ + ... + a_me_m
+ (λ_m+1/λ₁)^pa_m+1e_m+1 + (λ_m+2/λ₁)^pa_m+2e_m+2+ (λ_n/λ₁)^pa_ne_n)

ซึ่ง เมื่อ p → ∞ เราจะได้ว่า

A^p+1u ≈ λ₁^p(a₁e₁ + a₂e₂ + a₃e₃ + ... + a_me_m)

ผลลัพธ์ที่ได้เป็นเวกเตอร์ a₁e₁ + a₂e₂ + a₃e₃ + ... + a_me_m ซึ่งเรารู้ว่า มันก็เป็น eigenvector เหมือนกัน เพราะว่า eigenvalue มันเท่ากัน (พิสูจน์ไปแล้วในหัวข้อย่อย "จริง ๆ แล้ว จำนวน Eigenvector เป็นอนันต์" ในเรื่อง Transformation Matrix: Eigenvalues & Eigenvectors "คุณสมบัติ")

ดังนั้น เราจึงสรุปได้ว่า การเอาเวกเตอร์ที่เราสุ่มขึ้นมา คูณด้วย A ไปเรื่อย ๆ เราจะได้ eigenvector ตัวที่มีค่า eigenvalue สูงสุดออกมาเอง

มีอีกเรื่องที่ยังคาใจเราอยู่นะ คือ เมื่อตอนแรก เราสมมติว่า a₁ ≠ 0 ... แล้วถ้า a₁ = 0 มันจะเป็นยังไงน่ะเหรอ? เราก็คิดที่ a₂ แทนสิ ... ผลลัพธ์ก็คือ eigenvector ที่มี eigenvalue มากเป็นอันดับรองลงมาไงหละ

ดังนั้น ถ้าเรามั่วเวกเตอร์ u มาครั้งแรก แล้วเราหา e₁ ได้แล้ว เราก็มั่ว u มาอีกตัวที่ทำให้ a₁ = 0 ซะ คราวนี้ เราก็จะได้ e₂ แทน ... ทำซ้ำไปเรื่อย ๆ เราก็จะได้ e_i ครบทุกตัว

ในทางปฏิบัติ ทุกครั้งที่เราเอา A มาคูณ เราควรจะ normalize ผลลัพธ์ด้วย เพื่อให้ขนาดของเวกเตอร์ ไม่ใหญ่เกินไป จนเกิดปัญหา overflow

ผลพลอยได้จากปัญหา Eigenvector

มีคนเค้าพิสูจน์ไว้แล้วว่า ถ้าเราสมมติ P(λ) เป็นพหุนามดีกรี n ที่มีสัมประสิทธิ์เป็นจำนวนจริง ขึ้นมาอันนึง เราจะสามารถหา A ที่ทำให้ P(λ) = det(A - λI) ได้เสมอ

ดังนั้น ... แทนที่เราจะใช้ numerical method สำหรับหารากของสมการพหุนาม มาแก้ปัญหา eigenvector เราก็สามารถทำกลับกันได้ โดนเปลี่ยนปัญหาการหารากของสมการพหุนาม ไปเป็นปัญหา eigenvector แล้วใช้วิธีอย่างเมื่อกี๊

แปลว่า เราได้ numerical method สำหรับหารากของสมการพหุนาม เพิ่มขึ้นอีกวิธี ก็คือ วิธีการหา eigenvector นี่เอง

ทิ้งท้าย

จริง ๆ แล้ว numerical method สำหรับหา eigenvector เนี่ย มันมีอีกหลายวิธีมาก ๆ แต่ที่ยกมาให้ดูเนี่ย อยากให้เห็นวิธีการประยุกต์ความรู้มากกว่า (มันไม่ยาก แต่ใช้งานได้)

Transformation Matrix: Eigenvalues & Eigenvectors "คุณสมบัติ"

2005-10-28T01:35:00.000+07:00

ขอกำหนดข้อตกลงบางอย่างก่อนนะ ไม่อยากจะเขียนอะไรยั้วเยี้ย ...

A เป็นเมตริกซ์จัตุรัสที่มีมิติเท่ากับ n × n และมี eigenvector
A_i คือเวกเตอร์ของ แถว ที่ i ของ A (สังเกตว่า แถว เรียงอยู่ในแนวนอน แต่ถือว่า A_i เป็นเมตริกซ์แนวตั้ง) ดังนั้น A = ( A₁ : A₂ : A₃ : ... : A_n )

เผื่อลืม: ถ้าไม่รู้ว่าสัญลักษณ์ ( A₁ : A₂ : A₃ : ... : A_n ) คืออะไร ไปดูที่ Transformation Matrix: พื้นฐาน นะ

คุณสมบัติพื้นฐาน ที่สำคัญ ๆ ของ eigenvalue และ eigenvector ก็คือ

λ เป็น Eigenvalue ของ A ก็ต่อเมื่อ det(A - λI) = 0

สมมติว่า u เป็น eigenvector ของ A และมี eigenvalue เป็น λ จากนิยาม เราจะรู้ว่า

Au = λu
Au - λu = 0

จาก Iu = u

Au - λIu = 0

จากคุณสมบัติการกระจายของเมตริกซ์

(A - λI)u = 0

ได้ระบบสมการเชิงเส้น n ตัวแปร ที่พจน์ของค่าคงที่ทางขวาเป็น 0 หมด

เนื่องจากเราสนใจเฉพาะกรณี u ≠ 0 แสดงว่า สามารถเลือก u ที่ทำให้ (A - λI)u = 0 ได้ มันก็แปลว่า

เซตของเวกเตอร์ n เส้น จากแต่ละแถวของ A - λI มีคุณสมบัติ linear dependency

ซึ่งประโยคนี้ เทียบเท่ากับ

det(A - λI) = 0

เผื่อลืม: เรื่องของ det กับคุณสมบัติ linear dependency มีอยู่ใน 3 เรื่องนี้นะ

ตามหาความหมายของ Determinant: Linear Combination

Discrete: Linear Dependency

Continuous: Linear Dependency

ตอนนี้เราพิสูจน์ "ถ้า ... แล้ว" ได้เรียบร้อยละ การจะพิสูจน์ย้อนกลับก็ง่าย ๆ นะ ทำจากล่างขึ้นบนก็ได้เลย เพราะมันเป็น "ก็ต่อเมื่อ" ทุกขั้น ไม่เขียนให้ดูละกัน

จริง ๆ แล้ว จำนวน Eigenvector เป็นอนันต์

เหมือนกับโกหกกันไปแล้วทีนึงนะ ว่าปกติ จะมี eigenvector อยู่ (ไม่เกิน) n เส้น ... :P

จริง ๆ มันก็ไม่ใช่โกหกอะนะ เพราะมีคำว่า "ปกติ" อยู่ :D ... จริง ๆ มันขึ้นกับนิยามมากกว่าแหละ ลองดูนี่สิ

Au = λu

ถ้าเราเอาจำนวนจริง c ≠ 0 คูณเข้าไปทั้งสองข้าง

cAu = cλu

จากคุณสมบัติพื้นฐานของเมตริกซ์และเวกเตอร์ ...

A(cu) = λ(cu)

เห็นมั้ยว่า ถ้า u เป็น eigenvector แล้ว cu ก็เป็น eigenvector แต่ว่าเวกเตอร์พวกนี้มันขนานกัน บางคนก็เลยไม่สนใจไง ถือว่ามันเป็นพวกเดียว ๆ กัน นับ 1 (หรือจะบอกว่า นับแต่ unit eigenvector ก็ได้)

แต่มันก็มีความไม่ปกติที่ไม่ได้มาจากนิยามด้วยนะ ลองดูกรณีที่ eigenvector สองตัวมี eigenvalue เท่ากันซักหน่อย ...

Au = λu
Av = λv
⇓
A(pu + qv) = λ(pu + qv)
ดังนั้น pu + qv ก็เป็น eigenvector

ผลรวมเชิงเส้นของ eigenvector พวกนี้ ก็เป็น eigenvector หมดเลย!!!

แนะแนวการมอง

สมมติว่า E เป็นเซตของ eigenvector ทั้งหมดของ A และเราต้องการเลือก eigenvector กลุ่มนึง (ให้เป็นเซต S) ซึ่งมีคุณสมบัติว่า span(E) = span(S) และจำนวนสมาชิกของ S น้อยที่สุด

คุณสมบัติที่สำคัญอย่างแรกของ E (และ S) ก็คือ ถ้า x ∈ span(E) แล้ว Ax ∈ span(E) ด้วย เพราะว่า

A(a₁e₁ + a₂e₂ + a₃e₃ + ... + a_me_m)
= a₁Ae₁ + a₂Ae₂ + a₃Ae₃ + ... + a_mAe_m
= λ₁a₁e₁ + λ₂a₂e₂ + λ₃a₃e₃ + ... + λ_ma_me_m ∈ span(E)
เมื่อ m = | E |

ถ้า A เป็นเมตริกซ์สมมาตรแล้ว x จะตั้งฉากกับ e ∈ E ก็ต่อเมื่อ Ax ตั้งฉากกับ e

ถ้า A เป็นเมตริกซ์สมมาตร เราจะรู้ว่า

A = A^T

สมมติว่า e เป็น eigenvector ที่มี eigenvalue เป็น λ เราจะรู้ว่า

Ae = λe

แล้วก็สมมติอีกว่า x เป็นเวกเตอร์ที่ตั้งฉากกับ e

x ⋅ e = 0

เพื่อให้เขียนง่ายขึ้น เราจะเขียนแทนผลคูณภายในด้วยการคูณเมตริกซ์ แบบนี้ ...

x^Te = 0

จากสมการแรก ถ้าเราเอา x^T คูณทางซ้าย จะได้เป็น

x^TAe = λx^Te
x^TAe = 0

ซึ่ง ถ้าใส่ transpose เข้าไป จะกลายเป็น

e^TA^Tx = 0

แต่เนื่องจาก A = A^T ดังนั้น

e^TAx = 0

แสดงว่า Ax ตั้งฉากกับ e ด้วย

ส่วนการพิสูจน์ย้อนกลับว่า "ถ้า Ax ตั้งฉากกับ e แล้ว x ตั้งฉากกับ e ด้วย" ก็ทำย้อนกลับได้ง่าย ๆ เหมือนกัน ... ไม่เขียนให้ดูแล้วนะ

การสร้าง Orthonormal Basis จาก Eigenvector

จริง ๆ เราสามารถหาเซต S ของ eigenvector ที่ตั้งฉากกันและเป็น basis ที่สมบูรณ์ (span(S) = span(E)) ได้จากแนวคิดที่แล้ว โดยคิดว่า ถ้าเราหา eigenvector ได้แล้วตัวนึง เราก็ตัดเวกเตอร์ทั้งหมดที่ไม่ตั้งฉากกับ eigenvector ตัวนั้นทิ้งจากการพิจารณาได้ ดังนั้น eigenvector ตัวต่อ ๆ ไปที่หาได้ มันจะตั้งฉากกับตัวก่อนหน้าทั้งหมด

ที่เอามาให้ดูต่อไปนี้ เป็นอีกวิธีนึงสำหรับพิสูจน์ การมีอยู่จริงของ orthonormal basis จาก eigenvector โดยใช้หลักการที่ว่า ถ้าเซต S ของ eigenvector ยังไม่เป็น basis ที่สมบูรณ์ (คือ span(S) ≠ span(E)) เราจะสามารถหา e ∈ E - S ที่ตั้งฉากกับสมาชิกทุกตัวใน S ได้

สมมติว่า u กับ v เป็น eigenvector สองตัวที่มี eigenvalue เป็น λ กับ μ ตามลำดับ

Au = λu
Av = μv

เติมผลคูณภายในเข้าไปแบบนี้

v^TAu = λv^Tu
u^TAv = μu^Tv

เอาอันล่างมา transpose จะได้

v^TA^Tu = μv^Tu

เนื่องจาก A = A^T ฝั่งซ้ายของสมการนี้ จะไปเท่ากับสมการข้างบน ดังนั้น

λv^Tu = μv^Tu

ซึ่งแปลว่า λ = μ หรือ v^Tu = 0

ถึงตรงนี้ บางคนอาจจะเห็นว่า มันคล้าย ๆ กับบทพิสูจน์เรื่องที่แล้วเลย ... ถูกแล้วหละ จริง ๆ มันคืออันเดียวกันเลย

ถ้า v^Tu = 0 มันก็แปลว่า u ตั้งฉากกับ v อยู่แล้ว ... ส่วนอีกกรณีนึง ...

ถ้า λ = μ

เราพิสูจน์ไปแล้วว่า

w = pu + qv จะเป็น eigenvector ด้วย

ซึ่งถ้า u กับ v ไม่ขนานกัน เราจะสามารถหา w ที่ตั้งฉากกับ u ได้แน่ ๆ

Transformation Matrix: Eigenvalues & Eigenvectors "ตอนแรก"

2005-10-27T02:55:00.000+07:00

ถ้าใครช่างสังเกตหน่อย จะเห็นว่า ผมเปลี่ยนชื่อหัวข้อไปนิดนึง จากที่วางแผนไว้ใน Tunoblog Summarized จาก ...

เดิม Transformation: Eigenvalues & Eigenvectors
เป็น Transformation Matrix: Eigenvalues & Eigenvectors (คงมีหลายตอน)

จริง ๆ มันเป็นตั้งแต่ตอนที่แล้วแล้วแหละ (Transformation Matrix: Orthonormal Transformations) แต่ก็ยังไม่ลบชื่อหัวข้อเดิมออก ... มันเป็นความจงใจหนะนะ คือ จะเขียนต่ออีก ... ตอนนี้ขอเข้าเรื่องก่อน

นิยามของ Eigenvalue และ Eigenvector

ขอบอกนิยามสำหรับกรณีเมตริกซ์จัตุรัสมิติจำกัดก่อนนะ กรณีที่ทั่วไปมากขึ้น จะพูดถึงในตอนถัด ๆ ไป

Eigenvalues & Right Eigenvectors

ให้ A เป็นเมตริกซ์จัตุรัส มิติ n × n
และให้ u เป็นเวกเตอร์ n มิติ (คือ เมตริกซ์แนวตั้ง มิติ n × 1 หนะ)
ถ้าสามารถหาจำนวนจริง λ ที่ไม่ใช่ 0 ที่ทำให้
Au = λu ได้
จะเรียก u ว่าเป็น Eigenvector ทางขวา ของ A
และจะเรียก λ ว่าเป็น Eigenvalue ของ u

ที่เอานิยามแบบนี้มาให้ดู เพราะมันเป็นความนิยมหนะ จริง ๆ แล้ว ถ้าเราให้ u เป็นเมตริกซ์แนวนอน มิติ 1 × n และเปลี่ยนเงื่อนไขของสมการเป็น

uA = λu

เราก็จะเรียก u ว่าเป็น Eigenvector ทางซ้าย ของ A

เรื่องมหัศจรรย์มีอยู่ว่า ... λ มันจะเท่ากันทั้งสองกรณีน่ะสิ

เมตริกซ์ของ Eigenvalue และ เมตริกซ์ของ Eigenvector

ตอนนี้ ขอเรียก eigenvector ทางซ้ายว่า eigenvector เฉย ๆ นะ จะได้สั้น ๆ และตรงตามความนิยม

"โดยทั่วไป" แล้ว เมตริกซ์ n × n จะมี eigenvector อยู่ n ตัว ดังนั้น eigenvalue ก็จะมีอยู่ n ตัวด้วย

สมมติว่า n = 3 ก่อนละกันนะ แล้วก็ให้ λ₁ λ₂ λ₃ เป็น eigenvalue ทั้งสามของ เมตริกซ์ A ที่มีมิติ 3 × 3

เราจะเขียนเมตริกซ์ของ eigenvalue เป็นเมตริกซ์ทแยงมุมดังนี้

D₁ = (λ₁, 0, 0)
D₂ = (0, λ₂, 0)
D₃ = (0, 0, λ₃)
D = [ D₁ : D₂ : D₃ ]

เพื่อให้เขียนง่าย ๆ หน่อย ขอย่อเมตริกซ์ทแยงมุมเป็นแบบนี้นะ

D = [ λ₁ \ λ₂ \ λ₃ ]

ส่วนเมตริกซ์ของ eigenvector ก็แค่เอา eigenvector มาต่อกัน มันก็จะได้เมตริกซ์จัตุรัสเอง ... หน้าตาแบบนี้

P = [ u₁ : u₂ : u₃ ]

Eigen Decomposition

แล้วไอ้เมตริกซ์เมื่อกี๊ มันเอาไว้ทำอะไรอะ?

เดี๋ยวจะเอาให้ดู ว่าประโยชน์มันคืออะไร

สมมติก่อนว่า A เป็นเมตริกซ์ที่มีมิติเป็น 3 × 3 ซึ่งมี eigenvector 3 เส้น คือ u₁ u₂ u₃ และ eigenvector ทั้งสาม จับคู่กับ eigenvalue 3 ค่า คือ λ₁ λ₂ λ₃ ตามลำดับ ... จากนั้น กำหนดให้

D = [ λ₁ \ λ₂ \ λ₃ ]
P = [ u₁ : u₂ : u₃ ]

เราจะรู้ว่า

AP = A[ u₁ : u₂ : u₃ ]
AP = [ Au₁ : Au₂ : Au₃ ]
AP = [ λ₁u₁ : λ₂u₂ : λ₃u₃ ]

และ

PD = [ u₁ : u₂ : u₃ ][ λ₁ \ λ₂ \ λ₃ ]
PD = [ λ₁u₁ : λ₂u₂ : λ₃u₃ ]

ดังนั้น

AP = PD
A = PDP^-1

การยกกำลังเมตริกซ์ด้วย Eigen Decomposition

อันนี้เป็น หนึ่งในการใช้งานที่สุดแสนจะคลาสสิก และง่ายด้วย ... ความรู้ที่ต้องใช้ก็คือ

[ λ₁ \ λ₂ \ λ₃ ]ⁿ = [ λ₁ⁿ \ λ₂ⁿ \ λ₃ⁿ ] เมื่อ n เป็นจำนวนเต็มใด ๆ

คราวนี้ สมมติว่าเราอยากหา Aⁿ เราก็แตกด้วย Eigen Decomposition ก่อน แล้วทำแบบนี้

A = PDP^-1
A² = PDP^-1 PDP^-1 = PD²P^-1
A³ = PD²P^-1 PDP^-1 = PD³P^-1
...
Aⁿ = PDⁿP^-1

เนื่องจาก Dⁿ มันหาได้ง่าย ๆ จากสมการข้างบน ดังนั้น วิธีนี้จึงมีประสิทธิภาพสูงกว่าการคูณมันไปเรื่อย ๆ ตรง ๆ เห็น ๆ

นอกจากนี้ อินเวอร์สของ A ก็หาได้ด้วยวิธีเดียวกัน ... แบบนี้

Aⁿ = PDⁿP^-1
I = PDⁿP^-1A^-n
P^-1 = DⁿP^-1A^-n
D^-nP^-1 = P^-1A^-n
PD^-nP^-1 = A^-n

ดังนั้น สมการ Aⁿ = PDⁿP^-1 ก็เลยใช้ได้กับจำนวนเต็ม n ใด ๆ ไม่จำกัดเฉพาะจำนวนเต็มบวก (เป็น 0 ก็ได้นะ)

คราวนี้ พอเราหาเมตริกซ์ยกกำลังได้สะดวก ๆ แล้ว พหุนามของเมตริกซ์ก็เขียนได้ง่าย ๆ เหมือนกัน

สมมติว่า f(A) เป็นพหุนามของ A
ถ้าเราสามารถแยก A = PDP^-1 ได้ เราจะรู้ว่า
f(A) = P f(D) P^-1
ซึ่งทำให้ f(A) = P [ f(λ₁) \ f(λ₂) \ f(λ₃) \ ... \ f(λ_n) ] P^-1

พอรู้หยั่งงี้ ฟังก์ชันสุดฮิต e^x ของเรา ก็ใช้กับเมตริกซ์ได้แล้ว เพราะว่า เราสามารถเขียนให้อยู่ในรูปของพหุนามได้ ดังนี้

e^A = 1 + A + A²/2! + A³/3! + ...

ดังนั้น ถ้าเราแทนค่า e^A = f(A) ในความสัมพันธ์ f(A) = P [ f(λ₁) \ f(λ₂) \ f(λ₃) \ ... \ f(λ_n) ] P^-1 จะได้ว่า

e^A = P [ e^λ₁ \ e^λ₂ \ e^λ₃ \ ... \ e^λ_n ] P^-1

และที่ยิ่งไปกว่านี้ ... หน้าตาแบบนี้ ทำไมมันจะใช้ได้แค่ e หละ? ... ขยายต่อสิ ให้ฐานมันเป็นจำนวนจริงอะไรก็ได้

a^A = P [ a^λ₁ \ a^λ₂ \ a^λ₃ \ ... \ a^λ_n ] P^-1

เห็นมั้ย ว่าใช้เมตริกซ์เป็นเลขชี้กำลังได้ละ :D ผลลัพธ์เป็นเมตริกซ์ด้วย

จริง ๆ เราจะนิยามสัญลักษณ์ B^A เมื่อ A กับ B เป็นเมตริกซ์ อีกก็ได้นะ ก็แค่เอา B ไปแทนที่ a ในสมการข้างบนนี่ ... แต่ ... มันจะดูแปลก ๆ อ๊ะป่าว ??? ... เมตริกซ์ที่มีข้อมูลในช่องเป็นเมตริกซ์ ...

และแล้วก็จบตอนแรกของเรื่อง eigenvalue กับ eigenvector ... ยังมีอีกเยอะเลยหละ แต่ค่อย ๆ เอามาให้ดูละกัน จะได้อ่านกันไหว

Transformation Matrix: Orthonormal Transformations

2005-10-26T00:15:00.000+07:00

พูดเรื่องคำศัพท์นิดนึงก่อน มาดูว่า คำว่า "Normal" เนี่ย มันมีความหมายประมาณไหน

สมมติว่าเรามีเวกเตอร์ v อยู่ ขนาดของมัน เรียกว่า Norm เขียนแทนด้วย || v || (หรือ | v |)

Unit Vector คือ เวกเตอร์ที่มีขนาดเป็น 1 ภาษาไทยเรียกตรง ๆ ว่า เวกเตอร์หนึ่งหน่วย

Normalization คือ การหารเวกเตอร์ด้วยขนาดของมันเอง (เช่น v / || v ||) ผลลัพธ์เป็น unit vector ที่มีทิศทางเดิม

อีกที่นึงที่เจอคำว่า "Normal" บ่อย ๆ

ใน 2 มิติ Normal Vector ของเส้นตรง คือ เวกเตอร์ที่มีทิศตั้งฉากกับแนวเส้นตรงนั้น

ใน 3 มิติ Normal Vector ของระนาบ คือ เวกเตอร์ที่มีทิศตั้งฉากกับระนาบนั้น

รู้สึกอันนี้ คำว่า normal มันจะไม่ค่อยเกี่ยวกันเท่าไหร่แฮะ

ถ้า r(s) เป็นฟังก์ชันจาก เซตย่อยของจำนวนจริง ไปยังเซตย่อยของปริภูมิใด ๆ และมีอนุพันธ์อันดับสอง

T(s) = r'(s) / || r'(s) || เรียกว่า Tangent Vector
N(s) = T'(s) / || T'(s) || เรียกว่า Normal Vector
B(s) = T(s) × N(s) เรียกว่า Binormal Vector

อันนี้เกี่ยวกับอันที่แล้ว แต่ไม่ค่อยเกี่ยวกับอันแรกนะ

แล้วบอกทำไมมากมาย??? ... นั่นสิ ... ช่างมันดีกว่า เข้าเรื่องเลยละกัน ...

Orthogonal Transformation

คำว่า Orthogonal มันก็แปลว่า ตั้งฉาก อยู่แล้ว ดังนั้น Orthogonal Transformation ก็คือ การแปลงตั้งฉาก ... ???

เอาตัวอย่างมาดูเลยดีกว่า ท่าจะง่ายกว่า

สมมติว่า เดิมเรามีจุด (x, y) = xi + yj อยู่ แล้วเราอยากรู้ว่า ถ้าเปลี่ยนไปเป็นพิกัด au + bv เนี่ย จะได้ค่า a กับ b เป็นเท่าไหร่ เราจะทำยังไง? (เรารู้ค่า u กับ v ในพิกัด i-j อยู่แล้วนะ)

เอารูปเก่ามาดู (จาก ตามหาความหมายของ Determinant: Linear Combination)

วิธีที่เรารู้ ๆ กัน ก็คือใช้กฎของเครเมอร์ หาคำตอบของระบบสมการเชิงเส้น 2 ตัวแปร ก็จะได้ค่า a กับ b ออกมา ดังนี้ (เขียนไว้แล้วใน ตามหาความหมายของ Determinant: Kramer's Rule)

w = (x, y)
a = | w : v | / | u : v |
b = | u : w | / | u : v |
(ถ้าดูเครื่องหมายไม่รู้เรื่อง กลับไปดู ตามหาความหมายของ Determinant: เวกเตอร์ตั้งฉาก ก่อนนะ)

ถ้า u กับ v ตั้งฉากกันหละ? จะมีวิธีหา a กับ b ได้ง่ายกว่านี้รึเปล่า?

ลองดูใหม่นะ เรารู้ว่า

w = au + bv

เอา u ไปคูณ (ภายใน) ทั้งสองข้าง ก็จะได้

u⋅w = u⋅(au + bv)
u⋅w = au⋅u + bu⋅v

จากที่เราสมมติให้ u ตั้งฉากกับ v ดังนั้น u⋅v = 0 สมการก็จะกลายเป็น

u⋅w = au⋅u
a = u⋅w / u⋅u

เอ้อ มันดูง่ายกว่ากฎของเครเมอร์นิดนึงนะ (ตอนนี้อาจจะยังไม่เห็นชัด แต่ว่า พอมันมีหลาย ๆ มิติหนะ จะเห็นชัดมาก)

และแน่นอน ค่า b ก็หาได้ด้วยวิธีเดียวกัน แต่เปลี่ยนจากตอนที่เอา u ไปคูณ (ภายใน) ให้เป็น v แทน สูตรของ b ก็จะเป็น

b = v⋅w / v⋅v

จริง ๆ แล้ว เราขยายข้อสังเกตของเราได้นะ ... สมมติว่า เวกเตอร์แกนใหม่ของเรา มีอยู่ n ตัว คือ v₁ v₂ v₃ ... v_n แล้วเรามีจุด w = (x₁, x₂, x₃, ..., x_n) ใน n มิติอยู่ (ต้องรู้ค่าของเวกเตอร์ทุกตัว ในระบบแกนเดียวกันนะ ไม่งั้นจะหาผลคูณภายในไม่ได้) เราอยากรู้ว่า ในระบบพิกัดของแกนใหม่ ซึ่งระบุด้วย v_i เนี่ย ค่า w_i แต่ละตัวจะหาได้ยังไง? ... กำหนดให้

w = Σ_1≤i≤n w_iv_i

ถ้าหากทุก ๆ v_i ตั้งฉากกันหมด เราจะสามารถหาค่า w_i ทุกตัวได้ด้วยสมการ

w_i = v_i⋅w / v_i⋅v_i

หรือถ้าเขียนรวม ๆ ก็จะเป็น

w = Σ_1≤i≤n (v_i⋅w / v_i⋅v_i) v_i

ซึ่ง ... คราวนี้เห็นชัดเลยหละ ว่ามันง่ายกว่ากฎของเครเมอร์

Orthonormal Transformation

คราวนี้ ถ้าเกิดเรา normalize เวกเตอร์แกนใหม่ทุกตัว ให้เป็น unit vector ก่อนหละ ... มันจะมีอะไรง่ายขึ้นอีก?

คำถามนี้ ตอบง่ายแฮะ ... ก็ดูจากสูตรเมื่อกี๊

w_i = v_i⋅w / v_i⋅v_i

ถ้า v_i ทุกตัว มีขนาดเป็น 1 ... v_i⋅v_i ก็ต้องเท่ากับ 1 ... ดังนั้น

w_i = v_i⋅w
w = Σ_1≤i≤n (v_i⋅w) v_i

Fine ...

ทฤษฎีเซต: Paradox ใน Naive Set Theory

2005-10-25T20:58:00.000+07:00

ระบบเซตที่เราใช้ ๆ กันเนี่ย เราเรียกกันว่า Naive Set Theory เพราะมันมีบางอย่างพิเรนทร์อยู่ คิดว่า บางคนคงจะเคยได้ยินชื่อ Russell's Paradox กันมาบ้างแล้ว ... สำหรับใครที่ไม่คุ้น ก็ลองดูนี่ละกัน

Russell's Paradox
ถ้าให้เซต M = { A | A ∉ A } แล้ว M ∈ M หรือ M ∉ M ?

ที่มาของความวุ่นวายนี้ อาจจะเกิดขึ้นเพราะ เซตไม่มีนิยาม ก็ได้

ครั้งนี้ไม่ได้จะเอามาให้ดูแค่ Russell's Paradox หรอกนะ แต่จะบอกว่า มี paradox อีกหลายอัน ที่เกิดจากวลีว่า "เซตของ XXX ทั้งหมด"

ทฤษฎีบทที่สำคัญของ Cantor อันนึง กล่าวไว้ว่า

Cantor's Theorem
สำหรับเซต A ใด ๆ | A | < | 2^A|

เผื่อลืม: 2^A คือ power set ของ A นะ

(นิยามคือ 2^A = { x | x ⊆ A })

วิธีพิสูจน์ ก็ดูได้ที่นี่นะ (มันต้องอาศัยนิยามของ การเปรียบเทียบ cardinal number ด้วย แต่ถือว่า เข้าใจด้วย sense ละกันนะ)

คราวนี้ มาดู paradox อีกอันนึงบ้าง

Set of All Sets (Cantor's Paradox)

ให้ A เป็น เซตของเซตทั้งหมด
จากนิยามของ A และ 2^A ⇒ 2^A ⊆ A ⇒ | A | ≥ | 2^A |
... ขัดแย้งกับ Cantor's Theorem

อีกอัน...

Set of All Cardinal Numbers

ให้ C เป็น เซตของ cardinal number ทั้งหมด
สำหรับแต่ละ i ∈ C ให้ A_i เป็นเซตใด ๆ ที่ | A_i | = i (เลือกมาอันนึง)

ให้ S = ∪_i∈C A_i เราจะรู้ทันทีว่า A_i ⊆ S สำหรับทุก i ∈ C

ที่ i = | 2^S |
จากนิยามของ A_i จะรู้ว่า | A_i | = i = | 2^S |

แต่เนื่องจาก A_i ⊆ S เราจะได้ว่า | A_i | ≤ | S |

ข้อสรุปก็คือ | 2^S | ≤ | S | ... ขัดแย้งกับ Cantor's Theorem

แล้วก็ อีกอันนึง

Set of All Sets Equivalent to a Set

ให้ A เป็นเซตใด ๆ
และ B เป็น เซตของเซตทั้งหมดที่มี cardinal number เท่ากับ | A |

สำหรับทุก i ใด ๆ เราจะรู้ว่า | A | = | A × { i } |
ซึ่งทำให้ A × { i } ∈ B (จากนิยามของ B)
หรือก็คือ { A × { i } }_i∈C ⊆ B สำหรับเซต C ใด ๆ
นอกจากนี้ เรายังรู้แน่ ๆ ว่า | { A × { i } }_i∈C | = | C | ด้วย

พอเราให้ C = 2^B สิ่งที่เกิดขึ้นก็คือ

{ A × { i } }_i∈C ⊆ B ⇒ | { A × { i } }_i∈C | ≤ | B |

| { A × { i } }_i∈C | = | C | = | 2^B |

ก็เลยสรุปได้ว่า | 2^B | ≤ | B | ... ขัดแย้งกับ Cantor's Theorem

แล้ว paradox พวกนี้จะแก้ยังไงหละ? ... ไว้มาต่อกันคราวหน้านะ

อัดมาให้ฟัง - Chopin: Nocturne in C Minor Op. 48 No. 1

2005-10-24T19:39:00.000+07:00

ตามชื่อเลยละกัน

Chopin: Nocturne in C Minor Op. 48 No. 1

อัดมาให้ฟัง - Chopin: Polonaise in Ab Major Op. 53

2005-10-23T19:27:00.000+07:00

จริง ๆ วันนี้วันที่ 28 น่ะนะ (ขอโกงวันที่หน่อย) เป็นวันแข่งเปียโน แล้วก็...

ตกรอบแรก T_T

จริง ๆ รู้ตัวตั้งแต่ยังอยู่บนเวทีเลย ตอนที่เล่นไปแล้ว 2 เพลง เหลืออีก 2 เพลงอะ รู้แล้วว่าจะเล่นต่อไม่ได้ ... มือมันเย็นเฉียบ แข็งโด๊ก ไม่ขยับเลย T_T

แต่ช่างเถอะ อันนี้ เอามาให้ฟังกันเล่น ๆ นะ เป็นเพลงนึงที่เล่นวันนี้ (วันนี้เล่นไป 4 เพลง เพลงนี้เป็นเพลงสุดท้ายที่เล่น)

ถึงที่อัดมาให้ฟังเนี่ย จะยังไม่ค่อยดี แต่ดีกว่าที่ไปเล่นบนเวทีหลายขุมเลยหละ T_T สถานการณ์การแสดงจริงเนี่ย มันทำให้ฝีมือลดลงได้ เกิน 50% เลยหละ

Chopin: Polonaise in A_b Major Op. 53

อัดมาให้ฟัง - Chopin: Etude Op. 10 No. 10 (Eb Major)

2005-10-22T18:42:00.000+07:00

กลัว blog ว่างไป ก็เลยเอาเพลงที่เล่นอัดไว้ตอนซ้อม มาให้ฟังกัน

ต้องขอบอกไว้ก่อนนะ ว่า

ยังเล่นไม่ดีเลย
ใช้เครื่อง notebook อัดเสียง

ดังนั้น ทั้งคุณภาพเสียง และคุณภาพการเล่น จะอยู่ในเกณฑ์ที่ ค่อนข้างแย่ :P

แล้วดันเอามาให้ฟังอีก ??!!

เอาหนะ ... กลัว blog มันว่างไง :P

Chopin: Etude Op. 10 No. 10 (E^b Major)

เสียงมันเบาด้วยอะ เปิดลำโพงดัง ๆ นะ เวลาฟัง

เอามาให้ฟัง - Scherzo in D Major

2005-10-21T18:35:00.000+07:00

เพลงนี้เป็นเพลงที่เคยแต่งไว้ตอนอยู่ ม.4 หนะ (ก็ 7 ปีได้แล้วมั้ง) ไปขุดสมุดเขียนโน้ตเพลงเก่า ๆ แล้วเจอ ก็เลยเอามาให้ดูให้ฟังกัน

(รูปแบบเพลง Scherzo มาจาก Minuet ซึ่ง มีจังหวะเป็น 3/4 และมีท่อน Trio อยู่ตรงกลาง)

ฟัง Scherzo in D Major (.mid)
ดูโน้ต Scherzo in D Major (.pdf)

ไว้มีเวลา จะเอาเพลงอื่น ๆ ที่เคยแต่งไว้ (และที่แต่งใหม่) มาลงให้ดูให้ฟังกันอีกนะ

เอามาให้ฟัง - Short Piece in C Minor

2005-10-20T18:21:00.000+07:00

เพลงนี้ เป็นเพลงสั้น ๆ (เด็ก ๆ หน่อย) มีความยาว 20 ห้องเอง

มีโน้ตให้ดูด้วย เอาไปเป็นแบบฝึกหัดเปียโน ระดับพื้นฐานได้นะ :D (ไม่หวง)

ฟัง Short Piece in C Minor (.mid)
ดูโน้ต Short Piece in C Minor (.pdf)

อ้อ แล้วก็ อีกอย่าง ... ไม่รู้จะตั้งชื่อว่าไรดีอะ ... ขอความเห็นหน่อย

Synonym ของคำว่า "โกรธ"

2005-10-19T23:28:00.000+07:00

adjective ที่แปลว่า โกรธ โมโห ก็มีดังนี้

angered (anger [v] = โกรธ | ทำให้โกรธ)
angry (anger [n] = ความโมโห)
en'raged (en'rage [v] = ทำให้โมโห)
e'xasperated (e'xasperate [v] = รบกวน, ยั่วโมโห | ทำให้เลวร้าย) = หมดความอดทน
furious (fury [n])
in'furiated (in'furiate [v], furious)
irate/ireful (ire [n] = ความโกรธ ที่อาจจะนำไปสู่ ความมุ่งร้าย)
livid* = โกรธจัด ๆ | ผิวเปลี่ยนสี (เช่น ซีดเพราะป่วย หรือสีเข้มเพราะช้ำ) | ท่าทางน่ากลัว
maddened (mad [adj], madden [v])
pro'voked (pro'voke [v] = ยั่วโมโห | กระตุ้นให้เกิด (เหตุการณ์) | เรียก)
raging (rage [n, v])
tem'pestuous (tempest [n] = พายุ | ความปั่นป่วน) - คำนี้มักใช้กับปรากฏการณ์ธรรมชาติ แต่ก็ใช้กับคนได้เหมือนกัน
wild

ต่อด้วย noun ที่แปลว่า ความโกรธ ความโมโห

anger → anger [v], angry
angriness (angry)
choler = ความโกรธ | ความขี้รำคาญ
enragement (enrage)
fury → furious
infuri'ation (infuriate)
ire → irate, ireful
li'vidity (livid)
madness (mad)
rage → enrage

เค้าจะมีคำพิเศษนิดนึง สำหรับความโกรธที่สมเหตุสมผล (คือ เป็นเพราะ โดนทำอะไรที่ควรจะโกรธหนะ)

'incensed [adj] (incense [v] = ทำให้โมโห | ส่งกลิ่นหอมฟุ้งกระจาย)
in'dignant [adj] → indig'nation [n]
'outraged [adj] (outrage [v])
umbrage [n] → um'brageous [adj]

ความโกรธ + เกลียด (แต่เน้นที่โกรธมากกว่า) ก็จะเป็น

dander

hackles - ต้องเติม s นะ ถ้าไม่เติม มันจะเป็นคนละคำ
huffiness (huffy [adj])
i'rascibility (i'rascible [adj])
spleen - อีกความหมายนึงคือ ม้าม นะ

ความโกรธที่เกิดจากความรำคาญ ก็จะมีคำพวกนี้ (ปกติ คำพวกนี้จะมีความหมายอื่นอยู่ด้วยนะ)

an'noyance (an'noy [v] = สร้างความรำคาญ, รบกวน)
chafe (chafe [v] = annoy | ขัดถูผิวหนัง | เสียดทาน | เอามือมาถูกันให้อุ่น)
irri'tation ('irritate [v] = รบกวน | กระตุ้น)
ve'xation (vex [v] = annoy | ป่วน | ทำให้งง)

adjective ที่มีความหมายว่า โกรธง่าย ขี้โมโห จะเป็นพวกนี้ (ความจุกจิกจู้จี้ ก็รวมอยู่ด้วย)

bristly (bristle [n, v]) - คำนี้มีอีกความหมาย คือ "ปกคลุมด้วยหนาม"
choleric (choler [n] = ความโกรธ, ความรำคาญ | อารมณ์ (ที่) เสีย)
cranky* (crank [n] = คนขี้โมโห, อารมณ์เปลี่ยนเร็ว) = ไม่เสถียร (ใช้กับอะไรก็ได้) | โมโหง่าย
'hot'headed (hot, head)
hot-'tempered (temper [n] = อารมณ์)
huffy → huffiness [n]
fractious* = ขี้รำคาญ, เจ้าปัญหา
i'rascible* (ire [n], irate [adj])
irritable (irritate)
nettlesome (nettle [v]) - จะแปลว่า น่ารำคาญก็ได้นะ (เคยเอามาให้ดูแล้วทีนึง)
peckish - มีอีกความหมายนึง คือ หิว
peevish* (peeve [v] = ทำให้รำคาญ | ทำให้เกลียด)
pettish (pet [n] = การแสดงออกถึงความโกรธ)
petulant* → petulance [n]
prickly (prickle [n, v]) = bristly
'quick-'tempered
short-'tempered
sple'netic (spleen [n])
techy/tetchy
testy
waspish
wrathful (wrath)
wroth
wrothful (wroth)

สุดท้ายละ คำนามต่อไปนี้ หมายถึง การแสดงความโกรธออกมา

con'niption
fit
pet
scene
tantrum

เยอะเหมือนกันนะเนี่ย -_-' ...

Synonym ของคำว่า "ความเกลียดชัง" (Noun)

2005-10-18T02:20:00.000+07:00

คำว่า "HATE" เนี่ย มันสามารถเป็นได้ทั้ง verb และ noun อยู่แล้ว แต่ส่วนใหญ่เราจะเห็นอีกตัวนึงมากกว่า คือ "HATRED"

คำที่มีความหมายเหมือน ๆ กันกับ hate และ hatred ก็มีประมาณนี้ (noun ทุกตัวนะ)

ab'horrence (ab'hor)
abomi'nation (a'bominate) - คำนี้มีอีกความหมาย คือ คนที่น่ารังเกียจ
an'tipathy (anti-) → antipa'thetic [adj] = ขัดแย้งอย่างรุนแรง
a'version (a'vert [v] = หลีกเลี่ยง, หลบเลี่ยง)
detes'tation (de'test)
dis'gust (dis'gust [v])
dis'like (dis'like [v])
dis'taste (dis-, taste [n, v])
exe'cration (execrate)
hate
hatred
loathing (loath)
odium → odius [adj]
re'pugnance (re'pugn [v], re'pugnant [adj]) = aversion ขั้นรุนแรง
re'pulsion (re'pel [v], re'pulse [v]) = repugnance
re'vulsion (ไม่ได้มาจาก revel [v] นะ) = repugnance
scunner

คาดว่า คงคุ้น ๆ หน้าตาคำพวกนี้อยู่แล้วจากตอนก่อน ๆ (Synonym ของคำว่า "เกลียด" (Verb) กับ Synonym ของคำว่า "น่าเกลียด" และ "น่ารังเกียจ" (Adjective))

แล้วก็ คำที่มีความหมายว่าเกลียดอะไรซักอย่างเป็นพิเศษ มีประมาณนี้ (คำพวกนี้ รวมความมุ่งร้ายอยู่ด้วยนะ)

mis'anthropy* (mis-, -anthropy) - เกลียดคน
miso'cainea (mis-) - เกลียดแนวคิดใหม่
mi'sogamy (mis-, -gamy) - เกลียดการแต่งงาน
mi'sogyny/mi'sogynism (mis-, -gyny) - เกลียดผู้หญิง
mi'sology (mis-, -logy) - เกลียดการใช้เหตุผล
miso'neism (mis-) - เกลียดการเปลี่ยนแปลง
misopedia (mis-) - เกลียดเด็ก
murderousness (murderous [adj], murder [n, v]) - เกลียดจนอยากฆ่า

เกลียดแบบดูถูก เหยียดหยาม ก็มี... (คำพวกนี้ อาจจะแปลว่า การดูถูก เฉย ๆ ก็ได้นะ)

con'tempt* (con'temn [v] = ดูถูก เหยียดหยาม)
de'spisal (de'spise [v] = contemn)
de'spite (despise) → de'spiteful [adj]
dis'dain* (dis'dain [v] = contemn | ปฏิเสธด้วยความดูถูก)
scorn* (scorn [v] = disdain) → scornful [adj]

ส่วนความเกลียดชัง ที่เน้น มุ่งร้าย หนักหน่อย ก็มีดังนี้

bitterness (bitter [adj])
gall (gall [v] = ทำให้รำคาญ, ทำให้โมโห | ขัดถูจนช้ำ)
rancor/rancour → rancorous [adj] = re'sentful
re'sentment (re'sent)

ถ้า มุ่งร้าย หนักมาก จะเป็นพวกนี้

an'tagonism → an'tagonize [v] = พยายามขัดแย้ง | ยั่วโมโห
enmity (enemy)
grievance (grieve) - คำนี้ มีความแค้นปนอยู่ด้วย
grudge (grudge [v]) = grievance
hos'tility (hostile [adj])
ill will (ill [adj], will [n])
score = grievance

ไว้จะเอาพวกคำที่แปลว่า โกรธ กับ มุ่งร้าย มาให้อีกทีละกัน มันมีอีกเพียบ ... (มันก็เกี่ยวกับความเกลียดชังด้วยแหละ)

Duality: ความเจ๋งของ Abstraction

2005-10-17T03:38:00.000+07:00

จริง ๆ เคยแสดงเรื่อง abstraction ให้ดูไปแล้วในเรื่อง แต่คราวนี้อยากจะเอามาพูดถึง เน้นย้ำอีกนิดนึง

ลองดูคุณสมบัติสำหรับตรรกศาสตร์เชิงประพจน์ (Propositional Logic) ข้างล่างนี่ก่อน กฎต่อไปนี้ ใช้กับกรณีที่มีแต่เครื่องหมาย ∧ ∨ กับ ¬ นะ (p q r หมายถึง ประพจน์ใด ๆ หนะ แล้วก็ T หมายถึงเป็นจริง และ F หมายถึงเป็นเท็จ นะ)

p ∧ F ≡ F
p ∨ T ≡ T
p ∧ ¬p = F
p ∨ ¬p = T
¬(p ∧ q) ≡ ¬p ∨ ¬q
¬(p ∨ q) ≡ ¬p ∧ ¬q
p ∧ (q ∨ r) ≡ (p ∧ q) ∨ (p ∧ r)
p ∨ (q ∧ r) ≡ (p ∨ q) ∧ (p ∨ r)

กฎทั้งหกข้อนี้ เป็นจริงสำหรับพีชคณิต ของตรรกศาสตร์เชิงประพจน์ (แน่นอนสิ) ... แต่เราสามารถทำอะไรได้มากกว่านี้นิดนึงนะ

สมมติว่า เราเปลี่ยนหน้าตาเครื่องหมาย แบบนี้

∧ กลายเป็น ∩
∨ กลายเป็น ∪
T กลายเป็น U
F กลายเป็น ∅
(≡ กลายเป็น =)

เราก็จะได้ กฎสำหรับพีชคณิตของเซต ... ถ้าไปพิสูจน์ดู ก็จะรู้ว่ามันถูก ... แต่อันนี้ ยังไม่เจ๋งหรอก ลองเปลี่ยนอีกแบบดีกว่า

∧ กลายเป็น ∨
∨ กลายเป็น ∧
T กลายเป็น F
F กลายเป็น T

คราวนี้ กฎข้อที่ 1 ของเดิม จะกลายเป็นกฎข้อที่ 2 (ลองกลับขึ้นไปดูสิ) แล้วกฎข้อที่ 2 มันก็กลายเป็นกฎข้อที่ 1 ... !?

อ๊ะ! ... คู่อื่น ๆ (คู่ 3 กับ 4 คู่ 5 กับ 6 แล้วก็คู่ 7 กับ 8) ก็สลับกันเหมือนกัน ... สรุปคือ เราได้กฎเดิม!!! แน่นอนว่า มันก็ต้องถูกสิ เพราะกฎเดิมมันถูก

แล้วมันมีอะไรดีหละ? ... ลองดูอันนี้ละกัน

(p ∨ q) ∧ ¬p ≡ ¬p ∧ q

สมมติไปเลยละกัน ว่าเราพิสูจน์แล้วว่าเป็นจริง (จากกฎทั้ง 8 ข้อข้างบนน่ะแหละ) มันแปลว่า เราสามารถใช้กฎทั้ง 8 ข้อนั้น แปลงรูปฝั่งซ้าย ให้กลายเป็นฝั่งขวาได้

แล้ว ... มันจะเกิดอะไรขึ้น ถ้าเราเปลี่ยนหน้าตาเครื่องหมายแบบที่บอกไว้ ???

(p ∧ q) ∨ ¬p ≡ ¬p ∨ q

อันนี้ก็ต้องถูกต้องด้วยน่ะสิ!!! ... ทำไมน่ะเหรอ?

ก็เพราะว่า ... เราสามารถเลือกใช้กฎ ตามขั้นตอนการพิสูจน์ในแบบแรก (ที่เราสมมติว่า พิสูจน์ได้ไปแล้ว) ได้ในการพิสูจน์ประโยคแบบหลัง (คือ ที่สลับเครื่องหมายแล้วหนะ) น่ะสิ แค่เปลี่ยนจาก ถ้าเดิมใช้ข้อที่ 1 ก็ไปใช้ข้อที่ 2 แทน สลับกันแบบเนี้ย

นี่แหละ ที่เราเรียกว่า Duality ใน Boolean Algebra (มันก็คือ พีชคณิตของตรรกศาสตร์เชิงประพจน์แหละ)

ห้อยท้าย: ถ้าไปนั่งคิดดี ๆ จะเห็นว่า ถ้าเราเขียนวรรค จากรูปแบบปกติประพจน์แยก (Disjunctive Normal Form) โดยให้ แต่ละวรรคมีหน้าตาเป็น A ∧ B ∧ C ∧ ... ∧ Z และเชื่อมกันด้วย ∨ การรวม (Resolution) ก็ยังสามารถทำได้เหมือนกันนะ แต่เค้าไม่นิยมกัน (เท่านั้นเอง)

ตรรกศาสตร์: วรรคฮอร์น และ ภาษา PROLOG

2005-10-16T02:39:00.000+07:00

เราจะเรียกวรรควรรคนึงว่าเป็น วรรคฮอร์น (Horn Clause) ก็ต่อเมื่อ มีเพียง predicate เดียวในวรรคนั้น ที่ไม่มีเครื่องหมายนิเสธกำกับ เช่น

¬P(x) ∨ Q(y) ∨ ¬R(z) เป็นวรรคฮอร์น

P(x) ∨ ¬Q(y) ∨ R(z) ไม่เป็นวรรคฮอร์น

ลองสังเกตนิดนึง จะเข้าใจว่า วรรคฮอร์นพิเศษยังไง ...

¬A ∨ ¬B ∨ ¬C ∨ Z
≡ (A ∧ B ∧ C) → Z

ความหมายมันก็คือ การพิสูจน์ว่า Z เป็นจริง สามารถทำได้โดยการ พิสูจน์ว่า A B C เป็นจริงพร้อมกัน

สมมติว่าเรามีวรรคฮอร์นเพิ่มอีกวรรค กลายเป็นสองวรรค ดังนี้

¬A ∨ ¬B ∨ ¬C ∨ Z
¬ D ∨ ¬ E ∨ ¬ F ∨ Z

ถ้าเราต้องการจะพิสูจน์ว่า Z เป็นจริง จะมีทางเลือกให้ 2 ทาง คือ

พิสูจน์ว่า A B C เป็นจริงพร้อมกัน
พิสูจน์ว่า D E F เป็นจริงพร้อมกัน

ถ้าทำได้ซักทาง ก็แปลว่า Z เป็นจริง แต่ถ้าทำไม่ได้ ก็แปลว่า Z "ไม่จำเป็นต้องจริง" (ไม่ได้แปลว่า ไม่จริง นะ)

วรรคเป้าหมาย (Goal Clause) คือ วรรคที่ predicate ทุกตัว มีเครื่องหมายนิเสธกำกับ เช่น

¬P(x) ∨ ¬Q(y) ∨ ¬R(z)

สมมติว่า เรามีระบบของภาษาอันดับหนึ่ง ซึ่งเมื่อแปลงเป็นรูปแบบวรรคแล้ว ทุกวรรคเป็นวรรคฮอร์น แล้วเราต้องการจะพิสูจน์ว่า วรรคเป้าหมายซักอันนึง เป็นจริงรึเปล่า ... เราต้องพยายามหา วรรคที่รวมกับวรรคเป้าหมายได้

ดูตัวอย่างดีกว่า ถ้าอ่านแล้วงง ... ถ้าเราต้องการจะนิยามประพจน์ Even(x) กับ Odd(x) เมื่อ x เป็นจำนวนเต็มไม่ติดลบ ดังนี้

Even(x) ≡ x เป็นเลขคู่
Odd(x) ≡ x เป็นเลขคี่

เราจะรู้ว่า "กฎ" ต่อไปนี้ เป็นจริง

Even(0)
Even(x) → Odd(NextOf(x))
Odd(x) → Even(NextOf(x))

เราก็ แปลงให้เป็นรูปแบบวรรค ได้แบบนี้

Even(0)
¬Even(x) ∨ Odd(NextOf(x))
¬Odd(x) ∨ Even(NextOf(x))

วรรคทั้งสามวรรคนี้ เป็นวรรคฮอร์นหมดเลย

สมมติ เราอยากรู้ว่า Odd(NextOf(NextOf(NextOf(0)))) เป็นจริงรึเปล่า (คือ "3 เป็นเลขคี่รึเปล่า" อะนะ) เราก็ต้องตั้งวรรคเป้าหมาย เป็นนิเสธของสิ่งที่ต้องการพิสูจน์ ว่า

Goal: ¬Odd(NextOf(NextOf(NextOf(0))))

เราก็ต้อง พยายามหา predicate ที่รวมกับกฎได้ ... จะเห็นว่า วรรคที่ 2 สามารถรวมกับ วรรคเป้าหมาย ได้ด้วยตัวรวมทั่วไปที่สุด { NextOf(NextOf(0)) / x } ผลลัพธ์ก็จะเป็นวรรคใหม่ อันนี้...

Goal: ¬Even(NextOf(NextOf(0)))

มันก็เป็นวรรคเป้าหมายเหมือนกัน ตามนิยาม ... จะคิดซะว่า เป็นเป้าหมายใหม่ ก็ใช่แหละ ... คราวนี้ วรรคเป้าหมายนี้ ก็สามารถรวมได้กับ วรรคที่ 3 เท่านั้น ตัวรวมทั่วไปที่สุดคือ { Next(0) / x } ผลลัพธ์เป็น วรรคเป้าหมายใหม่อีกวรรค คือ

Goal: ¬Odd(NextOf(0))

หาวรรคมารวมอีกที จะเห็นว่า วรรคที่ 2 เป็นวรรคเดียวที่ใช้ได้ โดยมีตัวรวมทั่วไปที่สุดเป็น { 0 / x } ผลลัพธ์คือ

Goal: ¬Even(0)

คราวนี้ เห็นชัดเลยว่า วรรคที่ 1 จะรวมกับวรรคนี้ได้ และให้ผลลัพธ์เป็นวรรคว่าง ... สรุปว่า 3 เป็นเลขคี่นะ :D

เห็นแล้วใช่มั้ยหละ ว่าวรรคฮอร์น กับวรรคเป้าหมาย มีคุณสมบัติพิเศษคือ

"ผลลัพธ์ของการรวมวรรคฮอร์นกับวรรคเป้าหมาย (เก่า) คือวรรคเป้าหมาย (ใหม่)"

สาเหตุที่วรรคฮอร์น ก่อกำเนิดขึ้น และได้รับความนิยม เป็นเพราะว่า

ในวรรคเป้าหมาย ทุก predicate ติดนิเสธ
ในวรรคฮอร์น มี predicate เดียวที่ไม่ติดนิเสธ
ผลลัพธ์ของการรวม เป็นวรรคเป้าหมาย (ซึ่งทุก predicate ติดนิเสธ)

ดังนั้น การค้นหา predicate ที่สามารถรวมกันได้ จะรวดเร็วกว่ากรณีทั่วไป (ที่มีกฎที่ไม่อยู่ในรูปแบบ วรรคฮอร์น)

นอกจากนั้น การเพิ่มข้อกำหนดที่ว่า กฎทุกข้อ ต้องเป็นวรรคฮอร์น ลงไป ทำให้การสร้างโปรแกรมสำหรับช่วยพิสูจน์ ง่ายขึ้นมาก ... มันก็เร็วขึ้นด้วยแหละ อย่างที่บอกไปแล้ว

ภาษา PROLOG

โปรแกรมคอมพิวเตอร์ที่พูดถึงเมื่อกี๊ ก็คือ ภาษา PROLOG น่ะแหละ หน้าตามันจะประมาณนี้

Z :- A, B, C.
Z :- D, E, F.

ความหมายก็คือ ถ้าฝั่งขวาทุกตัวเป็นจริง ฝั่งซ้ายจะเป็นจริง แต่ถ้าจะเขียนว่า ฝั่งซ้ายเป็นจริงเสมอ ก็เขียนได้ โดยไม่ต้องมีเครื่องหมาย ":-" (แต่อย่าลืม "." ลงท้ายนะ) เช่น

Even(0).

ส่วน วรรคเป้าหมาย เค้ามักจะเขียนกันแบบนี้

:- P, Q, R.

ใครสนใจ ลองไปหาตัวแปลภาษา PROLOG เล่นได้ ที่นี่: SWI-Prolog

อ้อ ... สำหรับใครที่เอา SWI-Prolog ไปเล่น ... ชื่อตัวแปรที่ใช้ จะต้องขึ้นต้นด้วยตัวใหญ่นะ นอกนั้น ให้ขึ้นด้วยตัวเล็ก (ทั้งชื่อ predicate ชื่อฟังก์ชัน แล้วก็ชื่อค่าคงที่ด้วย) ... เอาตัวอย่างให้ดูนิดนึง

even(0).
odd(nextof(X)) :- even(X).
even(nextof(X)) :- odd(X).

แล้วก็ ... เค้ามีฟังก์ชันพื้นฐานให้ใช้ เยอะเหมือนกัน จริง ๆ ไม่ต้องเขียน nextof อะไรแบบนี้หรอก ใช้คำสั่ง add เลยก็ได้

Center of Mass & Centroid - Polyhedron

2005-10-15T16:18:00.000+07:00

คราวที่แล้ว (เรื่อง Center of Mass & Centroid - Polygon) เราได้แนวคิดการหา centroid ของ polygon แล้ว การขยายเป็น 3 มิติ ก็ทำเหมือน ๆ กันแหละ

การหา centroid ของ polyhedron เราจะใช้แนวคิดจากเรื่อง ต่อจากสูตรเมื่อสมัยเด็ก - ปริมาตรของ Tetrahedron ผนวกกับความจริงที่ว่า

"Centroid ของ Tetrahedron คือ Centroid ของจุดยอดทั้งสี่ของมัน"

ดังนั้น วิธีหา centroid ของ polyhedron ก็คล้าย ๆ กับการหาปริมาตรมันน่ะแหละ เพียงแต่ต้องเอา centroid ของ tetrahedron แต่ละชิ้นเข้าไปคูณด้วย ... สูตรสำเร็จหน้าตาหยั่งงี้

สมมติว่า tetrahedron มีจุดยอดคือ P Q R S

ให้ a = | P : Q : R |
b = | Q : R : S |
c = | R : S : P |
d = | S : P : Q |
C = (a(P + Q + R) + b(Q + R + S) +
c(R + S + P) + d(S + P + Q)) /4(a + b + c + d)

C ก็คือ centroid ของ tetrahedron หนะนะ

คราวนี้ ถ้าเรามี polyhedron ... เราก็สามารถแบ่งมันเป็น tetrahedron หลาย ๆ อันได้ แล้วก็หา centroid ของ tetrahedron เหล่านั้น เอามารวมกันแบบถ่วงน้ำหนักด้วยปริมาตรของมัน แต่การคิดมันจะไม่ง่ายเหมือนกับกรณีของ polygon แล้ว ต้องใช้ความระมัดระวังใน การรวมเข้าหักออก เหมือนกับในการหาปริมาตรของ tetrahedron

แล้วก็ ถึงจะขยายไปเป็นกี่มิติก็ตาม เราก็ใช้หลักการที่ว่า

"Centroid ของ รูปพื้นฐานใน n มิติ ก็คือ Centroid ของจุดยอดทั้งหมด n + 1 จุดของมัน"

แล้วคิดในลักษณะเดียวกัน

Transformation: Domain, Range and Inverse

2005-10-14T23:32:00.000+07:00

ย้ำคำเดิมอีกที ... การแปลง (Transformation) มันก็คือฟังก์ชัน (Function) น่ะแหละ ดังนั้น มันต้องมีโดเมนกับเรนจ์ และอาจจะมีอินเวอร์ส

สมมติให้ T เป็นการแปลงที่มีโดเมนเป็น D และเรนจ์เป็น R

เงื่อนไขการมีอินเวอร์สของการแปลง ก็คือ (ทวนของเก่านิดนึงอะนะ)

x, y ∈ D → [T(x) = T(y) ↔ x = y]
y ∈ R → จะมี x ∈ D ที่ทำให้ T(x) = y

ข้อแรก ก็คือที่เราเรียกกันว่า คุณสมบัติหนึ่งต่อหนึ่ง (One-to-One) และข้อสองก็คือที่เรียกว่า คุณสมบัติทั่วถึง (Onto)

เรามักจะเขียนว่า T:A → B เพื่อบอกว่า A เป็นโดเมนของ T และ เรนจ์ของ T เป็นสับเซตของ B นะ

Bijection

สั้น ๆ ก็คือ "ถ้า T เป็น bijection จาก A ไป B แปลว่า T เป็นฟังก์ชันที่มีอินเวอร์ส"

Finite, Infinitely Countable, Uncountable

เซต A จะเป็นเซตจำกัด (Finite) ก็ต่อเมื่อ มันมีจำนวนสมาชิกจำกัดไง ... (จะบอกทำไมเนี่ย - -'')
เซตจำกัดทุกเซต นับได้ (Countable)
เซต A จะเป็นเซตไม่จำกัด แต่นับได้ (Infinitely Countable หรือ Countably Infinite) ถ้าสามารถหา Bijection จาก A ไป Z (เซตของจำนวนเต็มหนะ) ได้
เซต A จะเป็นเซตนับไม่ได้ (Uncountable) ถ้ามันไม่จำกัด และนับไม่ได้

ความเป็นจริงบางประการ

ถ้า A ⊆ Z และ A เป็นเซตไม่จำกัด แล้ว A จะนับได้
Q (เซตของจำนวนตรรกยะ) นับได้
ถ้า A และ B นับได้ A ∪ B กับ A × B จะนับได้
R × A จะนับได้ก็ต่อเมื่อ A = ∅
ช่วง [a, b] (a, b) [a, b) และ (a, b] จะนับไม่ได้ก็ต่อเมื่อ a < b (คือ โดยทั่วไป มันจะนับไม่ได้หนะ)

ตัวอย่าง Bijection ที่ง่าย ๆ (x กับ y เป็นตัวแปร นอกนั้นเป็นค่าคงที่นะ)

x + a ⇒ (s, t) → (s + a, t + a)
ax ⇒ (s, t) → (as, at)
tan x ⇒ (-π/2, π/2) → (-∞, ∞)
e^x ⇒ (-∞, ∞) → (0, ∞)
x + y(y + 1)/2 ⇒ (Z⁺ ∪ {0}) × (Z⁺ ∪ {0}) → (Z⁺ ∪ {0})

ตัวอย่าง Bijection ที่พิเรนทร์นิดนึง

ก่อนจะเอาให้ดู ขอตกลงเครื่องหมายนิดนึงก่อน เพื่อให้เขียนง่ายขึ้น

[P] เมื่อ P เป็น predicate จะมีค่าเป็น 1 ถ้า P เป็นจริง และเป็น 0 ถ้า P เป็นเท็จ

เอาหละ ต่อไปนี้คือ bijection ตัวอย่างอีกตัวนึง

[x ∈ Z] + x ⇒ [0, ∞) → (0, ∞)

bijection แบบนี้ มีได้อีกหลายแบบนะ แต่ที่ต้องการจะสื่อก็คือ ... เราสามารถหา bijection ที่ถ่ายทอดช่วงเปิดไปปิด หรือปิดไปเปิด หรือครึ่งเปิดครึ่งปิด ยังไงก็ได้

Cardinal Numbers

สำหรับเซตนับได้ Cardinal Number ของมันก็คือ จำนวนสมาชิกนั่นเอง ดังนั้น วิธีเขียน cardinal number ของเซต A ก็คือ |A|

คุณสมบัติสำคัญของ cardinal number ก็คือ ถ้าสามารถหา bijection จาก A ไป B ได้ เราจะรู้ว่า |A| = |B|

สำหรับเซตอนันต์ เค้าก็มีการนิยาม cardinal number ไว้เช่นกัน ดังนี้

|Z| = ℵ₀
|R| = c

โดยที่ ℵ₀ คือ cardinal number ที่น้อยที่สุดของเซตอนันต์ (มันเลยห้อย 0 ไง) จะว่าไปก็คือ Z คือเซตอนันต์ที่ "เล็ก" ที่สุดน่ะแหละ

แล้วเค้าก็มีสมมติฐานอันนึง ชื่อว่า Continuum Hypothesis ซึ่งบอกว่า ไม่สามารถหาเซต A ที่ทำให้ ℵ₀ < |A| < c ได้ ... เน้นว่าเป็น สมมติฐาน นะ เพราะว่า มันไม่สามารถพิสูจน์ได้ (ด้วยระบบเซตแบบ Cantor)

คราวนี้ เราอาจจะสรุปบางอย่างได้สะดวกขึ้น เช่น

ถ้า a < b แล้ว | (a, b) | = | [a, b) | = | (a, b] | = | [a, b] | = c
|2^Z| = 2^ℵ₀ = c
c² = c × c > c
ถ้า |A| = ℵ₀ และ 0 < |B| ≤ ℵ₀ แล้ว |A × B| = ℵ₀
ถ้า |A| = c และ 0 < |B| ≤ ℵ₀ แล้ว |A × B| = c

แถมทิ้งท้าย เปลี่ยนเรื่องนิดนึง

ลองเอาการแปลงที่เคยพูดถึงแล้ว ในเรื่อง Discrete vs Continuous: ฟังก์ชัน เวกเตอร์ และเมตริกซ์ มาดูกันดีกว่า ว่า อันไหนมีโดเมนกับเรนจ์เป็นอะไรบ้าง (ขอละเว้นกรณีจำนวนเชิงซ้อน กับเงื่อนไขบางอย่าง ทิ้งไปก่อนนะ)

Discrete Fourier Transform
⇒D = {f | f:Z_n → R}, R = D
Fourier Series
⇒D = {f | f:[-L, L] → R}, R = {f | f:Z → R}
Fourier Transformation
⇒D = {f | f:R → R}, R = D
Generating Function
⇒D = {f | f:Z⁺ → R}, R = D
Z Transformation
⇒D = {f | f:Z⁺ → R}, R = D
Laplace Transformation
⇒D = {f | f:R⁺ → R}, R = D

หมายเหตุ: D อันนี้ กับ D ในเรื่อง Discrete vs Continuous: ฟังก์ชัน เวกเตอร์ และเมตริกซ์ มันคนละตัวกันนะ