ไมโครโปรเซสเซอร์โรมานซ์กับจำนวนเต็มลบ – วิธีและเหตุผลของการออกแบบเลขคณิตของ CPU

สิ่งแรกที่เราเรียนรู้เกี่ยวกับคอมพิวเตอร์คือพวกเขาเข้าใจแค่ 0 และ 1 , หรือบิต .

ในทางกลับกัน มนุษย์เราสื่อสารตัวเลขผ่านระบบทศนิยม ระบบนี้ใช้ตัวเลขตั้งแต่ 0 ถึง 9 พร้อมกับเครื่องหมายบวกและลบ (+ และ -) เพื่อแสดงตัวเลขบวกหรือลบ

เนื่องจากคอมพิวเตอร์ใช้ตัวเลขได้เพียงสองหลัก – 0 และ 1 – วิศวกรและนักคณิตศาสตร์ในสมัยก่อนได้ออกแบบเทคนิคอันชาญฉลาดในการแทนค่าตัวเลขติดลบและการคำนวณเลขคณิต มาสำรวจความงามของเทคนิคเหล่านั้นกัน

ก่อนอื่น ขอทราบข้อมูลเบื้องต้นเกี่ยวกับวิธีการทำงานของคอมพิวเตอร์

ซอฟต์แวร์ รูปภาพ ข้อความ วิดีโอ ตัวเลข และทุกสิ่งในระหว่างนั้นคือ 0 และ 1 ที่ระดับต่ำสุดในคอมพิวเตอร์ของเรา

สำหรับรูปภาพ ข้อความ วิดีโอ และตัวเลข เรามีรูปแบบการเข้ารหัสที่กำหนดว่าข้อมูลเหล่านี้จะไปถึง 0 และ 1 ได้อย่างไร เช่น ASCII และ Unicode สำหรับข้อความ

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

โปรเซสเซอร์เริ่มรอบการดำเนินการโดย ดึงข้อมูล คำแนะนำจากหน่วยความจำหลัก จากนั้นหน่วยควบคุมของโปรเซสเซอร์ จะถอดรหัส คำแนะนำเหล่านั้นออกเป็นสองส่วน - รหัสการทำงาน (opcode) และตัวถูกดำเนินการ

opcode ตัดสินใจดำเนินการเพิ่มเติมที่จำเป็นต้องดำเนินการเช่น ADD (เพิ่มเติม), JMP (ข้าม), INC (เพิ่มขึ้น) เป็นต้น ตัวถูกดำเนินการคือค่า (หรือตำแหน่งหน่วยความจำ) ที่การดำเนินการนั้นจะถูกดำเนินการ

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

ตัวอย่างเช่น รหัสการประกอบ ADD eax, 42 ถูกเปลี่ยนเป็นรหัสเครื่อง (0s และ 1s) เป็นครั้งแรกโดยแอสเซมเบลอร์ จากนั้นจะถูกเก็บไว้ในหน่วยความจำหลักก่อนที่วงจร fetch-decode-execute จะเริ่มขึ้น

เมื่อทำการดึงรหัสเครื่องสำหรับ ADD eax, 42 จากหน่วยความจำเสร็จสิ้นคำสั่งจะถูกถอดรหัส เอาต์พุตที่ถอดรหัสบอกว่า opcode คือ ADD และตัวถูกดำเนินการคือ eax และ 42 .

eax คือรีจิสเตอร์ – ตำแหน่งหน่วยความจำที่ฝังอยู่ในโปรเซสเซอร์ซึ่งโปรเซสเซอร์สามารถเข้าถึงได้ทันที eax register เรียกว่า accumulator ในโปรเซสเซอร์ส่วนใหญ่

ADD eax, 42 รหัสแอสเซมบลีออกแบบมาเพื่อเพิ่ม 42 ให้กับค่าปัจจุบันของ eax register (accumulator) และเก็บผลรวมใน eax . มันคือ eax = eax + 42 .

