বাইনারি গণিত — যোগ, বিয়োগ, 1's আর 2's complement

১ · কম্পিউটার কীভাবে হিসাব করে — দুই অঙ্কের গণিত

পর্ব ১৬-তে দেখেছেন, কম্পিউটারের ভেতরে সব সংখ্যা লেখা হয় binary-তে — শুধু 0 আর 1 দিয়ে। কারণ একটি সুইচের দুটি অবস্থা সবচেয়ে নির্ভরযোগ্যভাবে চেনা যায়: বিদ্যুৎ আছে, অথবা নেই। কিন্তু শুধু লিখে রাখলে তো হবে না — কম্পিউটারের আসল কাজ হিসাব করা। bKash-এ টাকা পাঠালে ব্যালান্স থেকে বিয়োগ, মোবাইল রিচার্জ করলে যোগ, Excel-এ SUM — সব শেষ পর্যন্ত bit-এর যোগ-বিয়োগ।

সুখবর হলো, বাইনারি গণিত দশমিক গণিতের চেয়ে সহজ। স্কুলে নামতা মুখস্থ করতে হয়েছিল ১০০টি জোড়ার জন্য (০ থেকে ৯-এর সাথে ০ থেকে ৯)। বাইনারিতে অঙ্ক মাত্র দুটি, তাই যোগের নামতায় জোড়া মাত্র চারটি। পুরো পর্বটি এই চার নিয়মের ওপর দাঁড়িয়ে।

এই তিনটি ধারণাই HSC ICT-র তৃতীয় অধ্যায়ের গণিত অংশের মূল, আর চাকরির পরীক্ষার কম্পিউটার অংশেও বারবার আসে। কিন্তু শুধু পরীক্ষার জন্য নয় — বাইনারি গণিত বুঝলে বুঝবেন কেন একটি পুরোনো গেমে স্কোর হঠাৎ ঋণাত্মক হয়ে যায়, কেন একটি রকেট আকাশে ভেঙে পড়েছিল, আর কেন ২০৩৮ সালে কিছু পুরোনো যন্ত্রের ঘড়ি পিছিয়ে যেতে পারে।

যোগের কাজটি করে CPU-র ভেতরের ALU, আর তার ভেতরে থাকে একটি adder সার্কিট। Adder কীভাবে logic gate দিয়ে বানানো হয়, তা দেখবেন পর্ব ২১-এ। এই পর্বে আমরা খাতা-কলমে সেই একই হিসাব করব — adder যা করে, আপনি হাতে তা-ই করবেন।

২ · বাইনারি যোগ — “হাতে ১” আর 1 + 1 + 1

প্রথমে চারটি মৌলিক নিয়ম। দুটি bit যোগ করলে ফল হয় দুই অংশে: একটি যোগফল bit (যা ওই কলামেই লেখা হয়) আর একটি carry (হাতে থাকা অঙ্ক, যা বাঁয়ের কলামে যায়)।

শেষ সারিটি খুব জরুরি, আর পরীক্ষায় সবচেয়ে বেশি আসে। কোনো কলামে দুটি 1 থাকলে, আর ডান দিক থেকে আরেকটি carry এলে, যোগ হয় তিনটি 1 — দশমিকে ৩, বাইনারিতে 11. অর্থাৎ কলামে লিখুন 1, হাতে 1. দশমিকে যেমন ৭ + ৮ = ১৫ হলে “৫ লিখি, হাতে ১”, ঠিক তেমন। দশমিকে হাতে যায় ১০ পূর্ণ হলে; বাইনারিতে ২ পূর্ণ হলেই।

এখন একটি পুরো যোগ: 1011 (দশমিকে ১১) আর 0111 (দশমিকে ৭)। খাতায় যেমন করেন — দুটি সংখ্যা ওপর-নিচে, ডান দিক থেকে শুরু। “পরের ধাপ” চেপে দেখুন প্রতিটি কলামে কী হয়:

