พล็อตจุดใน MATLAB พล็อต MATLAB

3. กราฟิก 3 มิติ .

กราฟของฟังก์ชันของตัวแปรสองตัวคือชิ้นส่วนของพื้นผิวที่แขวนอยู่เหนือพื้นที่นิยามของฟังก์ชัน จากสิ่งนี้ เป็นที่ชัดเจนว่าการแสดงกราฟของฟังก์ชันของตัวแปรสองตัวนั้นต้องใช้ "กราฟิกสามมิติ" บนจอคอมพิวเตอร์แบบจอแบน

ระบบย่อยกราฟิกระดับสูงของ MATLAB จะปรับใช้กราฟิก 3D โดยอัตโนมัติโดยไม่ต้องใช้ความพยายามพิเศษในส่วนของผู้ใช้ ให้คำนวณค่าของฟังก์ชัน z=f(x,y) ที่จุดที่มีพิกัด x1,y1 และเท่ากับ z1 ณ จุดอื่น (นั่นคือ ด้วยค่าของอาร์กิวเมนต์ที่ต่างกัน) x2,y2 คำนวณค่าของฟังก์ชัน z2 ต่อกระบวนการนี้ เราได้รับอาร์เรย์ (ชุด) ของจุด (x1,y1,z1), (x2,y2,z2), (xN,yN,zN) จำนวน N ชิ้นที่อยู่ในพื้นที่สามมิติ ฟังก์ชันพิเศษของระบบ MATLAB จะวาดพื้นผิวเรียบผ่านจุดเหล่านี้ และแสดงการฉายภาพบนจอคอมพิวเตอร์แบบแบน

ส่วนใหญ่แล้ว จุดอาร์กิวเมนต์จะถูกจัดเรียงอย่างสม่ำเสมอในโดเมนของฟังก์ชันในรูปแบบของตารางสี่เหลี่ยม (นั่นคือเมทริกซ์) ตารางของจุดดังกล่าวสร้างเมทริกซ์สองตัวของโครงสร้างเดียวกัน: เมทริกซ์แรกมีค่าของพิกัดแรกของจุดเหล่านี้ (พิกัด x) และเมทริกซ์ที่สองมีค่าของพิกัดที่สอง (y - พิกัด). ลองกำหนดเมทริกซ์แรกเป็น X และอันที่สอง - เป็น Y นอกจากนี้ยังมีเมทริกซ์ที่สาม - เมทริกซ์ของค่าของฟังก์ชัน z=f(x,y) ด้วยอาร์กิวเมนต์เหล่านี้ เมทริกซ์นี้จะแสดงด้วยตัวอักษร Z

ฟังก์ชันที่ง่ายที่สุดสำหรับการพล็อตฟังก์ชันของตัวแปรสองตัวในระบบ MATLAB คือฟังก์ชัน

พล็อต3(X , Y , Z)

โดยที่ X, Y และ Z เป็นเมทริกซ์ที่มีขนาดเท่ากัน ความหมายที่เราเพิ่งอธิบายไป

MATLAB มีฟังก์ชันพิเศษในการรับอาร์เรย์สองมิติ X และ Y จากอาร์เรย์หนึ่งมิติ x, y

P P> ให้แกน x กำหนดช่วงของค่าเป็นเวกเตอร์

ยู=-2:0.1:2

และบนแกน y พิสัยนี้คือ

v=-1:0.1:1

ในการรับเมทริกซ์ X และ Y ที่แทนพิกัดที่หนึ่งและสองของตารางจุดสี่เหลี่ยมที่เป็นผลลัพธ์ ให้ใช้ฟังก์ชันพิเศษของระบบ MATLAB:

[ X , Y ] = meshgrid(u, v)

ดังที่เราเห็น ฟังก์ชันนี้ได้รับเป็นอินพุตสองอาร์เรย์หนึ่งมิติ (เวกเตอร์) ซึ่งแทนอาร์เรย์ของจุดบนแกนพิกัด และส่งคืนอาร์เรย์สองมิติที่จำเป็นสองชุดทันที บนตารางจุดสี่เหลี่ยม เราคำนวณค่าของฟังก์ชัน ตัวอย่างเช่น ฟังก์ชัน exp:

Z = exp(- X.^2 - Y.^2)

สุดท้าย การใช้ฟังก์ชัน plot3 ที่อธิบายข้างต้น เราจะได้ภาพกราฟสามมิติของฟังก์ชันนี้ดังต่อไปนี้:

จากรูปนี้ จะเห็นว่าฟังก์ชัน plot3 แปลงเป็นเซตของเส้นตรงในอวกาศ ซึ่งแต่ละอันเป็นส่วนหนึ่งของพื้นผิวสามมิติโดยระนาบขนานกับระนาบ yOz ในอีกทางหนึ่ง เราสามารถพูดได้ว่าแต่ละเส้นได้มาจากส่วนของเส้นตรงที่เชื่อมต่อชุดของจุดที่พิกัดถูกนำมาจากคอลัมน์เดียวกันของเมทริกซ์ X, Y และ Z นั่นคือ บรรทัดแรกสอดคล้องกับคอลัมน์แรกของ X, YZ เมทริกซ์; บรรทัดที่สอง - ไปยังคอลัมน์ที่สองของเมทริกซ์เหล่านี้เป็นต้น

ในการพล็อตเส้นสามมิติที่ตั้งค่าแบบพาราเมตริก จะใช้รูปแบบอื่นของการเรียกใช้ฟังก์ชัน plot3:

พล็อต3(x, y, z)

โดยที่ x, y และ z เป็นอาร์เรย์หนึ่งมิติของพิกัดของจุด ซึ่งต้องเชื่อมต่อแบบอนุกรมโดยส่วนของเส้นตรง ตัวอย่างเช่น โค้ด snippet . ต่อไปนี้

เสื้อ = 0: pi/50: 10*pi ;

x = บาป(t);

y = cos(t);

พล็อต3(x, y, t);

บนตะแกรง

โดยที่คำสั่งที่ทราบจากกราฟแบบแบนจะถูกนำไปใช้

บนตะแกรง

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

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

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

ประสบการณ์(- X.^2 - Y.^2)

ได้ภาพนี้

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

ฟังก์ชันตาข่ายใช้ฟังก์ชันเซิร์ฟ (X, Y, Z)

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

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

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

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

แผนที่สี(ทองแดง)

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

ท่อง(X, Y, Z)

แทนที่จะเป็นการโต้คลื่น (X,Y,Z) ทำให้ได้กราฟที่ดูสมจริงมาก:

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

แรเงา interp

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

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