สมมุติว่าตอนนี้ eax คือ 20 ซึ่งหมายความว่าค่าของ eax หลังจากรัน ADD eax, 42 จะเท่ากับ 20 + 42 =62

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

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

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

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

วิธีการทำงานของระบบไบนารี

ถ้าฉันบอกให้อ่าน 872500 คุณอาจจะพูดว่า 872.5K . มาดูกันว่าจิตใจของเราทำแบบนี้ได้อย่างไร

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

พลังของ 10 เหล่านี้ในแต่ละสถานที่คือน้ำหนักของสถานที่ น้ำหนักของตำแหน่งที่ร้อยคือหนึ่งร้อย เราคูณตัวเลขในแต่ละตำแหน่งด้วยน้ำหนักของสถานที่ แล้วรวมเข้าด้วยกันเพื่อให้ได้จำนวนเต็ม

ในแผนภาพด้านบน คุณจะเห็นว่าน้ำหนักของสถานที่แต่ละแห่งเพิ่มขึ้นเป็นยกกำลัง 10 โดยเริ่มจาก 10^0 และผ่าน 10^5 . ทศนิยมจึงเรียกว่าระบบฐานสิบ

ในเลขฐานสอง น้ำหนักของสถานที่แต่ละแห่งจะเพิ่มขึ้นเป็น 2 ยกกำลัง ซึ่งหมายความว่าน้ำหนักของสถานที่นั้นเริ่มจาก 2^0 และสิ้นสุดที่ 2^something . นั่นคือความแตกต่างเท่านั้น

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

วิธีเพิ่ม 1 และ 0

การบวกทำงานในรูปแบบไบนารีในลักษณะเดียวกับที่ทำในทศนิยม ลองดูว่าผ่านตัวอย่าง เราจะบวกเลขฐานสองสองตัว:1101 (13) และ 1100 (12).

อย่างที่เราทำในระบบทศนิยม เราเริ่มจากตำแหน่งเดิม (2^0 ). การบวก 1 กับ 0 ทำให้เราได้ 1 เราจึงใส่ 1 ลงไป อยู่กับฉันแล้วคุณจะได้ภาพทั้งหมด

0 บวก 0 คือ 0 ก้าวต่อไป

1 บวก 1 ได้ 2 และ 2 ในไบนารีจะแสดงเป็น 10 . เรานำ 1 ไปที่ตำแหน่งถัดไปและเก็บ 0 จากตำแหน่งปัจจุบันที่เราอยู่ นี่ไม่เหมือนกับการบวกเลขทศนิยมที่เกิน 9 หรือไม่?

เรามี 1 สองตัวที่นั่น และ 1 ตัวที่ยกไปข้างหน้าจากตำแหน่งก่อนหน้า ดังนั้นจึงมี 1 ทั้งหมดสามตัว ผลรวมของพวกเขาจะเป็น 3 และในไบนารี 3 คือ 11 เราก็เลยเขียน 11 . ผลสุดท้ายออกมาเป็น 11001 หรือ 25 ในรูปทศนิยม ซึ่งก็คือ 13 + 12 นั่นเอง

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

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

ความงามของการออกแบบเลขคณิตแบบไบนารี

คำศัพท์สำคัญสองคำที่เราต้องทำความเข้าใจก่อนดำเนินการต่อคือส่วนที่มีนัยสำคัญน้อยที่สุด และ ส่วนที่สำคัญที่สุด .

บิตที่ ขวาสุดคือบิตที่มีนัยสำคัญน้อยที่สุด เพราะมันมีน้ำหนักน้อยที่สุด (2^0 ). และบิตที่ ซ้ายสุดคือบิตที่สำคัญที่สุด เนื่องจากมีน้ำหนักสูงสุด (2^7 )

หากโลกมีเพียงจำนวนบวก นี่คงเป็นจุดสิ้นสุดของบทความนี้ (เพราะเราได้เรียนรู้วิธีแสดงทศนิยมเป็นเลขฐานสองแล้วและวิธีบวกเลขฐานสองด้วย)