1  A =   1 0 1 1   (11)2  B = + 0 1 1 1   (7)3কলাম ১: 1+1   = 10 → 0, হাতে 14কলাম ২: 1+1+1 = 11 → 1, হাতে 15কলাম ৩: 0+1+1 = 10 → 0, হাতে 16কলাম ৪: 1+0+1 = 10 → 0, হাতে 17শেষের হাতের 1 নামান → 10010

আরও দুটি উদাহরণ, আর তিনটি সংখ্যার যোগ

  হাতে:   1 1 1 1 1          হাতে:  1 1 1 1
          1 1 0 1 1   (27)           0 1 1 1 1   (15)
        + 0 1 1 0 1   (13)         + 0 0 0 0 1   (1)
        -----------                 -----------
        1 0 1 0 0 0   (40)           1 0 0 0 0   (16)

ডানের উদাহরণে দেখুন, একটি carry কীভাবে “ঢেউয়ের মতো” বাঁ দিকে গড়িয়ে যায় — 01111-এর সাথে 1 যোগ করলে প্রতিটি কলামে 1 + 1 হয়, প্রত্যেকে পরের জনকে carry দেয়। দশমিকে ৯৯৯ + ১ = ১০০০-এর মতোই। হার্ডওয়্যারে এই গড়িয়ে যাওয়াই ripple carry — বড় সংখ্যায় এটি সময় নেয়, পর্ব ২১-এ এর সমাধানও উঁকি দেবে।

তিনটি সংখ্যা একসাথে যোগ করতে হলে সবচেয়ে নিরাপদ পথ: প্রথম দুটি যোগ করুন, তারপর ফলের সাথে তৃতীয়টি। এক কলামে চারটি 1 এলে (যেমন 1+1+1+1 = ৪ = 100) carry একসাথে দুই কলাম দূরে যায় — হাতে হিসাব রাখা কঠিন, তাই পরীক্ষায় ধাপে ধাপে করাই ভালো।

৩ · বাইনারি বিয়োগ (borrow), গুণ আর ভাগ

সরাসরি বিয়োগ — “ধার করা”

বিয়োগেরও চারটি নিয়ম। ঝামেলা শুধু একটিতে: 0 থেকে 1 বিয়োগ। তখন বাঁয়ের কলাম থেকে ধার নিতে হয় — একে বলে borrow. দশমিকে বাঁয়ের ঘর থেকে ১ ধার আনলে এই ঘরে ১০ যোগ হয়; বাইনারিতে আসে ২ (অর্থাৎ 10), আর 10 − 1 = 1.

  1 0 1 0   (10)          1 0 0 0 0   (16)
− 0 0 1 1   (3)         − 0 0 0 0 1   (1)
---------               -----------
  0 1 1 1   (7)           0 1 1 1 1   (15)

বাঁয়ের উদাহরণ, ডান দিক থেকে: প্রথম কলামে 0 − 1, তাই পাশের 1 থেকে ধার — ফল 1, আর পাশের কলামের 1 হয়ে গেল 0. দ্বিতীয় কলামে এখন 0 − 1, আবার ধার — তৃতীয় কলাম থেকে, যেখানে আছে 0; তাই ধার যায় আরও এক ঘর বাঁয়ে। ডানের উদাহরণে (১৬ − ১) ধারটি চারটি 0 পেরিয়ে সবার বাঁয়ের 1 থেকে আসে, আর পথের প্রতিটি 0 হয়ে যায় 1 — দশমিকে ১০০০০ − ১ = ৯৯৯৯-এর মতো।

গুণ — সরানো আর যোগ করা (shift-and-add)

বাইনারি গুণের নামতা আরও ছোট: 0×0 = 0, 0×1 = 0, 1×0 = 0, 1×1 = 1. অর্থাৎ গুণকের প্রতিটি bit হয় 0 (তাহলে কিছু যোগ হয় না), নয়তো 1 (তাহলে গুণ্য সংখ্যাটি নিজেই, এক ঘর করে বাঁয়ে সরানো)। দশমিকে ১০ দিয়ে গুণ মানে শেষে একটি শূন্য বসানো; বাইনারিতে শেষে 0 বসানো মানে ২ দিয়ে গুণ। নিচে ১৩ × ৫:

        1 1 0 1      (13)
      ×   1 0 1      (5)
      ---------
        1 1 0 1      ← গুণকের ডানের bit 1: 1101 যেমন আছে
      0 0 0 0 ·      ← মাঝের bit 0: সব শূন্য, এক ঘর সরানো
  1 1 0 1 · ·        ← বাঁয়ের bit 1: 1101, দুই ঘর সরানো
  -------------
  1 0 0 0 0 0 1      (65)  ✓ ১৩ × ৫ = ৬৫