ที่จุด 0.2, 0.3, 0.5, 0.8, 1.3, 1.7, 2.5.
ปัญหาได้รับการแก้ไขในสองขั้นตอน
1. สร้างเวกเตอร์แถว เอ็กซ์,ที่มีพิกัดของจุดที่กำหนด
2. คำนวณค่าฟังก์ชัน y(X) จากแต่ละองค์ประกอบของเวกเตอร์ Xและค่าผลลัพธ์จะถูกเขียนไปยังเวกเตอร์แถว ย.
ต้องพบค่าฟังก์ชันสำหรับแต่ละองค์ประกอบของเวกเตอร์แถว เอ็กซ์,ดังนั้นการดำเนินการในนิพจน์สำหรับฟังก์ชันจะต้องดำเนินการ องค์ประกอบต่อองค์ประกอบ.

» x =
x =
0.2000 0.3000 0.5000 0.8000 1.3000 1.7000 2.5000 y = บาป(x).^2./(l+cos(x))+exp(-x).*log(x)
ย =

โปรดทราบว่าเมื่อพยายามใช้การยกกำลัง ^, การหาร / และการคูณ * (ซึ่งไม่ใช่องค์ประกอบที่ชาญฉลาด) ข้อความแสดงข้อผิดพลาดจะปรากฏขึ้นเมื่อ sin(x) ถูกยกกำลังสอง:

"y \u003d บาป (x) ^ 2 / (1 + cos (x)) + exp (-x) * บันทึก (x)
??? เกิดข้อผิดพลาดในการใช้ ==> ^
เมทริกซ์ต้องเป็นสี่เหลี่ยมจัตุรัส

ความจริงก็คือใน MatLab การดำเนินการ * และ ^ ใช้เพื่อคูณเมทริกซ์ของขนาดที่สอดคล้องกัน และเพิ่มเมทริกซ์กำลังสองเป็นยกกำลัง
ตารางสามารถทำให้อ่านได้ง่ายขึ้นโดยการวางค่าฟังก์ชันไว้ด้านล่างค่าอาร์กิวเมนต์โดยตรง:

" X
x =
0.2000 0.3000 0.5000 0.8000 1.3000 1.7000 2.5000 »
y=
-1.2978 -0.8473 -0.2980 0.2030 0.8040 1.2258 1.8764

มักจำเป็นต้องแสดงค่าของฟังก์ชันที่จุดของเซ็กเมนต์ที่เว้นระยะห่างจากกันด้วยระยะทางเท่ากัน (ขั้นตอน) สมมติว่าเราต้องแสดงตารางค่าฟังก์ชัน y(X) ในส่วนที่มีขั้นตอน 0.2 แน่นอน คุณสามารถป้อนเวกเตอร์แถวของค่าอาร์กิวเมนต์ได้ x=จากบรรทัดคำสั่งและคำนวณค่าฟังก์ชันทั้งหมดตามที่อธิบายไว้ข้างต้น อย่างไรก็ตามหากขั้นตอนไม่ใช่ 0.2 แต่เช่น 0.01 แสดงว่ามีงานต้องทำมากมายในการป้อนเวกเตอร์ เอ็กซ์
MatLab ให้การสร้างเวกเตอร์อย่างง่าย ซึ่งแต่ละองค์ประกอบจะแตกต่างจากองค์ประกอบก่อนหน้าด้วยค่าคงที่ กล่าวคือ ขั้นตอนเดียว เครื่องหมายทวิภาคใช้เพื่อป้อนเวกเตอร์ดังกล่าว (อย่าสับสนกับการจัดทำดัชนีโคลอน) ตัวดำเนินการสองตัวถัดไปส่งผลให้เกิดเวกเตอร์แถวที่เหมือนกัน คุณสามารถเขียนแบบมีเงื่อนไข

» x =
x =
» x =
x =
1.0000 1.2000 1.4000 1.6000 1.8000 2.0000

คุณสามารถเขียนแบบมีเงื่อนไข

x = [ค่าเริ่มต้น: ขั้นตอน: ค่าสิ้นสุด]

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

» x =
x =
1.0000 1.2000 1.4000 1.6000 1.8000

เวกเตอร์แถวจะเติมองค์ประกอบที่ไม่เกินค่าสิ้นสุดที่เรากำหนด ขั้นตอนอาจเป็นลบได้เช่นกัน:

» x =
x =
1.9000 1.7000 1.5000 1.3000 1.1000

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

"x="
x =
0
0.1000
0.2000
0.3000
0.4000
0.5000

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

» x =
x =
1 2 3 4 5

กำหนดให้ต้องแสดงตารางค่าฟังก์ชัน

ในส่วนที่มีขั้นตอน 0.05
เมื่อต้องการทำงานนี้ คุณต้องทำตามขั้นตอนต่อไปนี้:
1. สร้างแถวเวกเตอร์ Xโดยใช้เครื่องหมายทวิภาค
2. คำนวณค่า ที่(X) จากองค์ประกอบ X.
3. เขียนผลลัพธ์ลงในเวกเตอร์แถว ย.
4. ถอนออก Xและ ย.

» x = ;
» y = exp(-x).*sin(10*x);
" X
x =
คอลัมน์ 1 ถึง 7
О 0.0500 0.1000 0.1500 0.2000 0.2500 0.3000
คอลัมน์ 8 ถึง 14
0.3500 0.4000 0.4500 0.5000 0.5500 0.6000 0.6500
คอลัมน์ 15 ถึง 21
0.7000 0.7500 0.8000 0.8500 0.9000 0.9500 1.0000
" ที่
ย =
คอลัมน์ 1 ถึง 7
0 0.4560 0.7614 0.8586 0.7445 0.4661 0.1045
คอลัมน์ 8 ถึง 14
-0.2472 -0.5073 -0.6233 -0.5816 -0.4071 -0.1533 0.1123
คอลัมน์ 15 ถึง 21
0.3262 0.4431 0.4445 0.3413 0.1676 -0.0291 -0.2001

แถวเวกเตอร์ x และ yประกอบด้วยองค์ประกอบ 21 อย่าง และไม่พอดีกับหน้าจอในบรรทัดเดียว จึงแสดงเป็นส่วนๆ เพราะ Xและ yเก็บไว้ในอาร์เรย์สองมิติของมิติทีละ 21 จากนั้นจึงแสดงในคอลัมน์ ซึ่งแต่ละส่วนประกอบด้วยหนึ่งองค์ประกอบ คอลัมน์ 1 ถึง 7 จะแสดงก่อน (คอลัมน์ 1 ถึง 7) จากนั้นคอลัมน์ 8 ถึง 14 (คอลัมน์ 8 ถึง 14) และสุดท้ายคือคอลัมน์ 15 ถึง 21 (คอลัมน์ 15 ถึง 21) ภาพและสะดวกยิ่งขึ้นคือการแสดงกราฟิกของฟังก์ชัน

