Bitwise operator: এক বিট করে কাজ

Kenji-র একটা board-এ আটটা LED, আর ওগুলো চালানোর জন্য একটা byte। Bit 0 প্রথম বাতি, bit 7 শেষটা।

ও আটটা variable চায় না। ও একটা সংখ্যা চায়, আর তার ভিতরে হাত ঢোকানোর একটা উপায় চায়।

এই lesson-এ যা আছে সবই সেটাই: এমন অঙ্ক যেটা একটা সংখ্যাকে পরিমাণ না ধরে সুইচের সারি ধরে।

ছয়টা operator, যারা মানের উপর না, bit-র উপর চলে

Module 2-র lesson 2 বলেছিল একটা integer আসলে bit-র একটা নকশা। এই operator-গুলো সেটা মেনে নেয়।

a & b      and       দুই bit-ই 1 হলে bit হয় 1
a | b      or        অন্তত এক bit 1 হলে bit হয় 1
a ^ b      xor       দুই bit আলাদা হলে bit হয় 1
~a         not       প্রতিটা bit উল্টে যায়
a << n     left      প্রতিটা bit n ঘর উপরের দিকে সরে
a >> n     right     প্রতিটা bit n ঘর নিচের দিকে সরে

ছয়টাই দেখতে চার bit-ই যথেষ্ট। নাও 12, যেটা 1100, আর 10, যেটা 1010।

#include <stdio.h>

int main(void)
{
    unsigned int a = 12u;
    unsigned int b = 10u;

    printf("a & b  = %2u\n", a & b);
    printf("a | b  = %2u\n", a | b);
    printf("a ^ b  = %2u\n", a ^ b);
    printf("a << 1 = %2u\n", a << 1);
    printf("a >> 2 = %2u\n", a >> 2);
    printf("~a     = %u\n", ~a);
    return 0;
}

a & b  =  8
a | b  = 14
a ^ b  =  6
a << 1 = 24
a >> 2 =  3
~a     = 4294967283

শেষ লাইনটাই একমাত্র চমক, আর চমকটা চওড়ার। ~12 32টা bit-ই উল্টায়, তুমি যে চারটা এঁকেছ শুধু সেগুলো না।

তাই ~a & 15u হলো 3, যেটা চার bit-র উত্তর। যখনই উল্টাবে, প্রায় সব সময় mask-ও লাগবে।

Mask মানে এমন একটা সংখ্যা যেটা তুমি ছাঁচ হিসেবে ব্যবহার করো

Mask এমন একটা মান যার 1 bit-গুলো দেখায় তুমি কোন ঘরগুলো নিয়ে ভাবছ। Mask-র সাথে & ওই ঘরগুলো রাখে আর বাকি সব শূন্য করে।

একটা bit নম্বর k-র mask হলো 1u << k। ওটা একটা 1, তার পরে kটা শূন্য।

একটা byte-কে binary-তে ছাপা মানে ওই mask আটবার ব্যবহার করা। Module 6 ওটা loop হিসেবে লিখবে; আজ ওটা আটটা expression।

#include <stdio.h>

int main(void)
{
    unsigned int leds = 90u;

    printf("%u%u%u%u%u%u%u%u\n",
           (leds >> 7) & 1u, (leds >> 6) & 1u,
           (leds >> 5) & 1u, (leds >> 4) & 1u,
           (leds >> 3) & 1u, (leds >> 2) & 1u,
           (leds >> 1) & 1u, leds & 1u);
    return 0;
}

01011010

প্রতিটা expression যে bit-টা তুমি চাও সেটাকে একদম নিচে নামায়, তারপর শুধু ওই একটা bit রাখে।

তাই "bit k পড়ো" মানে সব সময় একই দুই ধাপ: নিচে নামাও, তারপর 1 দিয়ে mask করো।

চারটা idiom, আর ওরাই পুরো lesson

এই operator-গুলোর প্রতিটা বাস্তব ব্যবহার চারটা লাইনের একটা। চারটা শিখে ফেললে bit নিয়ে কাজ শেখা হয়ে গেল।

flags |=  (1u << k);      bit k-কে 1 করো
flags &= ~(1u << k);      bit k-কে 0 করো
flags ^=  (1u << k);      bit k উল্টে দাও
(flags >> k) & 1u         bit k পরীক্ষা করো, মান 1 বা 0

#include <stdio.h>

int main(void)
{
    unsigned int flags = 0u;

    flags |= (1u << 3);
    printf("set bit 3     %u\n", flags);
    flags |= (1u << 5);
    printf("set bit 5     %u\n", flags);
    flags &= ~(1u << 3);
    printf("clear bit 3   %u\n", flags);
    flags ^= (1u << 5);
    printf("toggle bit 5  %u\n", flags);
    printf("is bit 5 set? %u\n", (flags >> 5) & 1u);
    return 0;
}

set bit 3     8
set bit 5     40
clear bit 3   32
toggle bit 5  0
is bit 5 set? 0

মানগুলোকে bit-র নকশা হিসেবে পড়লে অঙ্কটা মিলিয়ে যায়। 8 মানে এক বাতি জ্বলছে, 40 মানে দুই বাতি, 32 মানে আবার এক বাতি।

তাই একটা unsigned int-এ 32টা আলাদা হ্যাঁ-না উত্তর থাকে, আর প্রতিটার কাছে পৌঁছাতে এক লাইন লাগে।

Shift করা মানে গুণ করা, যতক্ষণ না ওটা আর তা থাকে