CPU-র ভেতরের সাধারণ গুণের পদ্ধতিও এই: shift (সরানো) আর add (যোগ)। আধুনিক CPU অনেকগুলো আংশিক যোগফল একসাথে যোগ করার বিশেষ সার্কিট দিয়ে কাজটি দ্রুত সারে, কিন্তু মূল ধারণা একই।

ভাগ — বারবার বিয়োগ

বাইনারি ভাগ দশমিকের লম্বা ভাগের (long division) মতো, শুধু সহজতর — প্রতিটি ধাপে ভাজক “যায়” (ভাগফলে 1) অথবা “যায় না” (ভাগফলে 0); অনুমান করার কিছু নেই। যেমন 1100 (১২) ÷ 100 (৪): প্রথম তিন অঙ্ক 110 থেকে 100 বিয়োগ করা যায় → ভাগফলে 1, ভাগশেষ 10; পরের অঙ্ক নামিয়ে 100 → আবার যায় → 1, ভাগশেষ 0. ভাগফল 11 = ৩ ✓. আর ২ দিয়ে ভাগ মানে ডান দিকে এক ঘর সরানো — দশমিকে ১০ দিয়ে ভাগের মতো।

৪ · ঋণাত্মক সংখ্যা — sign-magnitude, 1's আর 2's complement

কাগজে ঋণাত্মক সংখ্যা লিখতে সামনে “−” চিহ্ন বসাই। কিন্তু register-এ আছে শুধু 0 আর 1 — “−” রাখার আলাদা জায়গা নেই। তাই একটি bit-কেই চিহ্নের কাজে লাগাতে হয়। যে সংখ্যায় ধনাত্মক-ঋণাত্মক দুটোই রাখা যায়, তাকে বলে signed number; যেখানে শুধু ০ ও ধনাত্মক — unsigned. চিহ্নের কাজ করে সবার বাঁয়ের bit, যার নাম MSB (Most Significant Bit); আর সবার ডানের bit হলো LSB. ইতিহাসে তিনটি পদ্ধতি চালু হয়েছিল। নিচে ৮ bit ধরে দেখি।

পদ্ধতি ১: Sign-magnitude — চিহ্ন আর মান আলাদা

সবচেয়ে সহজ ভাবনা: MSB হবে চিহ্ন (0 = ধনাত্মক, 1 = ঋণাত্মক), বাকি ৭ bit সংখ্যার মান। তাই +5 = 0000 0101, −5 = 1000 0101. এই পদ্ধতির নাম sign-magnitude. পড়তে সহজ, কিন্তু দুটি বড় সমস্যা। এক, শূন্য দুটি: 0000 0000 (+0) আর 1000 0000 (−0). দুই, সাধারণ যোগ কাজ করে না — +5 আর −5 সরাসরি যোগ করলে আসে 1000 1010 = −10, অথচ উত্তর হওয়ার কথা ০. যোগের আগে চিহ্ন দেখে আলাদা নিয়ম চালাতে হয়।

পদ্ধতি ২: 1's complement — সব bit উল্টে দিন

ঋণাত্মক সংখ্যা পেতে ধনাত্মক রূপের প্রতিটি bit উল্টে দিন — 0 হবে 1, 1 হবে 0. এটিই 1's complement (এক-এর পরিপূরক)। +5 = 0000 0101 হলে −5 = 1111 1010. MSB এখানেও চিহ্ন বোঝায়। যোগ প্রায় কাজ করে — শুধু শেষ carry এলে সেটিকে ঘুরিয়ে আবার ডানে যোগ করতে হয় (end-around carry, অংশ ৫)। কিন্তু শূন্য এখনো দুটি: 0000 0000 (+0) আর 1111 1111 (−0).