2. การพลอตฟังก์ชันของตัวแปรหนึ่งตัว

2.1. กราฟของฟังก์ชันในระดับเชิงเส้น

MatLab ได้พัฒนาความสามารถด้านกราฟิกสำหรับการแสดงข้อมูลเป็นภาพเป็นอย่างดี พิจารณาที่จุดเริ่มต้นการสร้างกราฟที่ง่ายที่สุดของฟังก์ชันของตัวแปรหนึ่งโดยใช้ตัวอย่างของฟังก์ชัน

กำหนดไว้ในส่วน ผลลัพธ์ของฟังก์ชันในรูปแบบของกราฟประกอบด้วยขั้นตอนต่อไปนี้:
1. การระบุเวกเตอร์ของค่าอาร์กิวเมนต์ เอ็กซ์
2. การคำนวณเวกเตอร์ ที่ค่าฟังก์ชัน y(X).
3. เรียกคำสั่ง plot เพื่อพล็อตกราฟ
คำสั่งสำหรับการระบุ Vector Xและเป็นการดีกว่าที่จะยุติการคำนวณฟังก์ชันด้วยเครื่องหมายอัฒภาคเพื่อระงับการแสดงผลของค่าไปยังหน้าต่างคำสั่ง (ไม่จำเป็นต้องใส่เครื่องหมายอัฒภาคหลังคำสั่ง plot เนื่องจากไม่ได้ส่งออกข้อมูลใดๆ

» x = ;
» y = exp(-x).*sin(10*x);
»พล็อต(x, y)

หลังจากดำเนินการคำสั่ง หน้าต่างจะปรากฏขึ้นบนหน้าจอ รูป ไม่. หนึ่งด้วยกราฟฟังก์ชัน หน้าต่างประกอบด้วยเมนู แถบเครื่องมือ และพื้นที่แผนภูมิ ต่อไปนี้ จะอธิบายคำสั่งที่ออกแบบมาเป็นพิเศษสำหรับการออกแบบแผนภูมิ ตอนนี้เราสนใจหลักการของการวางแผนและความเป็นไปได้ที่ง่ายที่สุดบางประการสำหรับการแสดงภาพฟังก์ชัน
ในการลงจุดกราฟฟังก์ชันในพื้นที่ทำงาน MatLab จะต้องกำหนดเวกเตอร์สองตัวที่มีมิติเดียวกัน ตัวอย่างเช่น Xและ ย.อาร์เรย์ที่สอดคล้องกัน x มีค่าของอาร์กิวเมนต์ และ y มีค่าฟังก์ชันของอาร์กิวเมนต์เหล่านั้น คำสั่ง plot เชื่อมต่อจุดต่างๆ ด้วยพิกัด (x(i), y(i)) ด้วยเส้นตรง โดยจะปรับขนาดแกนโดยอัตโนมัติเพื่อการวางตำแหน่งพล็อตในหน้าต่างที่เหมาะสมที่สุด เมื่อทำการพล็อตกราฟ จะสะดวกที่จะวางหน้าต่าง MatLab หลักและหน้าต่างโดยให้กราฟอยู่เคียงข้างกันบนหน้าจอ เพื่อไม่ให้ซ้อนทับกัน
กราฟที่สร้างขึ้นของฟังก์ชันมีจุดบอด เพื่อการพล็อตที่แม่นยำยิ่งขึ้น ต้องคำนวณฟังก์ชัน y(X) ที่จุดจำนวนมากในกลุ่ม นั่นคือ กำหนดขั้นตอนที่เล็กลงเมื่อป้อนเวกเตอร์ X:

» x = ;
» y = exp(-x).*sin(10*x);
»พล็อต(x, y)

ผลลัพธ์ที่ได้คือกราฟของฟังก์ชันในรูปของเส้นโค้งที่นุ่มนวลขึ้น
สะดวกในการเปรียบเทียบฟังก์ชันต่างๆ ด้วยการแสดงกราฟบนแกนเดียวกัน ตัวอย่างเช่น ในช่วง [-1, -0.3] เราพล็อตกราฟของฟังก์ชัน
,

โดยใช้ลำดับของคำสั่งต่อไปนี้:

» x = [-1:0.005:-0.3];
» f = บาป(x.^-2);
» ก. = บาป(1.2*x.^-2);
» พล็อต(x, f, x, g)

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

» x1 = [-1:0.005:-0.3];
» f = บาป(x1.^-2);
» x2 = [-1:0.005:0.3];
» g = บาป(1.2*x2.^-2);
» พล็อต(x1, f, x2, g)

ในทำนองเดียวกัน โดยการระบุคู่อาร์กิวเมนต์ของรูปแบบ: เวกเตอร์ abscissa, เวกเตอร์พิกัดในพล็อต, คั่นด้วยเครื่องหมายจุลภาค, กราฟของจำนวนฟังก์ชันตามอำเภอใจจะถูกพล็อต

หมายเหตุ 1

การใช้พล็อตกับอาร์กิวเมนต์หนึ่งอาร์กิวเมนต์ ทำให้เกิด "พล็อตเวกเตอร์" เช่น การพึ่งพาค่าขององค์ประกอบเวกเตอร์กับตัวเลข อาร์กิวเมนต์การพล็อตสามารถเป็นเมทริกซ์ได้เช่นกัน ซึ่งในกรณีนี้ กราฟของคอลัมน์จะแสดงบนแกนพิกัดเดียวกัน
บางครั้งคุณต้องการเปรียบเทียบพฤติกรรมของสองฟังก์ชันที่มีค่าต่างกันมาก กราฟของฟังก์ชันที่มีค่าน้อยผสานกับแกน abscissa ในทางปฏิบัติและไม่สามารถกำหนดลักษณะที่ปรากฏได้ ในสถานการณ์นี้ ฟังก์ชัน plotyy ช่วย ซึ่งแสดงกราฟในหน้าต่างที่มีแกนแนวตั้งสองแกนที่มีมาตราส่วนที่เหมาะสม
เปรียบเทียบ ตัวอย่างเช่น สองฟังก์ชัน: และ

» x = ;
» f = x.^-3;
» F \u003d 1,000 * (x + 0.5) ^-4;
» พล็อต (x, f, x, F)

ในขณะที่คุณเรียกใช้ตัวอย่างนี้ สังเกตว่าสีของกราฟตรงกับสีของแกน y ที่สอดคล้องกัน
ฟังก์ชันพล็อตใช้สเกลเชิงเส้นบนแกนพิกัดทั้งสอง อย่างไรก็ตาม MatLab มอบความสามารถในการพล็อตฟังก์ชันของตัวแปรหนึ่งตัวในระดับลอการิทึมหรือกึ่งลอการิทึม

2.2. กราฟของฟังก์ชันในมาตราส่วนลอการิทึม

ฟังก์ชันต่อไปนี้ใช้เพื่อพล็อตมาตราส่วนลอการิทึมและเซมิลอการิทึม:
- loglog (สเกลลอการิทึมทั้งสองแกน);
- semilogx (มาตราส่วนลอการิทึมตามแกน x เท่านั้น);
-semilogy (มาตราส่วนลอการิทึมตามแกน y เท่านั้น)

อาร์กิวเมนต์ loglog, semilogx และ semilogy ถูกระบุเป็นคู่ของเวกเตอร์ของ abscissa และค่าพิกัดในลักษณะเดียวกับฟังก์ชันพล็อตที่อธิบายไว้ในย่อหน้าก่อนหน้า ให้เราสร้าง เช่น กราฟของฟังก์ชัน และ บนเซ็กเมนต์ในระดับลอการิทึมตามแนวแกน X:

» x = ;
» f = บันทึก(0.5*x);
» g = บาป(บันทึก(x));
» semilogx(x, f, x,g)

2.3. การตั้งค่าคุณสมบัติของเส้นบนกราฟฟังก์ชัน

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

เครื่องหมายประเภท		ประเภทสาย
			แข็ง
			จุด
			เส้นประ
	เครื่องหมายบวก		ประ
	ดาว


	สามเหลี่ยมคว่ำ
	สามเหลี่ยมคว่ำ
	สามเหลี่ยมชี้ไปทางซ้าย
	สามเหลี่ยมชี้ไปทางขวา
	ดาวห้าแฉก
	ดาวหกแฉก

ตัวอย่างเช่น หากคุณจำเป็นต้องพล็อตกราฟแรกด้วยเครื่องหมายจุดสีแดงโดยไม่มีเส้น และกราฟที่สองที่มีเส้นประสีดำ คุณควรใช้พล็อต (x, f, "r.", x, g, คำสั่ง "k:")

2.4. การออกแบบกราฟฟังก์ชัน

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

» เวลา = ;
» อุณหภูมิ1 = ;
» อุณหภูมิ2 = ;
» พล็อต (เวลา, temp1, "ro-", เวลา, temp2, "go-")
» กริดบน
» title("อุณหภูมิรายวัน")
» xlabel("เวลา (ชั่วโมง)")
» ylabel("อุณหภูมิ (C)")
» ตำนาน("10 พฤษภาคม 11 พฤษภาคม")

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

* -1 - นอกแผนภูมิที่มุมบนขวาของหน้าต่างกราฟิก
* 0 - เลือกตำแหน่งที่ดีที่สุดในกราฟเพื่อให้กราฟทับซ้อนกันน้อยที่สุด
* 1 - ที่มุมขวาบนของแผนภูมิ (ตำแหน่งนี้ถูกใช้โดยค่าเริ่มต้น);
* 2 - ที่มุมซ้ายบนของแผนภูมิ
* 3 - ที่มุมล่างซ้ายของแผนภูมิ
* 4 - ที่มุมล่างขวาของแผนภูมิ

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

» พล็อต(x,f,"k-",x,g,"k:")

ดำเนินการสร้างกราฟแรกด้วยเส้นสีดำทึบ และกราฟที่สอง - ด้วยเส้นประสีดำ อาร์กิวเมนต์ "k-" และ "k:" จะระบุรูปแบบและสีของบรรทัดแรกและบรรทัดที่สอง ในที่นี้ k หมายถึงสีดำ และยัติภังค์หรือโคลอนหมายถึงเส้นทึบหรือเส้นประ สามารถปิดหน้าต่างแผนภูมิได้โดยคลิกที่ปุ่มที่มีเครื่องหมายกากบาทที่มุมขวาบน

3. ฟังก์ชั่นพล็อตของสองตัวแปร

การพล็อตฟังก์ชันของตัวแปรสองตัวใน MatLab บนพื้นที่สี่เหลี่ยมของคำจำกัดความของตัวแปรประกอบด้วยสองขั้นตอนเบื้องต้น:
1. แบ่งโดเมนของคำจำกัดความด้วยกริดสี่เหลี่ยม
2. การคำนวณค่าฟังก์ชันที่จุดตัดของเส้นตารางและการเข้าสู่เมทริกซ์
มาพลอตฟังก์ชันกัน z(x,ที่)= X 2 + ที่ 2 บนโดเมนของคำจำกัดความในรูปแบบของสี่เหลี่ยม Xเป็นของ , y- . จำเป็นต้องแบ่งสี่เหลี่ยมจัตุรัสด้วยตารางสม่ำเสมอ (เช่น ด้วยขั้นตอน 0.2) และคำนวณค่าของฟังก์ชันที่โหนดที่ระบุด้วยจุด
สะดวกในการใช้อาร์เรย์สองมิติ x และ y ที่มีขนาดหกคูณหกเพื่อเก็บข้อมูลเกี่ยวกับพิกัดของโหนด อาร์เรย์ x ประกอบด้วยสตริงที่เหมือนกันซึ่งมีพิกัด x 1, X 2, ..., X 6 และอาร์เรย์ ที่มีคอลัมน์เดียวกับ y1, ที่ 2, ..., ที่ 6. เราเขียนค่าฟังก์ชันที่โหนดกริดลงในอาร์เรย์ z ของมิติเดียวกัน (6 x 6) และคำนวณเมทริกซ์ Zใช้นิพจน์สำหรับฟังก์ชัน แต่ด้วย องค์ประกอบต่อองค์ประกอบการดำเนินการเมทริกซ์ ตัวอย่างเช่น z(3,4) จะเท่ากับค่าของฟังก์ชัน z(x,y) ณ จุดนั้น (x3, ที่สี่) เพื่อสร้างกริดอาร์เรย์ Xและ ที่ตามพิกัดของโหนดใน MatLab จะมีการจัดเตรียมฟังก์ชัน meshgrid เพื่อพล็อตกราฟในรูปแบบของพื้นผิวโครงลวด ฟังก์ชันตาข่าย ข้อความต่อไปนี้ทำให้หน้าต่างที่มีกราฟของฟังก์ชันปรากฏขึ้นบนหน้าจอ (ไม่มีเครื่องหมายอัฒภาคที่ส่วนท้ายของคำสั่งเพื่อควบคุมการสร้างอาร์เรย์):

» = เมชกริด (0:0.2:1,0:0.2:1)
X=

0 0.2000 0.4000 0.6000 0.8000 1.0000
0 0.2000 0.4000 0.6000 0.8000 1.0000
0 0.2000 0.4000 0.6000 0.8000 1.0000
0 0.2000 0.4000 0.6000 0.8000 1.0000
0 0.2000 0.4000 0.6000 0.8000 1.0000
y=
0 0 0 0 0 0
0.2000 0.2000 0.2000 0.2000 0.2000 0.2000
0.4000 0.4000 0.4000 0.4000 0.4000 0.4000
0.6000 0.6000 0.6000 0.6000 0.6000 0.6000
0.8000 0.8000 0.8000 0.8000 0.8000 0.8000
1.0000 1.0000 1.0000 1.0000 1.0000 1.0000

» Z = X.^2+Y.^2

Z=
0 0.0400 0.1600 0.3600 0.6400 1.0000
0.0400 0.0800 0.2000 0.4000 0.6800 1.0400
0.1600 0.2000 0.3200 0.5200 0.8000 1.1600
0.3600 0.4000 0.5200 0.7200 1.0000 1.3600
0.6400 0.6800 0.8000 1.0000 1.2800 1.6400
1.0000 1.0400 1.1600 1.3600 1.6400 2.0000

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

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

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

บนโดเมนสี่เหลี่ยม Xเป็นของ [-1, 1], y .
มาเตรียมเมทริกซ์ด้วยพิกัดของโหนดกริดและค่าฟังก์ชัน:

» = เมชกริด(-1:0.05:1, 0:0.05:1);
» Z = 4*บาป(2*pi*X).*cos(1.5*pi*Y).*(1-X.^2).*Y.*(1-Y);

ในการสร้างพื้นผิวโครงลวด ใช้ฟังก์ชันเมช ซึ่งเรียกด้วยอาร์กิวเมนต์สามตัว:

สีของเส้นพื้นผิวสอดคล้องกับค่าของฟังก์ชัน MatLab ดึงเฉพาะส่วนที่มองเห็นได้ของพื้นผิว

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

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

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

»เซิร์ฟ(X,Y,Z)
» แถบสี

คำสั่งแถบสีสามารถใช้ร่วมกับฟังก์ชันทั้งหมดที่วาดวัตถุ 3 มิติ

การใช้พื้นผิวที่มีสีเป็นการยากที่จะสรุปเกี่ยวกับค่าของฟังก์ชัน ณ จุดใดจุดหนึ่งในระนาบ xyคำสั่ง meshc หรือ surfc ช่วยให้คุณเข้าใจพฤติกรรมของฟังก์ชันได้แม่นยำยิ่งขึ้น คำสั่งเหล่านี้สร้างพื้นผิวโครงลวดหรือพื้นผิวโครงลวดที่เติมสีแล้ววางบนระนาบ xyเส้นระดับฟังก์ชัน (เส้นคงตัวของค่าฟังก์ชัน):

»เซิร์ฟ (X,Y,Z)
» แถบสี

MatLab ช่วยให้คุณสร้างพื้นผิวที่ประกอบด้วยเส้นระดับโดยใช้ฟังก์ชัน contour3 ฟังก์ชันนี้สามารถใช้ได้ในลักษณะเดียวกับ mesh, surf, meshc และ surfc ด้านบนด้วยอาร์กิวเมนต์สามตัว ในกรณีนี้ จำนวนบรรทัดระดับจะถูกเลือกโดยอัตโนมัติ เป็นไปได้ที่จะระบุเป็นอาร์กิวเมนต์ที่สี่ใน contour3 ทั้งจำนวนเส้นระดับหรือเวกเตอร์ที่มีองค์ประกอบเท่ากับค่าฟังก์ชันที่แสดงเป็นเส้นระดับ การระบุเวกเตอร์ (ระดับ, อาร์กิวเมนต์ที่สี่) นั้นสะดวกเมื่อคุณต้องการสำรวจพฤติกรรมของฟังก์ชันในช่วงค่าที่แน่นอน (การแบ่งฟังก์ชัน) สร้างตัวอย่างเช่นพื้นผิวที่ประกอบด้วยเส้นระดับที่สอดคล้องกับค่าฟังก์ชันตั้งแต่ 0 ถึง 0.5 ด้วยขั้นตอน 0.01:

» ระดับ = ;
» รูปร่าง3(X, Y, Z, ระดับ)
» แถบสี

4. การสร้างแผนผังฟังก์ชันของตัวแปรสองตัว

MatLab ให้ความสามารถในการรับแปลงรูปร่างประเภทต่างๆ โดยใช้ฟังก์ชันรูปร่างและเส้นขอบ ลองพิจารณาความสามารถของพวกเขาในตัวอย่างของฟังก์ชัน

การใช้รูปร่างที่มีสามอาร์กิวเมนต์

»รูปร่าง (X,Y,Z)

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

» = รูปร่าง (X, Y, Z);
» clabel(CMatr, h)
» กริดบน

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

» รูปร่างf(X, Y, Z, 20)
» แถบสี

5. การออกแบบกราฟของฟังก์ชัน

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

» เซิร์ฟ (X, Y, Z)
»แถบสี
» แผนที่สี(สีเทา)
» title("กราฟของฟังก์ชัน z(x,y)")
» xlabel("x")
» ylabel("y")
» zlabel("z")

โปรดทราบว่าคำสั่ง colormap(สีเทา) เปลี่ยนจานสีของหน้าต่างกราฟิก เช่น กราฟต่อไปนี้จะแสดงในหน้าต่างนี้ด้วยโทนสีเทา หากต้องการคืนค่าเดิมของจานสี ให้ใช้คำสั่ง colormap("default") จานสีที่มีอยู่ใน MatLab จะแสดงในตาราง 2.

ตารางที่ 2

จานสี	เปลี่ยนสี
	เนียนเปลี่ยน แดง-ส้ม-เหลือง.
	คล้ายกับจานสีเทา แต่มีสีน้ำเงินเล็กน้อย
	แต่ละสีเปลี่ยนจากมืดเป็นสว่าง
	เฉดสีฟ้าและม่วง
	เฉดสีทองแดง
	จักรยาน แดง-ขาว-น้ำเงิน-ดำ.
	โทนสีเทา.
	เนียนเปลี่ยน ดำ-แดง-ส้ม-เหลือง-ขาว.
	เปลี่ยนไปอย่างราบรื่นเหมือนสีรุ้ง
	เนียนเปลี่ยน น้ำเงิน - ฟ้า - แดง - เขียว - เหลือง - แดง
	คล้ายกับจานสีเทา แต่มีสีน้ำตาลเล็กน้อย
	จักรยานแดง-ส้ม-เหลือง-เขียว-น้ำเงิน-ม่วง
	เฉดสีม่วงและเหลือง
	เฉดสีเขียวและเหลือง
	จานสี Windows สิบหกสี
	สีขาวสีเดียว.
	เฉดสีฟ้าและเขียว

6. แสดงกราฟหลายกราฟบนแกนเดียวกัน

ในการแสดงกราฟฟังก์ชันต่างๆ ของตัวแปรหนึ่งตัวบนแกนเดียวกัน จะใช้ความเป็นไปได้ของฟังก์ชัน พล็อต, plotyy, semilogx, semilogy, loglog. อนุญาตให้คุณพล็อตฟังก์ชันหลายฟังก์ชันโดยระบุอาร์กิวเมนต์เวกเตอร์ที่เหมาะสมเป็นคู่ เช่น plot(x,f,x,g) อย่างไรก็ตาม ไม่สามารถใช้รวมแปลง 3 มิติได้ ในการรวมกราฟดังกล่าว คำสั่ง Hold on มีวัตถุประสงค์ ซึ่งต้องระบุก่อนการลงจุด ในตัวอย่างต่อไปนี้ การรวมกราฟสองกราฟ (ระนาบและกรวย) ส่งผลให้เกิดจุดตัดกัน กรวยถูกระบุแบบพาราเมตริกโดยการอ้างอิงต่อไปนี้:

, , , .

ในการแสดงรูปกรวยแบบกราฟิก ก่อนอื่นคุณต้องสร้างเวกเตอร์คอลัมน์และเวกเตอร์แถวโดยใช้เครื่องหมายทวิภาค ซึ่งมีค่าของพารามิเตอร์ในช่วงเวลาที่กำหนด (เป็นสิ่งสำคัญที่ คุณเอ็มเวกเตอร์คอลัมน์และเวกเตอร์แถวเป็นเมทริกซ์ที่มีหนึ่งมิติเท่ากับหนึ่ง จริงๆ แล้ว, จาก = abTที่การคูณเกิดขึ้นตามกฎ ผลิตภัณฑ์เมทริกซ์ตัวดำเนินการเครื่องหมายดอกจันใช้ในการคำนวณผลิตภัณฑ์เมทริกซ์ใน MatLab มากำหนดผลคูณภายนอกของเวกเตอร์สองตัวกัน:

» a = ;
» ข = ;
»C=a*b"
C=
5 6 7
10 12 14
15 18 21

มาสร้างเมทริกซ์กันเถอะ X,Yจำเป็นสำหรับการแสดงกราฟิกของกรวย:

» X = 0.3*u*cos(v);
» Y = 0.3*u*บาป(v);

เมทริกซ์ Zจะต้องมีขนาดเท่ากับเมทริกซ์ Xและ Y. นอกจากนี้ต้องมีค่าที่สอดคล้องกับค่าพารามิเตอร์ หากฟังก์ชั่นรวมผลิตภัณฑ์ และและ วีแล้วเมทริกซ์ Zสามารถเติมได้แบบเดียวกับเมทริกซ์ Xและ Yด้วยความช่วยเหลือของผลิตภัณฑ์ภายนอก ในทางกลับกัน ฟังก์ชัน z(คุณ v) สามารถแสดงเป็น , โดยที่ . ดังนั้นในการคำนวณ Zสามารถใช้ผลคูณภายนอกของเวกเตอร์ และ โดยที่เวกเตอร์แถวมีมิติเท่ากับ วีแต่ประกอบด้วยหน่วย:

» Z = 0.6*u*ones(ขนาด(v));

สร้างเมทริกซ์ที่จำเป็นสำหรับการแสดงกรวยแล้ว เครื่องบินถูกกำหนดดังนี้:

» = เมชกริด (-2:0.1:2);
» Z = 0.5*X+0.4*Y;

ตอนนี้ ไม่ยากเลยที่จะจดลำดับคำสั่งทั้งหมดสำหรับการสร้างกรวยและระนาบที่ตัดกัน:

» ยู = [-2*pi:0.1*pi:2*pi]";
» v = [-2*pi:0.1*pi:2*pi];
» X = 0.3*u*cos(v);
» Y = 0.3*u*บาป(v);
» Z = 0.6*u*ones(ขนาด(v));
» ท่อง(X, Y, Z)
» = เมชกริด (-2:0.1:2);
» Z = 0.5*X+0.4*Y;
" เดี๋ยว
» ตาข่าย (X, Y, Z)
» ปิดซ่อน

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

»พล็อต(x,f,x,g)

มีค่าเท่ากับลำดับ

»พล็อต(x,f)
" เดี๋ยว
» พล็อต(x,g)

ผลงานของฉัน:

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

3.1. ฟังก์ชั่นพล็อต

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

สมมติว่าคุณต้องการพล็อตฟังก์ชันไซน์ในช่วงตั้งแต่ 0 ถึง ในการทำเช่นนี้เราตั้งค่าเวกเตอร์ (ชุด) ของจุดตามแกน Ox ซึ่งจะแสดงค่าของฟังก์ชันไซน์:

ผลลัพธ์คือเวกเตอร์คอลัมน์ที่มีชุดค่าตั้งแต่ 0 ถึงและด้วยขั้นตอน 0.01 จากนั้นเราคำนวณชุดค่าของฟังก์ชันไซน์ที่จุดเหล่านี้:

และแสดงผลบนหน้าจอ

เป็นผลให้เราได้รับกราฟที่แสดงในรูปที่ 3.1.

รายการฟังก์ชัน plot() ที่นำเสนอแสดงว่าอาร์กิวเมนต์ที่มีเซตของจุดของแกน Ox ถูกเขียนขึ้นก่อน จากนั้นอาร์กิวเมนต์ที่มีเซตของจุดของแกน Oy เมื่อทราบค่าเหล่านี้แล้ว ฟังก์ชัน plot() จะสามารถพล็อตจุดบนระนาบและสอดแทรกเป็นเส้นตรงเพื่อให้เกิดการพล็อตต่อเนื่อง

ข้าว. 3.1. การแสดงฟังก์ชันไซน์โดยใช้ฟังก์ชัน plot()

ฟังก์ชัน plot() สามารถเขียนด้วยอาร์กิวเมนต์ x หรือ y เดียว:

พล็อต(x);
พล็อต(y);

เป็นผลให้เราได้รับกราฟสองแบบที่แสดงในรูปที่ 3.2.

การวิเคราะห์รูปที่ 3.2 แสดงว่าในกรณีของอาร์กิวเมนต์หนึ่ง ฟังก์ชัน plot() จะแสดงชุดของจุดตามแนวแกน Oy และสร้างชุดของจุดที่มีหน่วยก้าวตามแกน Ox โดยอัตโนมัติ ดังนั้น เพื่อให้เห็นภาพเวกเตอร์เป็นกราฟสองมิติอย่างง่ายดาย ก็เพียงพอแล้วที่จะใช้ฟังก์ชัน plot() กับอาร์กิวเมนต์เดียว

ในการพล็อตหลายแปลงบนแกนพิกัดเดียวกัน ฟังก์ชัน plot() จะถูกเขียนดังนี้:

x = 0:0.01:พาย;
y1 = บาป(x);
y2 = cos(x);
พล็อต(x,y1,x,y2);

ผลลัพธ์ของแฟรกเมนต์ของโปรแกรมนี้แสดงในรูปที่ 3.3.

ข้าว. 3.2. ผลลัพธ์ของฟังก์ชัน plot() พร้อมอาร์กิวเมนต์เดียว:

a – พล็อต(x); ข – พล็อต (y)

ข้าว. 3.3. แสดงกราฟสองกราฟในแกนพิกัดเดียวกัน

ในทำนองเดียวกัน สองแปลงสามารถพล็อตได้โดยใช้อาร์กิวเมนต์เดียวกับฟังก์ชัน plot() สมมุติว่ามีเวกเตอร์ค่าสองตัว

y1 = บาป(x);
y2 = cos(x);

มาแสดงบนหน้าจอ ในการทำเช่นนี้ เรารวมพวกมันเป็นเมทริกซ์สองมิติ

โดยที่คอลัมน์ประกอบด้วยเวกเตอร์ y1 และ y2 ตามลำดับ เมทริกซ์ดังกล่าวจะแสดงโดยฟังก์ชัน

พล็อต(); % apostrophes แปลเวกเตอร์แถว
% ไปยังเวกเตอร์คอลัมน์

ในรูปแบบของสองกราฟ (รูปที่ 3.4)

ข้าว. 3.4. การแสดงเมทริกซ์สองมิติในรูปแบบของสองกราฟ

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

x1 = 0:0.01:2*pi;
y1 = บาป(x1);

x2 = 0:0.01:pi;
y2 = cos(x2);

ตัวเลข; % การสร้างหน้าต่างกราฟิกที่ 2
พล็อต(x2, y2); % วาดแผนภูมิที่ 2 ในหน้าต่างที่ 2

ฟังก์ชันฟิกเกอร์ที่ใช้ในโปรแกรมนี้จะสร้างหน้าต่างกราฟิกใหม่และเปิดใช้งาน ฟังก์ชัน plot() ถูกเรียกทันทีหลังฟังก์ชันฟิกเกอร์ จะแสดงพล็อตในหน้าต่างกราฟิกที่ใช้งานอยู่ในปัจจุบัน ด้วยเหตุนี้ หน้าต่างสองบานที่มีสองกราฟจะแสดงบนหน้าจอ

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

x1 = 0:0.01:2*pi;
y1 = บาป(x1);

x2 = 0:0.01:pi;
y2 = cos(x2);

รูปที่ 1); %สร้างหน้าต่างหมายเลข 1
พล็อต(x1, y1); % วาดกราฟแรก
รูป (2); % สร้างหน้าต่างกราฟิกหมายเลข 2
พล็อต(x2, y2); % วาดแผนภูมิที่ 2 ในหน้าต่างที่ 2

เมื่อดำเนินการโปรแกรมนี้ หน้าต่างกราฟิกเพียงสองหน้าต่างที่มีตัวเลข 1 และ 2 เท่านั้นที่จะแสดงบนหน้าจอเสมอ และจะแสดงกราฟของฟังก์ชันไซน์และโคไซน์ตามลำดับ

ในบางกรณี การนำเสนอข้อมูลที่สะดวกยิ่งขึ้นสามารถทำได้โดยการแสดงกราฟสองกราฟในหน้าต่างกราฟิกเดียว ทำได้โดยใช้ฟังก์ชัน subplot() ซึ่งมีรูปแบบดังนี้:

แผนย่อย(<число строк>, <число столбцов>, <номер координатной оси>)

ลองพิจารณาตัวอย่างการแสดงกราฟสองกราฟใต้กันของฟังก์ชันไซน์และโคไซน์ด้านบน

x1 = 0:0.01:2*pi;
y1 = บาป(x1);

x2 = 0:0.01:pi;
y2 = cos(x2);

รูปที่ 1);
แผนย่อย(2,1,1); % แบ่งหน้าต่างออกเป็น 2 แถวและหนึ่งคอลัมน์
พล็อต(x1,y1); แสดง% ของกราฟแรก
แผนย่อย(2,1,2); % สร้างแกนพิกัดที่ 2
พล็อต(x2,y2); % แสดงกราฟที่ 2 ในแกนใหม่

ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 3.5.

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

