วิธีสร้างโปรแกรมรวมตัวเลขใน Python: 10 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:07

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

สิ่งที่คุณต้องการ:

คอมพิวเตอร์ส่วนบุคคลพร้อมอินเทอร์เน็ต

ขั้นตอนที่ 1: ทำความเข้าใจเกี่ยวกับอัลกอริทึม ตอนที่ 1: ปริพันธ์ที่แน่นอนและการใช้งาน

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

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

ขั้นตอนที่ 2: ทำความเข้าใจอัลกอริทึม ตอนที่ 2: การประมาณเชิงตัวเลข

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

ขั้นตอนที่ 3: ทำความเข้าใจเกี่ยวกับอัลกอริทึม ตอนที่ 3: กฎจุดกึ่งกลาง

กฎนี้กำหนดวิธีการสร้างและใช้สี่เหลี่ยมในการประมาณ สี่เหลี่ยมแต่ละอันจากสี่เหลี่ยม "N" ต้องมีความกว้างเท่ากัน Δx แต่สี่เหลี่ยมที่ n แต่ละอันจะต้องไม่เหมือนกันทุกประการ: ปัจจัยที่แตกต่างกันคือความสูงซึ่งแตกต่างกันไปตามฟังก์ชันที่ประเมิน ณ จุดหนึ่ง กฎจุดกึ่งกลางได้ชื่อมาจากข้อเท็จจริงที่ว่าคุณกำลังประเมินความสูงของสี่เหลี่ยมแต่ละอันเป็น f(x_n) โดยที่ "x_n" คือจุดศูนย์กลางตามลำดับของแต่ละรูปสี่เหลี่ยมผืนผ้า ตามที่กำหนดไว้ทางด้านซ้ายหรือขวาของสี่เหลี่ยม การใช้จุดกึ่งกลางก็เหมือนการใช้ค่าเฉลี่ยซึ่งจะทำให้การประมาณมีความแม่นยำมากกว่าที่คุณจะใช้ทางขวาหรือทางซ้าย รูปภาพสนับสนุนสำหรับขั้นตอนนี้สรุปวิธีการกำหนดกฎจุดกึ่งกลางทางคณิตศาสตร์

ขั้นตอนที่ 4: การสร้างโปรแกรม ตอนที่ 1: ดาวน์โหลด Python Compiler/Editor

เมื่อคุณเข้าใจอัลกอริธึมที่ต้องดำเนินการแล้ว เป็นเรื่องของการให้คอมพิวเตอร์ทำการคำนวณให้คุณ ขั้นตอนแรกในการบอกคอมพิวเตอร์ว่าต้องทำอะไรคือการใช้เครื่องมือต่างๆ อัลกอริธึมนี้สามารถเข้ารหัสในภาษาใดก็ได้ เพื่อความเรียบง่าย โปรแกรมนี้จะถูกเข้ารหัสในภาษา Python ในการสั่งให้คอมพิวเตอร์ของคุณดำเนินการกับ Python คุณจะต้องมีตัวแก้ไขที่รับคำสั่งที่เขียนในภาษานั้น จากนั้นจะคอมไพล์เป็นภาษาเครื่องที่คอมพิวเตอร์ของคุณสามารถเข้าใจได้ เพื่อให้สามารถทำงานที่คุณบอกให้ทำ ในยุคนี้ บรรณาธิการและคอมไพเลอร์มักถูกรวมเข้าด้วยกัน แต่ก็ไม่เป็นเช่นนั้นเสมอไป คุณสามารถใช้ตัวแก้ไข/คอมไพเลอร์ใดก็ได้ที่คุณพอใจ แต่ฉันจะแสดงวิธีรับรายการโปรดส่วนตัวของฉันสำหรับ Python: Canopy หากคุณมีตัวแก้ไข/คอมไพเลอร์อยู่แล้ว คุณสามารถข้ามขั้นตอนเหล่านี้ได้

1. ไปที่
2. คลิกดาวน์โหลด Canopy

3. คลิกปุ่มดาวน์โหลดที่ตรงกับระบบปฏิบัติการของคุณ

   การดาวน์โหลดจะเริ่มขึ้นโดยอัตโนมัติ

4. ทำตามคำแนะนำการปลูกฝังหลังจากเริ่มไฟล์การดำเนินการ
5. เรียกใช้โปรแกรม
6. คลิก "ตัวแก้ไข" จากเมนูหลักของโปรแกรม
7. คลิก "สร้างไฟล์ใหม่" ตรงกลางหน้าจอ

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