โชคดีที่เรามีตัวเลขติดลบด้วย

ความสวยงามของการออกแบบทางคณิตศาสตร์ของ CPU นั้นอยู่ในแง่ลบ

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

โปรดทราบว่าในส่วนด้านล่าง เราจะทำงานกับคอมพิวเตอร์ 4 บิตเพื่อทำความเข้าใจแนวคิด หมายความว่าบิตที่ 5 จะถือว่าเป็นโอเวอร์โฟลว์ หลักการเดียวกันนี้ใช้กับสถาปัตยกรรม CPU ทั้งหมด เช่น 16 บิต 32 บิต หรือ 64 บิตเพื่อทำการคำนวณ

แนวทางการเข้ารหัสขนาดสัญญาณ

1101 ในรูปแบบทศนิยมจะเป็น -5 ในรูปแบบการเข้ารหัสนี้ บิตซ้ายสุดหรือสำคัญที่สุดคือบิตเครื่องหมาย มันบอกโปรเซสเซอร์เกี่ยวกับเครื่องหมายของตัวเลข นั่นคือ ไม่ว่าตัวเลขจะเป็นบวกหรือลบ

0 ในเครื่องหมายบิตแสดงถึงค่าบวกและ 1 แสดงถึงค่าลบ บิตที่เหลือบอกเราถึงขนาดที่แท้จริง

ใน 1101 บิตเครื่องหมายคือ 1 ดังนั้นจำนวนจึงเป็นลบ 101 เท่ากับ 5 ในทศนิยม ดังนั้น 1101 จะคำนวณเป็น -5 เป็นทศนิยม

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

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

ลองบวกจำนวนบวกและลบ ตัวอย่างเช่น เราจะเพิ่ม +4 และ -1 คำตอบของเราควรเป็น (+4) + (-1) = (+3) นั่นคือ 0011 .

ดูสิ ผลลัพธ์คือ 1101 (-5). คำตอบที่แท้จริงควรเป็น 0011 (+3). หากเราใช้แนวทางนี้กับโปรเซสเซอร์ เราจะต้องเพิ่มตรรกะเพื่อจัดการกับปัญหานี้ และวิศวกรเกลียดความซับซ้อนเพิ่มเติมในตรรกะของพวกเขา

เมื่อเราเพิ่มวงจรมากขึ้น การใช้พลังงานก็เพิ่มขึ้นและประสิทธิภาพลดลง

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

แต่ลองนึกถึงคอมพิวเตอร์ยุคแรกๆ อย่าง EDVAC ซึ่งใช้หลอดสุญญากาศหลายพันหลอดซึ่งกินไฟเป็นกิโลวัตต์ซึ่งควบคุมโดยคนหลายร้อยคนต่อวัน และรัฐบาลใช้เงินหลายล้านเพื่อสร้างมันขึ้นมา

ในสมัยนั้นการเพิ่มวงจรและหลอดสูญญากาศหมายถึงหลายพันดอลลาร์และปัญหาการบำรุงรักษาที่ร้ายแรง

ดังนั้นวิศวกรจึงต้องนึกถึงการออกแบบการเข้ารหัสที่ชาญฉลาดยิ่งขึ้น

ถึงเวลาแล้วที่จะเปิดเผยความงามที่จะจัดการกับปัญหานี้และทำให้ระบบของเราง่ายขึ้น มีประสิทธิภาพมากขึ้น และใช้พลังงานน้อยลง

ระบบเข้ารหัสที่สวยงามเข้ามาและ CPU ส่องแสง ❤️

ในรูปแบบการเข้ารหัสนี้ เช่นเดียวกับในก่อนหน้านี้ บิตซ้ายสุดทำหน้าที่เป็นบิตสัญญาณ แต่มีศิลปะบางส่วนที่เกี่ยวข้องกับการแสดงตัวเลขติดลบ