แผนย่อย('ตำแหน่ง', );

โดยที่ left คือ offset จากด้านซ้ายของหน้าต่าง ด้านล่าง - ออฟเซ็ตจากด้านล่างของหน้าต่าง ความกว้าง ความสูง – ความกว้างและความสูงของแผนภูมิในหน้าต่าง ตัวแปรเหล่านี้ทั้งหมดมีตั้งแต่ 0 ถึง 1

ข้าว. 3.5. ตัวอย่างของฟังก์ชันย่อย

ด้านล่างเป็นส่วนของโปรแกรมสำหรับแสดงกราฟของฟังก์ชันไซน์ตรงกลางหน้าต่างกราฟิก ผลงานแสดงในรูปที่ 3.6.

x1 = 0:0.01:2*pi;
y1 = บาป(x1);

แผนย่อย('ตำแหน่ง', );
พล็อต(x1,y1);

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

ดังนั้น เมื่อใช้พารามิเตอร์ตำแหน่ง คุณสามารถวางองค์ประกอบกราฟิกในระนาบหน้าต่างได้ตามต้องการ

ข้าว. 3.6. ตัวอย่างการทำงานของฟังก์ชันแผนย่อยกับพารามิเตอร์ตำแหน่ง

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

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

พล็อต( , , <’цвет линии, тип линии, маркер точек’>);