ขั้นตอนที่ 5: การสร้างโปรแกรม ตอนที่ 2: การนำเข้าฟังก์ชัน & การกำหนดตัวแปร

คัดลอกรหัสในภาพ

สำหรับโปรแกรมใด ๆ ที่คุณอาจพบว่าตัวเองกำลังเขียนโค้ดจะมีตัวแปรอยู่ ตัวแปรคือชื่อที่กำหนดให้กับค่าที่จะดำเนินการและสามารถเปลี่ยนแปลงได้ ในภาษาการเขียนโปรแกรมส่วนใหญ่ (ถ้าไม่ใช่ทั้งหมด) คุณต้องเริ่มต้นตัวแปรก่อนที่โปรแกรมจะทำการเปลี่ยนแปลงได้ ในกรณีของโปรแกรมนี้ ฉันได้ตั้งชื่อตัวแปรว่า "N" "a" และ "b" ค่าเหล่านี้แสดงถึงจำนวนการวนซ้ำ (AKA จำนวนสี่เหลี่ยม) ขอบเขตล่าง และขอบเขตบนตามลำดับ คุณสามารถตั้งชื่อสิ่งที่คุณต้องการได้ แต่เพื่อให้ตรงกับสูตรที่ระบุใน "การทำความเข้าใจอัลกอริทึมส่วนที่ 3: กฎจุดกึ่งกลาง" วิธีที่ดีที่สุดคือให้มันเหมือนเดิม สังเกตว่าไม่ได้ตั้งค่าเป็นค่าเฉพาะ เนื่องจากเป็นอินพุตที่เมื่อรันโปรแกรม ผู้ใช้โปรแกรมสามารถกำหนดได้ว่าค่าจะเป็นเท่าใด ข้อความในเครื่องหมายคำพูดหลังจากคำสั่งอินพุตจะปรากฏขึ้นเมื่อคุณเรียกใช้โปรแกรมโดยบอกคุณว่าควรพิมพ์ค่าประเภทใด คุณจะสังเกตเห็นว่ามีการใช้ "int" และ "float" ก่อนการกำหนดอินพุต คำศัพท์เหล่านี้บอกคอมพิวเตอร์ว่าค่านี้จะเป็นตัวแปรประเภทใด "int" เป็นจำนวนเต็ม และ "float" เป็นค่าทศนิยม (เช่น ทศนิยม) ควรมีความชัดเจนว่าทำไมจึงถูกกำหนดให้เป็นเช่นนี้

ข้อความใดๆ ที่ปรากฏหลัง "#" คือความคิดเห็นที่อนุญาตให้โปรแกรมเมอร์ปฏิบัติตามโค้ดในลักษณะที่เห็นอกเห็นใจ ฉันได้แสดงความคิดเห็นบางอย่างในรหัสของฉันซึ่งคุณจะคัดลอก แต่อย่าลังเลที่จะเพิ่มความคิดเห็นที่ช่วยเหลือคุณโดยเฉพาะ โปรแกรมจะไม่อ่านอะไรที่มี "#" มาก่อนเป็นคำสั่ง

ส่วนของโค้ดที่อ่านว่า "from math import *" บอกให้โปรแกรมนำเข้าอาร์เรย์ของฟังก์ชันทางคณิตศาสตร์ที่สามารถใช้ได้โดยไม่ต้องตั้งโปรแกรมในตัวเอง ตัว "*" หมายถึง "ทั้งหมด" อ่านโค้ดส่วนนี้เป็น: จากไลบรารีคณิตศาสตร์นำเข้าฟังก์ชันทั้งหมด ซึ่งช่วยให้คุณใช้ฟังก์ชันทางคณิตศาสตร์ได้ เช่น ไซน์ โคไซน์ บันทึก เอ็กซ์พี ฯลฯ ฟังก์ชันเหล่านี้สามารถผสานรวมทางคณิตศาสตร์ภายในโค้ดได้

ขั้นตอนที่ 6: การสร้างโปรแกรม ตอนที่ 3: การสร้างฟังก์ชันสำหรับการบูรณาการ

คัดลอกรหัสในภาพด้านล่างรหัสก่อนหน้า

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