পদ্ধতি ৩: 2's complement — উল্টে দিন, তারপর ১ যোগ

1's complement-এর সাথে 1 যোগ করলে পাওয়া যায় 2's complement (দুই-এর পরিপূরক)। −5 = 1111 1010 + 1 = 1111 1011. আজকের প্রায় সব কম্পিউটার, ফোন আর মাইক্রোকন্ট্রোলার ঋণাত্মক পূর্ণসংখ্যা এভাবেই রাখে। কারণ এতে শূন্য একটিই, আর সাধারণ যোগই কোনো বাড়তি নিয়ম ছাড়া সঠিক উত্তর দেয়।

খেয়াল করুন: ধনাত্মক সংখ্যা তিন পদ্ধতিতেই হুবহু এক। পার্থক্য শুধু ঋণাত্মকে। আর 2's complement-এ −0-এর জায়গাটি খালি হয়নি — সেই bit-নকশা 1000 0000 পেয়েছে একটি বাড়তি সংখ্যা: −128. এ জন্যই 8-bit-এ ঋণাত্মক দিকে একটি সংখ্যা বেশি — −128 থেকে +127, মোট ২৫৬টি মান। ১৬ bit-এ সীমা −32,768 থেকে +32,767, আর ৩২ bit-এ −2,147,483,648 থেকে +2,147,483,647 — এই সংখ্যাটি অংশ ৮-এ আবার দেখবেন।

2's complement বের করার দুটি পথ