โปรดทราบว่าพารามิเตอร์ที่สามเขียนด้วยเครื่องหมายอะพอสทรอฟีและมีสัญลักษณ์ที่ระบุในตาราง 3.1-3.3 เครื่องหมายด้านล่างเขียนทีละตัว เช่น

'ko' - บนแผนภูมิแสดงจุดของแผนภูมิด้วยวงกลมสีดำ
'ko-' - วาดแผนภูมิด้วยเส้นสีดำและใส่จุดในรูปแบบของวงกลม

แท็บ 3.1. การกำหนดสีของเส้นกราฟ

	สีเส้น

	สีม่วง

แท็บ 3.2. การกำหนดประเภทเส้นกราฟ

	สีเส้น
	ต่อเนื่อง
	ประ
	จุด
	เส้นประ

แท็บ 3.3. การกำหนดประเภทจุดกราฟ

	สีเส้น


	ดาว

ด้านล่างนี้คือตัวอย่างการเขียนฟังก์ชัน plot() ด้วยชุดเครื่องหมายต่างๆ

x = 0:0.1:2*พาย;
y = บาป(x);

แผนย่อย(2,2,1); พล็อต(x,y,"r-");
แผนย่อย(2,2,2); พล็อต(x,y,"r-",x,y,"ko");
แผนย่อย(2,2,3); พล็อต(y,"b--");
แผนย่อย(2,2,4); พล็อต(y,"b--+");

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