ตัวอย่างโค้ดถัดไปนี้เป็นหัวใจของโปรแกรม ในที่นี้ มีการกำหนดฟังก์ชัน Python ที่ดำเนินการอัลกอริทึมของการรวมตัวเลขโดยใช้กฎจุดกึ่งกลาง "def Integrate(N, a, b)" อ่านว่า: กำหนดฟังก์ชันที่เรียกว่า "Integrate" ที่ยอมรับตัวแปร "N, "a, " และ "b, " และส่งคืนพื้นที่ใต้เส้นโค้ง (ฟังก์ชันทางคณิตศาสตร์) ซึ่งกำหนดไว้ภายในฟังก์ชัน "Integrate" Python คุณสามารถเรียกใช้ฟังก์ชัน Python นี้ได้ทุกอย่างเมื่อคุณทำการเข้ารหัส แต่ควรเรียกฟังก์ชันนี้ว่าการผสานรวม เนื่องจากเป็นฟังก์ชันที่รวมฟังก์ชันทางคณิตศาสตร์ไว้อย่างแท้จริง

ณ จุดนี้ ควรแสดงความคิดเห็นว่า Python แยกบล็อกของโค้ดอย่างไร บล็อกของรหัสคือส่วนที่ทำงานบางอย่าง ภาษาโปรแกรมต่างๆ จะกำหนดวิธีแยกแยะ "บล็อก" เหล่านี้ สำหรับ Python บล็อกจะแยกความแตกต่างจากการเยื้อง: แต่ละส่วนการปฏิบัติงานมีการเยื้องของตัวเอง และสามารถเยื้องบล็อกภายในบล็อกอื่นๆ ที่เยื้องได้ สิ่งนี้แสดงถึงงานภายในงาน และบอกลำดับที่โค้ดต้องถูกดำเนินการ ในกรณีของฟังก์ชัน Python ที่กำหนดไว้ "Integrate" ทุกอย่างภายในฟังก์ชันนั้นจะถูกเยื้องออกหนึ่งบล็อก ดังนั้นจึงแยกแยะงานที่จะดำเนินการภายในฟังก์ชันนั้นได้ มีส่วนเยื้องภายในฟังก์ชัน Python นี้ที่ทำงานของตัวเองเช่นกัน เป็นไปดังนี้: มีการกำหนดคำสั่ง (งาน) เครื่องหมายโคลอนตามคำสั่ง และสิ่งที่คำสั่งทำจะถูกเยื้องไว้ด้านล่าง

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

ถัดไป for-loop ทำหน้าที่เป็นผลรวมที่กำหนดไว้ในสูตรในส่วน "การทำความเข้าใจอัลกอริทึม" ของบทช่วยสอนนี้ การรวมนี้ต้องใช้ตัวแปรอีกสองสามตัว ซึ่งหนึ่งในนั้นจะทำหน้าที่เป็นค่าส่งคืนสำหรับฟังก์ชัน "Integrate" Python ทั้งหมด ก่อน for-loop ฉันได้กำหนดตัวแปรเหล่านี้เป็น "value" และ "value2" งานของ for-loop คือการวนซ้ำช่วงของค่าสำหรับตัวแปรที่กำหนด ซึ่งสามารถกำหนดได้อย่างสะดวกภายในคำสั่ง for-loop ในกรณีนี้ ตัวแปรนั้นคือ "n" ช่วงที่เกิดซ้ำคือ 1 ถึง N+1 คุณควรสังเกตว่าผลรวมที่กำหนดไว้ในสูตรดังกล่าวมีช่วงตั้งแต่ 1 ถึง N เท่านั้น เรากำหนดด้วยวิธีนี้เนื่องจากภาษา Python นับแต่ละค่าที่วนซ้ำโดยเริ่มจากศูนย์ ดังนั้นเราจึงต้องเปลี่ยนช่วงของค่าให้เหมาะสมกับความต้องการของเรา พิสัย. จากนั้น for-loop อนุญาตให้รวมความสูงของสี่เหลี่ยมผืนผ้าทั้งหมดเข้าด้วยกัน และเก็บค่านั้นไว้ในตัวแปรที่ฉันเรียกว่า "ค่า" สิ่งนี้เห็นได้ในส่วนของโค้ดที่แสดงเป็น: value += f(a+((n-(1/2))*((b-a)/N)))

จากนั้นโค้ดส่วนถัดไปจะใช้ตัวแปรที่เรียกว่า "value2" ซึ่งกำหนดให้เป็นผลรวมของความสูงทั้งหมดของสี่เหลี่ยมผืนผ้าแต่ละอันคูณด้วยความกว้างมาตรฐานของสี่เหลี่ยมแต่ละอัน - นี่คือคำตอบสุดท้ายของเราที่เราต้องการ แสดงโดยโปรแกรมของเราและเป็นค่าส่งคืนของฟังก์ชัน Python "Integrate"

ขั้นตอนที่ 7: การสร้างโปรแกรมส่วนที่ 4: การแสดงคำตอบ