ตัวเลขบวกจะแสดงในลักษณะเดียวกับรูปแบบการเข้ารหัสก่อนหน้า:0 นำหน้า ตามด้วยบิตที่เหลือสำหรับขนาด ตัวอย่างเช่น ในรูปแบบการเข้ารหัสนี้ด้วย 6 จะถูกแสดงเป็น 0110 .

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

มาดูกันว่า -6 จะเข้ารหัสเป็นไบนารีอย่างไร:

ในแนวทางขนาดเครื่องหมายก่อนหน้า ในการคำนวณค่าลบของ +6 เราจะเปลี่ยนบิตเครื่องหมายจาก 0 ถึง 1 . 0110 (+6) จะกลายเป็น 1110 (-6).

ในรูปแบบการเข้ารหัสใหม่นี้ ก่อนอื่นเราจะกลับบิต การเปลี่ยนศูนย์เป็นหนึ่งและศูนย์เป็นศูนย์ 0110 (+6) กลายเป็น 1001 . การกลับบิตเรียกว่า "ส่วนเติมเต็ม" ดังนั้นเราได้คำนวณส่วนเติมเต็มของ 0110 ส่งผลให้ 1001 . แล้ว...

เราเพิ่ม 0001 (+1) ไปยังส่วนเติมเต็มที่เราได้รับจากขั้นตอนที่หนึ่ง (1001 ). ผลลัพธ์ 1010 จะเป็นเลขฐานสองของ -6 รูปแบบการเข้ารหัสนี้เรียกว่าส่วนเติมเต็มของสอง ดังนั้น พึงระลึกไว้เสมอว่าการคำนวณส่วนประกอบสองส่วนของจำนวนเต็มบวกจะทำให้มีค่าเท่ากับลบ

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

ตอนนี้เรามาดูกันว่าทำไมรูปแบบการเข้ารหัสนี้จึงสวยงาม เราจะเพิ่ม 0100 (+4) และ 1111 (-1).

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

เราได้เรียนรู้วิธีแสดงจำนวนเต็มลบใน 0 และ 1 ผ่านการเข้ารหัสเสริมของสองตัว สมมติว่าเรารัน ADD eax, -3 และค่าปัจจุบันในการลงทะเบียน eax คือ -1 ดังนั้นค่าใน eax หลังจากดำเนินการ ADD eax, -3 จะเป็น -4 (ซึ่งก็คือ 1100 ในการเข้ารหัสเสริมสอง)

เมื่อระบบปฏิบัติการดึง 1100 จาก eax มาแสดงผลให้ผู้ใช้เห็น ระบบปฏิบัติการถอดรหัส 1100 . อย่างไร เป็นทศนิยม? หรือสมมุติว่าเราเป็นโปรแกรมเมอร์เจอ 1100 เราจะรู้ได้อย่างไรว่าตัวเลข 1100 แสดงถึง?

แน่นอน เราไม่สามารถคำนวณส่วนเสริมของจำนวนเต็มบวกแต่ละตัวของสองตัวต่อไปเพื่อดูว่าเรากด 1100 เมื่อใด . นั่นจะช้าเกินไป

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

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

ก่อนอื่น เรามาทำความเข้าใจว่า OS หรือโปรแกรมเมอร์จะถอดรหัส 1100 . อย่างไร ให้เป็นทศนิยม

ในการดึง 1100 จากการลงทะเบียน eax ระบบปฏิบัติการจะเห็น 1 เป็นบิตเครื่องหมายที่ส่งสัญญาณว่าจำนวนเต็มเป็นลบ ส่วนเติมเต็มของ 1100 เป็นการคำนวณที่ให้ผลบวกของ 1100 ซึ่งออกมาเป็น 0100 (+4). จากนั้น OS จะใส่เครื่องหมายลบนำหน้าค่าบวกและคืนค่าคำตอบสุดท้ายเป็น -4 อ่านย่อหน้านี้อีกครั้งแล้วคุณจะเข้าใจมากขึ้น