ข้าว. 3.7. ตัวอย่างการแสดงกราฟที่มีเครื่องหมายประเภทต่างๆ

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

แกน ([ xmin, xmax, ymin, ymax ]),

โดยที่ชื่อของพารามิเตอร์ที่ระบุจะสื่อถึงตัวมันเอง

ลองใช้ฟังก์ชันนี้เพื่อแสดงกราฟของฟังก์ชันไซน์ในช่วงตั้งแต่ 0 ถึง :

x = 0:0.1:2*พาย;
y = บาป(x);

แผนย่อย(1,2,1);
พล็อต(x,y);
แกน();

แผนย่อย(1,2,2);
พล็อต(x,y);
แกน();

จากผลลัพธ์ของโปรแกรม (รูปที่ 3.8) จะเห็นได้ว่าแม้จะมีการตั้งค่าฟังก์ชันไซน์อยู่ในช่วงตั้งแต่ 0 ถึง โดยใช้ฟังก์ชัน axis() คุณสามารถแสดงทั้งกราฟและแฟรกเมนต์ได้ ช่วงตั้งแต่ 0 ถึง .

ข้าว. 3.8. ตัวอย่างการทำงานของฟังก์ชัน axis()

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

ตารางที่ 3.4. ฟังก์ชันการออกแบบแผนภูมิ