คัดลอกรหัสในภาพด้านล่างรหัสก่อนหน้า

ตอนนี้สามารถรับคำตอบผ่านฟังก์ชัน "Integrate" Python ได้แล้ว เราต้องการที่จะแสดงผลได้ นี่เป็นเพียงเรื่องของการวางค่าที่ผู้ใช้ป้อน ("N, " "a, " และ "b") ลงในฟังก์ชัน Python "Integrate" และพิมพ์บนหน้าจอ คำสั่งนี้แสดงอยู่ในบรรทัดที่ 21 และเป็นทั้งหมดที่คุณต้องทำเพื่อสิ้นสุดขั้นตอนนี้ รหัสในบรรทัดที่ 19 และ 20 มีไว้เพื่อ "สวยขึ้น" ผลลัพธ์ของโปรแกรมทั้งหมด "print("…………….")" แยกส่วนอินพุตของโปรแกรมออกจากส่วนผลลัพธ์ และ "print("นี่คือคำตอบของคุณ: ")" เป็นเพียงการกำหนดว่าคำตอบจะ ให้พิมพ์ต่อจากบรรทัดนั้น

ขั้นตอนที่ 8: การเรียกใช้โปรแกรมส่วนที่ 1: การเรียกใช้โปรแกรมตามที่เป็นอยู่

หากคุณไม่ได้ใช้ Canopy คุณอาจไม่จำเป็นต้องทำตามขั้นตอนนี้เลย และการรันโปรแกรมอาจต้องใช้ขั้นตอนที่แตกต่างกัน ใน Canopy ก่อนที่คุณจะสามารถเรียกใช้โปรแกรมได้ คุณจะต้องบันทึกก่อน ประเภทไฟล์สำหรับโปรแกรม Python คือไฟล์.py ซึ่งจะบันทึกโดยอัตโนมัติเช่นนี้ เลือกตำแหน่งที่คุณต้องการบันทึกไฟล์ จากนั้นคุณจะสามารถเรียกใช้โปรแกรมได้

การรันโปรแกรม:

1. กดปุ่มสีเขียวที่ดูเหมือน "ปุ่มเล่น" ที่อยู่บนแถบเครื่องมือเหนือตำแหน่งที่ชื่อไฟล์ของคุณแสดงขึ้น (ดูรูป)
2. จากนั้นโปรแกรมจะทำงานในหน้าจอด้านล่างของตัวแก้ไขซึ่งเรียกว่าสภาพแวดล้อมการวิเคราะห์ข้อมูล Canopy สมมติว่าคุณคัดลอกข้อความแจ้งขณะที่ฉันเขียน คุณจะเห็นข้อความแจ้งที่ด้านล่างของสภาพแวดล้อมการวิเคราะห์ข้อมูลของ Canopy: "ป้อนจำนวนครั้งที่คุณต้องการรวม (มากขึ้น = แม่นยำยิ่งขึ้น):." (ตามภาพ)
3. ป้อนค่าจำนวนครั้งที่คุณต้องการทำซ้ำ เช่น 10000 (จำนวนสี่เหลี่ยมที่คุณต้องการดันเข้าไปในพื้นที่ของคุณ) จากนั้นกด Enter
4. ข้อความแจ้งเพิ่มเติมจะปรากฏขึ้นพร้อมกับข้อความที่ควรเป็นการป้อนข้อมูลที่คุ้นเคยที่คุณเข้ารหัสลงในโปรแกรมในขั้นตอนที่ 5 กรอกข้อมูลให้เหมาะสมเช่นเดียวกับในข้อ 3 ด้านบน
5. ควรประเมินอินทิกรัลและผลลัพธ์ควรปรากฏขึ้น

หากคุณเข้ารหัสโปรแกรมตามที่แสดงในภาพก่อนหน้า แสดงว่าคุณเพิ่งรวม f(x) = x^2 เข้ากับขอบเขตบางส่วน อินทิกรัลของ x^2 นั้นง่ายต่อการประเมินด้วยมือ ดังนั้นคุณควรตรวจสอบและตรวจสอบให้แน่ใจว่าโปรแกรมให้คำตอบที่ใกล้เคียงมากสำหรับค่าการวิเคราะห์ที่ถูกต้องซึ่งกำหนดด้วยมือ เมื่อฉันรันโปรแกรมด้วยค่า N = 10000, a = 0 และ b = 10 ฉันได้รับคำตอบ 333.33333249999964 คำตอบเชิงวิเคราะห์ที่ถูกต้องคือ 333.333 สิ่งนี้แม่นยำและรวดเร็วอย่างเหลือเชื่อ คุณได้บีบสี่เหลี่ยม 10, 000 อันระหว่าง 0 ถึง 10 บนแกน x แล้วใช้พวกมันเพื่อประมาณพื้นที่ใต้เส้นโค้ง x^2!