แล้วซีพียูก็ยิ้มบอกลาความสวยของวันนี้;)

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

ทำไมและอย่างไรที่การเข้ารหัสเสริมทำงานอย่างไร

ถ้าฉันบอกคุณให้หาค่าลบของตัวเลข ให้พูดว่า +42 วิธีที่ง่ายที่สุดในการหาค่าลบของ +42 คืออะไร

วิธีที่ง่ายที่สุดคือการลบตัวเลขออกจาก 0 ใช่ไหม 0 - (+42) = -42 . หากทำซ้ำ เราจะกลับไปเป็นค่าบวก 0 - (-42) = +42 . นี่คือคณิตศาสตร์ทั้งหมดที่สร้างขึ้นจากการเติมเต็มของทั้งสอง

เรากำลังดำเนินการ 10000 (0 เป็นทศนิยมเนื่องจาก 1 ซ้ายสุดโอเวอร์โฟลว์) ลบ 0101 (+5). เราได้ 1011 นั่นคือ -5 เป็นทศนิยมในการเข้ารหัสเสริมของสอง ไม่ต้องสนใจวิธีการลบออก นั่นไม่สำคัญ การทำความเข้าใจสัญชาตญาณเบื้องหลังการเติมเต็มของทั้งสองเป็นสิ่งสำคัญ

10000 สามารถเขียนเป็น 1111 + 0001 (ลองเพิ่มสองตัวนี้เข้าไปจะได้ 10000 ). ที่จริงแล้วเรากำลังทำอยู่:

        10000       -   0101
=>  (1111 + 0001)   -   0101

การจัดเรียงสมการข้างต้นใหม่ เราสามารถเขียนได้ว่า:

    (1111 + 0001)  -  0101
=>  (1111 - 0101)  +  0001

Step 1: subtract 0101 from 1111

        1 1 1 1
       -0 1 0 1
       ---------
        1 0 1 0
        
       see, subtracting 0101 from 1111 is equivalent 
       to inverting the bits of 0101, as we got 1010 as a result. 

  
       
Step 2: add 0001 to the above result  

        1 0 1 0  ---> result of step 1
       +0 0 0 1
       ---------
        1 0 1 1      
       
       we get 1011 that is -5 in two's complement encoding.      

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

นี่คือเหตุผลที่เราได้รับค่าบวกของจำนวนลบและค่าลบของจำนวนบวกเมื่อเราคำนวณส่วนประกอบสองส่วน เนื่องจากเรากำลังลบตัวเลขออกจาก 0 (0 - number ).

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

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

ทำไมเราไม่ลบ 0 โดยตรงเพื่อหาค่าลบของตัวเลขหรือในทางกลับกันในไบนารี?

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

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

ดังนั้นขอชื่นชมนักออกแบบคอมพิวเตอร์ของเราสำหรับรูปแบบการเข้ารหัสที่สวยงาม – ส่วนเติมเต็มของทั้งสอง ❤️

คำสุดท้าย

ฉันสัญญากับตัวเองว่าจะไม่คิดค่าใช้จ่ายสำหรับสื่อการเรียนรู้ใดๆ ที่ฉันผลิต อะไรก็ตามที่ฉันทำเพื่อการศึกษา ไม่ว่าจะเป็นบทความง่ายๆ หรือหลักสูตร หรือ ebook จะเป็นฟรี 100% และเปิดกว้างเสมอ

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

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

Animesh ของ mycodeschool สอนแนวคิดการเขียนโปรแกรมให้ฉันมากมายได้ดีกว่าใครๆ รวมถึงแนวคิดที่ฉันเขียนในบทความนี้ด้วย

André Jaenisch ที่ปรึกษาและเพื่อนของฉัน หากปราศจากความพยายามในการทบทวนและการสนับสนุนอย่างต่อเนื่อง ฉันจะไม่เขียนบทความนี้

มีความสุขในการเรียนรู้!