ชื่อ	คำอธิบาย
	เปิด/ปิดเส้นตารางบนแผนภูมิ
ชื่อเรื่อง('ชื่อแผนภูมิ')	สร้างป้ายชื่อแผนภูมิ
xlabel('ป้ายกำกับแกนวัว')	สร้างป้ายกำกับแกน x
ylabel('ป้ายกำกับแกน Oy')	สร้างป้ายกำกับแกน Oy
ข้อความ(x,y,'ข้อความ')	สร้างป้ายกำกับข้อความที่พิกัด (x,y)

พิจารณาการทำงานของฟังก์ชันเหล่านี้ในตัวอย่างต่อไปนี้:

x = 0:0.1:2*พาย;
y = บาป(x);

พล็อต(x,y);
แกน();
กริดบน;
title("กราฟิกของฟังก์ชัน sin(x)");
xlabel("พิกัดของ Ox");
ylabel("พิกัดของ Oy");
text(3.05,0.16,"\leftarrow sin(x)");

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

ดังนั้น ด้วยการใช้ชุดฟังก์ชันและพารามิเตอร์ที่อธิบายไว้ คุณสามารถบรรลุวิธีการออกแบบกราฟที่ต้องการในระบบ MatLab ได้

ข้าว. 3.9. ตัวอย่างการทำงานของการออกแบบแผนภูมิ