• পাঠ্যবইয়ের পথ: সংখ্যাটি নির্দিষ্ট bit-এ লিখুন → সব bit উল্টান (1's complement) → 1 যোগ করুন। −৬৫: 0100 0001 → 1011 1110 → 1011 1111.
• দ্রুত পথ (shortcut): ডান দিক থেকে পড়ুন। প্রথম 1 পর্যন্ত (সেই 1 সহ) সব যেমন আছে লিখুন, তারপরের সব bit উল্টে দিন। 0100 0001-এ প্রথম 1 সবার ডানেই — সেটি রেখে বাকিগুলো উল্টালে 1011 1111. একই উত্তর, অর্ধেক সময়ে। পরীক্ষায় উত্তর মিলিয়ে নিতে কাজে লাগে।

MSB কেন চিহ্ন — আর ঋণাত্মক সংখ্যার দশমিক মান

2's complement-এর সবচেয়ে সুন্দর ব্যাখ্যা: MSB-এর ওজন ঋণাত্মক। 8-bit-এ সাধারণত ঘরগুলোর ওজন ১২৮, ৬৪, ৩২, ১৬, ৮, ৪, ২, ১. 2's complement-এ বাঁয়ের ঘরের ওজন +১২৮ নয়, −১২৮. বাকিগুলো আগের মতো। তাহলে 1111 1011 = −১২৮ + ৬৪ + ৩২ + ১৬ + ৮ + ০ + ২ + ১ = −১২৮ + ১২৩ = −৫. বাকি সাত ঘর মিলে সর্বোচ্চ +১২৭ হতে পারে, যা ১২৮-এর চেয়ে ছোট — তাই MSB 1 হলেই পুরো সংখ্যা ঋণাত্মক। MSB আলাদা কোনো “চিহ্ন” নয়; সে নিজেই একটি ঋণাত্মক ওজনের অঙ্ক, আর সে কারণেই চিহ্নের কাজ করে।

অন্য পথ: পুরো bit-নকশাকে সাধারণ (unsigned) সংখ্যা হিসেবে পড়ে ২৫৬ বিয়োগ করুন — 1111 1011 = ২৫১, আর ২৫১ − ২৫৬ = −৫. আর তৃতীয় পথ, পাঠ্যবইয়ে যেটি বেশি দেখা যায়: MSB 1 দেখলে পুরো সংখ্যার আবার 2's complement নিন — 0000 0101 = ৫ — তারপর সামনে “−” বসান।

৫ · Complement দিয়ে বিয়োগ — যোগ করেই বিয়োগ

এবার আসল জাদু। A − B করতে হবে? B-এর 2's complement নিন (অর্থাৎ −B), তারপর A-এর সাথে যোগ করুন। ৮ bit পেরিয়ে নবম bit-এ কোনো carry এলে সেটি ফেলে দিন। কোনটি বড় তুলনা করার দরকার নেই, borrow-এর ঝামেলা নেই। নিচে ৯ − ৫, 8-bit-এ:

19 = 0000 1001,  5 = 0000 010125-এর bit উল্টাই → 1111 101031 যোগ → 1111 1011  (= −5)4  0000 10015+ 1111 10116= 1 0000 01007নবম bit বাদ → 0000 0100 = 4

ফল যখন ঋণাত্মক — ৫ − ৯

এবার উল্টো: ৫ − ৯. −৯ = ৯ (0000 1001)-এর 2's complement = 1111 0111. যোগ: 0000 0101 + 1111 0111 = 1111 1100. এবার নবম bit-এ কোনো carry নেই, আর MSB 1 — অর্থাৎ ফল ঋণাত্মক, আর সংখ্যাটি নিজেই 2's complement রূপে আছে। মান জানতে আবার 2's complement নিন: 1111 1100 → উল্টে 0000 0011 → +1 → 0000 0100 = ৪. সুতরাং উত্তর −৪ ✓.

1's complement দিয়ে বিয়োগ — end-around carry

1's complement পদ্ধতিতেও যোগ করেই বিয়োগ, শুধু একটি পার্থক্য: নবম bit-এ carry এলে সেটি ফেলে দেওয়া হয় না, বরং ঘুরিয়ে এনে ফলের ডানের bit-এ যোগ করা হয়। একে বলে end-around carry. কেন? কারণ 1's complement-এ −B আসলে (2ⁿ − 1) − B, অর্থাৎ 2's complement-এর চেয়ে এক কম; সেই হারানো ১-টি ফেরত দেয় end-around carry. নিচে আবার ৯ − ৫:

দুই পদ্ধতি পাশাপাশি মনে রাখুন: 1's complement → carry এলে ঘুরিয়ে যোগ; 2's complement → carry এলে বাদ। দুই ক্ষেত্রেই carry না এলে ফল ঋণাত্মক, আর মান পেতে সেই পদ্ধতিরই complement আবার নিতে হয়। AI চ্যাটবট আর অনেক শিক্ষার্থী ঠিক এখানেই গুলিয়ে ফেলে — দুই নিয়ম মিশিয়ে দেয়।

৬ · Overflow আর carry — ঘরে না ধরলে কী হয়

8-bit signed register-এ সর্বোচ্চ +127. এখন ১০০ + ৫০ = ১৫০ — যা ঘরে ধরে না। কম্পিউটার কি থেমে যায়? না। যোগের সার্কিট নিয়ম মেনে যোগ করে, আর ফল আসে একটি ভুল সংখ্যা। একে বলে overflow. নিচে দেখুন কী হয়:

1100 = 0110 0100  (MSB 0, ধনাত্মক)2 50 = 0011 0010  (MSB 0, ধনাত্মক)3যোগ = 1001 0110  (unsigned 150)4signed পড়া: −128 + 22 = −106 !5MSB-তে ঢোকা carry = 16MSB থেকে বেরোনো carry = 071 ≠ 0 → Overflow (V = 1)

Carry আর overflow — এক জিনিস নয়

নবম bit-এ carry আসা মানেই ভুল নয়। ৯ + (−৫)-এ carry এসেছিল, অথচ উত্তর সঠিক। আসলে একই bit-নকশা দুই ভাবে পড়া যায়, আর দুই পড়ার জন্য দুই আলাদা সতর্কসংকেত:

সহজ একটি সত্য মনে রাখুন: বিপরীত চিহ্নের দুটি সংখ্যা যোগ করলে কখনো overflow হয় না — ফল সবসময় দুটির মাঝামাঝি থাকে। Overflow শুধু একই চিহ্নের দুটি সংখ্যার যোগে সম্ভব।

CPU প্রতিটি হিসাবের পর কয়েকটি এক-bit সংকেত রাখে — একে বলে status flag: C (carry), V (overflow), Z (zero — ফল শূন্য কি না), আর S বা N (sign — ফলের MSB). প্রোগ্রাম এগুলো দেখে সিদ্ধান্ত নেয়; বিস্তারিত পর্ব ২৪-এ। নিচের ছোট JavaScript প্রোগ্রামটি একটি 8-bit ALU-র নকল — প্রতিটি কলাম আলাদা করে যোগ করে, আর চারটি flag দেখায়। “Run” চাপুন:

const b8 = n => (n & 255).toString(2).padStart(8, "0");
const sval = n => (n & 128) ? (n & 255) - 256 : (n & 255);
const twos = n => (~n + 1) & 255;          // উল্টাও, তারপর +1
function alu(a, b, label) {
  let carry = 0, cin7 = 0, out = 0, row = "";
  for (let i = 0; i < 8; i++) {            // ডান থেকে বাঁয়ে, এক কলাম করে
    const s = ((a >> i) & 1) + ((b >> i) & 1) + carry;
    if (i === 7) cin7 = carry;             // MSB-তে ঢোকা carry
    out |= (s & 1) << i;
    carry = s >> 1;
    row = carry + row;
  }
  console.log(label + "\n   carry : " + row);
  console.log("  ", b8(a), "+", b8(b), "=", b8(out));
  console.log("   signed =", sval(out), "| C =", carry,
    "V =", cin7 !== carry ? 1 : 0, "Z =", out === 0 ? 1 : 0, "S =", out >> 7);
}
console.log("2's complement of 5:", b8(5), "-> flip", b8(~5), "-> +1", b8(twos(5)));
alu(11, 7, "1) 11 + 7");
alu(9, twos(5), "2) 9 - 5  =  9 + (-5)");
alu(5, twos(9), "3) 5 - 9  =  5 + (-9)");
alu(100, 50, "4) 100 + 50 (signed 8-bit)");

৭ · অক্টাল আর হেক্সাডেসিমাল যোগ — একই নিয়ম, অন্য সীমা

যোগের নিয়মটি আসলে সব সংখ্যা পদ্ধতিতে একই: কলামের যোগফল ভিত্তি (base) ছুঁলে বা ছাড়ালে ভিত্তি বিয়োগ করে লিখুন, হাতে ১. দশমিকে ভিত্তি ১০, বাইনারিতে ২, অক্টালে ৮, হেক্সাডেসিমালে ১৬. পর্ব ১৬-এর রূপান্তর জানা থাকলে এই অংশ খুব সহজ।

অক্টাল (ভিত্তি 8)                 হেক্সাডেসিমাল (ভিত্তি 16)
  হাতে:  1 1                       হাতে:  1 1
           5 7   (৪৭)                       9 A   (১৫৪)
         + 2 6   (২২)                     + 7 C   (১২৪)
         -----                            -----
         1 0 5   (৬৯) ✓                   1 1 6   (২৭৮) ✓

7 + 6 = 13 → 13 − 8 = 5, হাতে 1     A + C = 10 + 12 = 22 → 22 − 16 = 6, হাতে 1
5 + 2 + 1 = 8 → 8 − 8 = 0, হাতে 1    9 + 7 + 1 = 17 → 17 − 16 = 1, হাতে 1

হেক্সে সবচেয়ে বেশি ভুল হয় অক্ষর-অঙ্কে — মনে রাখুন A = ১০, B = ১১, C = ১২, D = ১৩, E = ১৪, F = ১৫. কলামের যোগ ১০ থেকে ১৫-র মধ্যে হলে অক্ষরটি লিখুন (যেমন 7 + 8 = ১৫ = F), carry নেই। নিশ্চিত হতে চাইলে দুই সংখ্যাকে বাইনারিতে বদলে যোগ করে আবার হেক্সে ফিরুন — উত্তর একই আসবে। প্রোগ্রামাররা মেমরির ঠিকানা আর রঙের কোড (যেমন #1E90FF) নিয়ে কাজের সময় হেক্স যোগ-বিয়োগ প্রায়ই করেন।

৮ · বাস্তব জীবনে overflow — আর 2's complement কেন জিতল

Overflow শুধু পরীক্ষার অঙ্ক নয়। সফটওয়্যারের ইতিহাসে এটি বহুবার টাকা, সময় আর কখনো কখনো আস্ত যন্ত্র নষ্ট করেছে। তিনটি বিখ্যাত ঘটনা — বিস্তারিত ভাবনার প্রশ্নে।

তিনটি গল্পের শিক্ষা একই: সংখ্যার ঘর বাছাইয়ের সময় ভাবুন, ভবিষ্যতে মান কত বড় হতে পারে। আর প্রোগ্রাম overflow হলে চুপচাপ ভুল চালিয়ে যাবে, নাকি থেমে সতর্ক করবে — সেটিও নকশার সিদ্ধান্ত।

2's complement কেন সবার পছন্দ হলো

• একটিই adder: যোগ আর বিয়োগ একই সার্কিটে। বিয়োগের জন্য শুধু B-এর bit উল্টে (NOT gate) প্রথম কলামে carry-in 1 দিলেই হয় — “উল্টাও, +1” হার্ডওয়্যারে প্রায় বিনা খরচে।
• একটিই শূন্য: “ফল শূন্য কি না” পরীক্ষা মানে সব bit 0 কি না — দুই রকম শূন্য সামলানোর ঝামেলা নেই।
• End-around carry নেই: শেষ carry ফেলে দিলেই চলে, বাড়তি দ্বিতীয় যোগ লাগে না।
• Signed আর unsigned-এর জন্য একই যোগ: bit-স্তরে যোগটি একই; শুধু ফল পড়ার নিয়ম আর দেখার flag আলাদা (C না V).

এ কারণে ১৯৬০-এর দশক থেকে ধীরে ধীরে প্রায় সব নতুন কম্পিউটার 2's complement বেছে নেয়, আর আজ C ভাষার সাম্প্রতিক মান (C23) আর C++20 signed পূর্ণসংখ্যার জন্য 2's complement বাধ্যতামূলক করেছে — অন্য পদ্ধতির যন্ত্র প্রায় আর নেই বললেই চলে।

৯ · AI-এর যুগে — বাইনারি হিসাব যাচাই করুন

বাইনারি অঙ্কে AI চ্যাটবট খুব আত্মবিশ্বাসী ব্যাখ্যা দেয়, কিন্তু হিসাবে প্রায়ই ভুল করে — বিশেষ করে লম্বা bit-সারিতে, যেখানে একটি অঙ্ক এদিক-ওদিক হলেই পুরো উত্তর বদলে যায়। ভাষা মডেল অঙ্ক “হিসাব” করে না, অনেকটা “অনুমান” করে লেখে। তাই AI-কে শিক্ষক হিসেবে ব্যবহার করুন, কিন্তু উত্তর নিজে যাচাই করুন।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• সব সংখ্যা প্রশ্নে বলা একই bit-এ (যেমন ৮ bit) লেখা হয়েছে
• 1's complement-এ শুধু উল্টানো, 2's complement-এ উল্টে +1 — দুটো গুলিয়ে যায়নি
• শেষ carry-র নিয়ম পদ্ধতি অনুযায়ী মানা হয়েছে (1's → ঘুরিয়ে যোগ, 2's → বাদ)
• ঋণাত্মক ফলের মান আবার complement নিয়ে পড়া হয়েছে
• উত্তরটি নিজে দশমিকে হিসাব করে মিলিয়েছি — এবং ফল সীমার (−128…+127) ভেতরে কি না দেখেছি

সবচেয়ে সহজ যাচাই: প্রতিটি বাইনারি সংখ্যাকে দশমিকে বদলে দেখুন (পর্ব ১৬-এর পদ্ধতিতে), হিসাবটি দশমিকে করুন, তারপর মিলান। এ পর্বের ALU প্রোগ্রামেও সংখ্যা বসিয়ে দেখতে পারেন — সেটি প্রতিটি কলাম সত্যিই হিসাব করে, অনুমান করে না।