একটা unsigned মানে x << n 2-র n ঘাত দিয়ে গুণ করে, আর x >> n ওটা দিয়ে ভাগ করে, ভাগশেষ ফেলে দিয়ে।

তাই 2-র ঘাত লেখার সবচেয়ে সস্তা উপায় 1u << n। 1u << 10 হলো 1024।

দুইটা নিয়ম এটাকে সব জায়গায় নিরাপদ হতে দেয় না, আর ওরা ইচ্ছে করেই আলাদা দুইটা শব্দ ব্যবহার করে।

• ঋণাত্মক signed মানকে ডানে shift করা implementation defined। Compiler-কে লিখে রাখতে হয় ও কী করে, আর তারপর সেটাই করতে হয়। GCC চিহ্নটা ধরে রাখে, তাই ওখানে -8 >> 1 হলো -4।
• একটা 1-কে চিহ্নের bit-এ বাঁয়ে shift করা undefined behaviour। 32 bit-র একটা int-এ 1 << 31-র কোনো নির্ধারিত মানেই নেই, আর এখানে তার কোনো output লেখা নেই।

মানটা unsigned হলে দুইটাই মিলিয়ে যায়। 1u << 31 সাধারণ, পুরোপুরি নির্ধারিত 2147483648।

#include <stdio.h>

int main(void)
{
    printf("1u << 0  = %u\n", 1u << 0);
    printf("1u << 10 = %u\n", 1u << 10);
    printf("1u << 31 = %u\n", 1u << 31);
    return 0;
}

1u << 0  = 1
1u << 10 = 1024
1u << 31 = 2147483648

Literal-র গায়ে ওই u-টাই পুরো নিরাপত্তা। এক অক্ষর খরচ, আর মাথা থেকে দুইটা নিয়ম বাদ।

তাই এই track প্রতিবার 1u << k লেখে, আর shift করে শুধু unsigned মান।

& মানে && না, আর XOR swap একটা ফাঁদ

5 & 1 হলো 1 আর 5 && 1-ও 1, আর এই জন্যই ভুলটা এত দিন টিকে থাকে।

ওরা মিলে যায় কাকতালীয়ভাবে। 4 & 1 হলো 0 আর 4 && 1 হলো 1, আর ওখানেই কাকতালটা শেষ।

& bit মেলায় আর সব সময় দুই পাশই চালায়। && উত্তর মেলায় আর ডান পাশ বাদ দিতে পারে। Lesson 2-র পাহারা দেওয়া ভাগটা ওই তফাতের উপরই দাঁড়ানো।

আরও একটা বিখ্যাত চালাকির নাম বলে তারপর বাদ দেওয়া দরকার। তৃতীয় কোনো variable ছাড়া, তিনটা ^= লাইন দিয়ে দুইটা সংখ্যা অদলবদল করা যায়।

ওটা সত্যি, আর এই track ওটা ব্যবহার করে না। আধুনিক যেকোনো processor-এ ওটা তৃতীয় একটা বাক্সের চেয়ে ধীর, ওটা পড়া যায় না, আর দুই পাশে একই variable থাকলে ওটা চুপচাপ শূন্য বানিয়ে দেয়। Module 2-র বাড়তি বাক্সটাই ঠিক উত্তর।

#include <stdio.h>

int main(void)
{
    unsigned int n = 0;
    scanf("%u", &n);

    printf("%u\n", n & 1u);
    return 0;
}

1

#include <stdio.h>

int main(void)
{
    unsigned int bold = 0;
    unsigned int italic = 0;
    unsigned int under = 0;
    scanf("%u %u %u", &bold, &italic, &under);

    unsigned int look = (bold << 0) | (italic << 1) | (under << 2);

    printf("look %u\n", look);
    printf("italic? %u\n", (look >> 1) & 1u);
    return 0;
}

look 5
italic? 0

#include <stdio.h>

int main(void)
{
    unsigned int r = 0;
    unsigned int g = 0;
    unsigned int b = 0;
    scanf("%u %u %u", &r, &g, &b);

    unsigned int packed = (r << 16) | (g << 8) | b;

    printf("packed %u\n", packed);
    printf("r %u\n", (packed >> 16) & 255u);
    printf("g %u\n", (packed >> 8) & 255u);
    printf("b %u\n", packed & 255u);
    return 0;
}

packed 13140520
r 200
g 130
b 40

unsigned int flags = 4u;
printf("%u %u\n", flags & 1u, flags && 1u);

unsigned int nibble = 12u;
printf("%u\n", ~nibble);

printf("%d\n", 1 << 31);

unsigned int flags = 8u;
printf("%u\n", flags & (1u << 3));

unsigned int a = 1u << 31;
int b = 1 << 31;

#include <stdio.h>

int main(void)
{
    unsigned int n = 0;
    unsigned int k = 0;
    scanf("%u %u", &n, &k);

    /* Shift the bit down to the bottom, then mask with 1u. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int r = 0;
    unsigned int g = 0;
    unsigned int b = 0;
    scanf("%u %u %u", &r, &g, &b);

    /* Pack with two shifts and two ors. Unpack with shifts and 255u. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int b = 0;
    scanf("%u", &b);

    /* Eight tests, added together. No loop until Module 6. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int b = 0;
    scanf("%u", &b);

    /* Two halves: one moves up four places, the other moves down four. */

    return 0;
}

এরপর জানবে, এক লাইনে কয়েকটা operator লিখলে তাদের ক্রম কে ঠিক করে।