การแสดงพื้นผิวที่มองเห็นได้ชัดเจนนั้นมาจากกราฟตาข่ายโดยใช้การแรเงาตามหน้าที่ของเซลล์ ตัวอย่างเช่น สีพื้นผิว z(x, y)สามารถปรับระดับความสูงได้ zพื้นผิวที่มีให้เลือกโทนสีเข้มสำหรับความสูงที่ต่ำ และโทนสีอ่อนสำหรับความสูงที่สูง ในการสร้างพื้นผิวดังกล่าวจะใช้คำสั่งคลาส นักท่อง (…):

ท่อง (X, Y, Z.C)- สร้างพื้นผิวสีพาราเมตริกตามเมทริกซ์ X, Y และ Z ด้วยสีที่ระบุโดยอาร์เรย์ C
ท่อง(X.Y.Z)- คล้ายกับคำสั่งก่อนหน้าโดยที่ C=Z เพื่อให้สีถูกกำหนดโดยความสูงของเซลล์ผิวหนึ่งหรือเซลล์อื่น
ท่อง(xyz)และ ท่อง(x.y.Z.C)ด้วยอาร์กิวเมนต์เวกเตอร์สองอาร์กิวเมนต์ x และ y - เวกเตอร์ x และ y แทนที่อาร์กิวเมนต์เมทริกซ์สองอาร์กิวเมนต์แรก และต้องมีความยาว length(x)=n และ length(y)=m โดยที่ =size(Z) ในกรณีนี้ จุดยอดของพื้นที่ผิวจะแสดงด้วยพิกัดสามเท่า (x(j), yd), Z(1,j)) โปรดทราบว่า x สอดคล้องกับคอลัมน์ Z และ y สอดคล้องกับแถว
ท่อง(Z)และ ท่อง(Z.C)ใช้ x = 1:n และ y = 1:m ในกรณีนี้ ความสูง Z เป็นฟังก์ชันที่กำหนดไว้อย่างเฉพาะเจาะจงซึ่งกำหนดโดยตารางสี่เหลี่ยมทางเรขาคณิต
h=ท่อง(...)- สร้างพื้นผิวและส่งคืนหมายเลขอ้างอิงไปยังวัตถุคลาส พื้นผิว.

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

ด้านล่างนี้เป็นตัวอย่างง่ายๆ ของการสร้างพื้นผิว - พาราโบลา:

> > = meshgrid([ - 3: 0.15: 3 ]);

> > Z = X.^2 + Y.^2 ;

> > เซิร์ฟ(X,Y,Z)

กราฟที่สอดคล้องกับตัวอย่างนี้แสดงในรูปที่ 6.25.

ข้าว. 6.25. พล็อตพาราโบลาพร้อมการระบายสีเซลล์ที่ใช้งานได้

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

ตัวอย่างต่อไปนี้ใช้การระบายสีระดับสีเทาที่ใช้งานได้กับเอาต์พุตระดับโทนสี:

> > = meshgrid([ - 3: 0.1: 3 ]);

> > Z = บาป(X). /(X.^2 + Y.^2 + 0.3);

> > ท่อง(X.Y.Z)

> > แผนที่สี (สีเทา)

> > แรเงา interp

>> แถบสี

ในตัวอย่างนี้ คำสั่ง แผนที่สี(สีเทา)กำหนดโทนสีของสีเทาและคำสั่ง แรเงา Interpให้การกำจัดภาพกริดและตั้งค่าการแก้ไขสำหรับเฉดสีของพื้นผิวปริมาตร ในรูป 6.26 แสดงมุมมองของกราฟที่สร้างขึ้นในตัวอย่างนี้

ข้าว. 6.26. พล็อตพื้นผิวพร้อมสีที่ใช้งานได้เป็นสีเทา

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