ขั้นตอนที่ 9: การเรียกใช้โปรแกรม ตอนที่ 2: การผสานรวมฟังก์ชันทางคณิตศาสตร์อื่นๆ

ในขั้นตอนก่อนหน้านี้ หากคุณได้ปฏิบัติตามอย่างเคร่งครัด คุณได้รวม f(x) = x^2 นั่นไม่ใช่ฟังก์ชันทางคณิตศาสตร์เพียงอย่างเดียวที่โปรแกรมนี้สามารถผสานรวมได้ เรียกคืนจากขั้นตอนที่ 5 ที่คุณนำเข้าอาร์เรย์ไลบรารีคณิตศาสตร์ของฟังก์ชัน Python ลงในโปรแกรม วิธีนี้ช่วยให้คุณใช้ฟังก์ชันทางคณิตศาสตร์ที่ซับซ้อนยิ่งขึ้นซึ่งสามารถรวมเข้าด้วยกันได้ มาลองดูกัน แน่นอน คุณสามารถใช้ฟังก์ชันใดก็ได้ที่คุณต้องการ แต่ฉันจะแสดงความถูกต้องของโค้ดนี้เพิ่มเติมโดยการรวมฟังก์ชันทางคณิตศาสตร์เฉพาะที่ให้ค่าที่รู้จักกันดีเมื่อรวมเข้ากับช่วงที่กำหนด ฟังก์ชันนั้นคือ f(x) = บาป[x] ฟังก์ชันทางคณิตศาสตร์นี้จะแสดงในรูปภาพประกอบภาพแรก โดยพล็อตจาก 0 ถึง 2π และพื้นที่ที่สนใจจะถูกแรเงาเป็นสีเทอร์ควอยซ์ มีพื้นที่บวกเท่ากันเนื่องจากมีพื้นที่ลบในช่วงเวลานี้ ดังนั้นหากคุณบวกพื้นที่ทั้งหมดเข้าด้วยกัน คุณจะได้ศูนย์ ลองดูว่าสิ่งนี้เกิดขึ้นจริงหรือไม่:

การใส่ฟังก์ชันทางคณิตศาสตร์ f(x) = Sin[x] ลงในโปรแกรม:

1. ก่อนรันโปรแกรมอีกครั้ง ภายใต้ความคิดเห็น "#type your function after return " type: sin(x) where x**2 is located. (ตามภาพ).
2. เรียกใช้โปรแกรมโดยกดปุ่มเล่นสีเขียวอีกครั้ง
3. พิมพ์ 10000 สำหรับค่า N (จำนวนครั้งที่คุณต้องการรวม)
4. ใส่ "0" สำหรับขอบเขตล่าง
5. ใส่ 6.2832 ในขอบเขตบน (ประมาณ2π)
6. ดูว่าคุณได้รับค่าอะไร

เมื่อฉันทำสิ่งนี้ ฉันได้รับค่า 1.079e-10: นี่เท่ากับ.0000000001079 ซึ่งใกล้เคียงกับศูนย์จริงๆ ดังนั้นจึงดูเหมือนว่าจะแม่นยำ และแสดงให้เห็นว่าอัลกอริทึมจัดการพื้นที่เชิงลบได้อย่างเพียงพอ

ขั้นตอนที่ 10: การเรียกใช้โปรแกรมส่วนที่ 3: การขยายโปรแกรม

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

ความคิดของฉันเกี่ยวกับการขยายโปรแกรม:

• ใช้ส่วนต่อประสานกราฟิกกับผู้ใช้ที่อนุญาตให้คุณเรียกใช้โปรแกรมโดยไม่ต้องใช้สภาพแวดล้อมการวิเคราะห์ข้อมูลเชิงโต้ตอบของ Canopy
• ทำให้ฟังก์ชันทางคณิตศาสตร์ที่จะรวมเข้าด้วยกันไม่จำเป็นต้องป้อนเข้าในโปรแกรม แต่สามารถป้อนข้อมูลได้หลังจากรันโปรแกรมแล้ว (ตอนแรกฉันพยายามทำเช่นนี้ แต่คิดไม่ออก)
• กำหนดฟังก์ชัน Python "Integrate" เพื่อให้ใช้ฟังก์ชัน f(x) ตามที่กำหนดให้มีฟังก์ชัน f(x) กำหนดอยู่ภายใน

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