এই পর্বে যা শিখবেন
- Type-এর সংজ্ঞা (মানের সেট, operation, representation) আর Haat-এর চারটি primitive type-এর typing rule পড়া
- C, Java, Python, Rust, JavaScript আর Haat-এ integer-এর আকার কে ঠিক করে, আর C-র usual arithmetic conversions হাতে চালানো
- একটি binary64 বিট-প্যাটার্ন হাতে decode করা, আর 0.1 কীভাবে গোল হয় তা ধাপে ধাপে দেখানো
- টাকার হিসাবে float কেন বিপজ্জনক, আর Decimal বা পয়সায় Int দিয়ে নিরাপদে হিসাব
- Primitive type কীভাবে compiler-এর নির্দেশ বাছাই আর কোন optimization বৈধ তা ঠিক করে, প্রমাণসহ
১ · Type মানে কী — মানের সেট, কাজের সেট আর বিট পড়ার নিয়ম
বাজারঘরের গুদামে চাল মাপা হয় কেজিতে, ডিম গোনা হয় হালিতে, আর ক্যাশবাক্সে টাকা গোনা হয় পয়সা পর্যন্ত। কেউ যদি লেখেন “৩ কেজি চাল + ২ হালি ডিম”, যোগফলটি অর্থহীন। আবার ওজন ২.৭৫ কেজি হতে পারে, কিন্তু ডিম ২.৭৫টি বিক্রি হয় না। প্রতিটি জিনিসের সঙ্গে দুটি কথা লুকিয়ে আছে: কোন মান সম্ভব, আর কোন কাজ বৈধ। প্রোগ্রামিং ভাষায় এই জোড়ার নাম type.
একটি data type T হলো একটি জোড়া: মানের একটি সেট V(T) আর সেই মানের ওপর বৈধ operation-এর একটি সেট. বাস্তবায়নে তৃতীয় একটি সিদ্ধান্ত যোগ হয়, representation: প্রতিটি মান মেমরিতে কোন বিট-রূপে থাকবে। যেমন Haat-এর Int: V = {−263, …, 263 − 1}, operation = + - * / %, তুলনা আর ==, representation = ৬৪-বিট two's complement.
Primitive type হলো ভাষার একেবারে মৌলিক type, যা অন্য type জুড়ে তৈরি নয়। ভাষা নিজেই এর মান আর operation সংজ্ঞায়িত করে, আর সাধারণত একটি-দুটি CPU নির্দেশেই এর কাজ হয়ে যায়। Array, record, union-এর মতো composite type এদের জুড়ে তৈরি; সেগুলো পর্ব ২২-এ। কোনটি primitive, তা ভাষাভেদে আলাদা: Java 21-এ ঠিক আটটি (byte short int long float double char boolean); JavaScript-এ সাতটি (number, bigint, string, boolean, undefined, null, symbol); Python 3-এ সবকিছুই object, তবে int float bool str built-in মৌলিক type. Haat-এর চারটি:
| Type | মানের সেট | বৈধ operation (reference, সিদ্ধান্ত ৮ ও ১১) |
|---|---|---|
Int | −9223372036854775808 থেকে 9223372036854775807 | + - * / %, < <= > >=, == !=, unary -, print |
Bool | true, false | && || !, == !=, print |
Str | যেকোনো Unicode লেখা | + (জোড়া), == !=, print; কোনো ক্রম-তুলনা নেই |
Unit | একটিমাত্র মান, কোনো literal নেই | কিছুই না; print-ও করা যায় না |
Type checker এই সেটগুলোকে inference rule হিসেবে লেখে: দাগের ওপরে শর্ত, নিচে সিদ্ধান্ত। Γ ⊢ e : τ পড়ুন “নামগুলোর type-এর তালিকা Γ থেকে প্রমাণ করা যায় যে e-এর type τ”। Haat-এর তিনটি নিয়ম:
T-Int-এর শর্ত বাস্তবায়নে lexer-ই পরীক্ষা করে: Haat reference-এ print(9223372036854775808); লিখলে আসে 1:7: error: integer literal too large, তাই সবচেয়ে ছোট Int লিখতে হয় -9223372036854775807 - 1 (reference-এর সিদ্ধান্ত ৩)। T-Eq-এর τ দুই পাশে একই, তাই 5 == true কোনো নিয়মে মেলে না। Typing rule-এর পূর্ণ গণিত পর্ব ৩৪-এ।
এই দৃষ্টিভঙ্গি compiler লেখকের কাছে খুব বাস্তব: একই ৩২টি বিট দেখে compiler কোন নির্দেশ বসাবে, signed তুলনা না unsigned, integer যোগ না floating-point যোগ, তা সে ঠিক করে type দেখে। পুরো পর্বজুড়ে এই প্রশ্নটি ফিরে আসবে: type কোন সিদ্ধান্ত বদলায়?
২ · Integer-এর আকার কে ঠিক করে
একটি integer type-এর দুটি মূল প্রশ্ন: কত বিট, আর ঋণাত্মক মান রাখা যায় কি না (signed না unsigned). ভাষাগুলো উত্তর দিয়েছে ভিন্ন ভিন্নভাবে:
| ভাষা | Integer type | আকার কে ঠিক করে |
|---|---|---|
| C17 | char short int long long long, প্রতিটির unsigned রূপ | Standard শুধু ন্যূনতম দেয় (int ≥ ১৬, long ≥ ৩২, long long ≥ ৬৪ বিট); বাকিটা compiler আর target-এর |
| Java 21 | byte ৮, short ১৬, int ৩২, long ৬৪ (সব signed) | ভাষার specification; প্রতিটি JVM-এ এক |
| Python 3.14 | int | কোনো নির্দিষ্ট আকার নেই, arbitrary-precision |
| Rust (stable) | i8…i128, u8…u128, isize/usize | নামেই বিট লেখা; isize pointer-এর সমান |
| JavaScript (ES2025) | number (আসলে binary64), bigint | number-এ পূর্ণসংখ্যা নির্ভুল শুধু ±(253 − 1) পর্যন্ত |
| Haat | Int | Spec v1: ৬৪-বিট two's complement |
C-র “বাকিটা compiler-এর” কথাটির নাম implementation-defined behavior: standard কয়েকটি বিকল্প খোলা রাখে, compiler একটি বেছে নিয়ে তা document করতে বাধ্য। এটি undefined behavior থেকে আলাদা: সেখানে কোনো প্রতিশ্রুতিই নেই। একই compiler কিন্তু আলাদা target-এ উত্তর কতটা বদলায়, দেখুন।
সত্যিকারের run — একই Clang, পাঁচটি target
PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; zig মানে python -m ziglang. ছোট একটি ফাইলে কয়েকটি ধ্রুবক রাখা হলো, যাদের মান compile-এর সময়ই ঠিক হয়; তারপর প্রতিটি target-এর জন্য LLVM IR বের করে ধ্রুবকগুলো পড়া হলো (program চালাতে হয়নি, তাই অন্য CPU-র জন্যও কাজ করে):
// sizes.c
const int size_long = sizeof(long);
const int size_ptr = sizeof(void *);
const int char_min = CHAR_MIN;
const int minus1L_lt_1u = (-1L < 1u);
~/haat $ zig cc -target x86_64-windows-gnu -S -emit-llvm sizes.c -o win.ll
@size_long = dso_local constant i32 4, align 4
@char_min = dso_local constant i32 -128, align 4
@minus1L_lt_1u = dso_local constant i32 0, align 4
~/haat $ zig cc -target riscv64-linux-musl -S -emit-llvm sizes.c -o rv64.ll
@size_long = dso_local constant i32 8, align 4
@char_min = dso_local constant i32 0, align 4
@minus1L_lt_1u = dso_local constant i32 1, align 4
| Target | int | long | pointer | CHAR_MIN | -1L < 1u |
|---|---|---|---|---|---|
| x86_64-windows-gnu | 4 | 4 | 8 | −128 | 0 |
| x86_64-linux-musl | 4 | 8 | 8 | −128 | 1 |
| aarch64-linux-musl | 4 | 8 | 8 | 0 | 1 |
| riscv64-linux-musl | 4 | 8 | 8 | 0 | 1 |
| riscv32-linux-musl | 4 | 4 | 4 | 0 | 0 |
তিনটি শিক্ষা। এক, long Windows x64-এ ৪ byte, Linux x86-64-এ ৮ byte, যদিও CPU একই। কারণ অপারেটিং সিস্টেমের ABI-র data model আলাদা: Linux আর macOS-এর ৬৪-বিট জগৎ LP64 (long আর pointer ৬৪ বিট), Windows-এর LLP64 (long ৩২, long long আর pointer ৬৪), আর riscv32 ILP32 (int, long, pointer সবই ৩২)। দুই, char x86-64-এ signed (CHAR_MIN −128), কিন্তু ARM64 আর RISC-V Linux-এ unsigned (CHAR_MIN 0); অংশ ৭-এ আবার আসবে। তিন, একই expression -1L < 1u-এর মান target বদলালে 1 থেকে 0 হয়ে যায়; কেন, তা পরের অংশের নিয়মে। এজন্যই C99 এনেছে <stdint.h>-এর int32_t, int64_t: নামেই আকার লেখা, যেমন Rust-এ।
সীমা পেরোলে কী হয় (Java-র wrap, Python-এর বড় সংখ্যা, Rust-এর panic, C-র undefined behavior), তা পর্ব ০৬-এ (ভাষা নকশার লক্ষ্য আর আপস) সত্যিকারের run দিয়ে দেখেছেন; এখানে আর নয়। Haat-এর integer overflow নিয়ম wrapping arithmetic, আর তা সীমার কোণেও নির্ধারিত (reference-এর সিদ্ধান্ত ১৩)। Reference বাস্তবায়নে python haat.py run, আর vm-এও একই ফল:
let max = 9223372036854775807;
print(max + 1); // -9223372036854775808
print(-(-9223372036854775807 - 1)); // -9223372036854775808
print(7 / -2); // -3
print(-7 % 2); // -1
সবচেয়ে ছোট Int-এর ঋণাত্মক ধরে না, তাই wrap করে নিজেই থেকে যায়; / শূন্যের দিকে কাটে আর % ভাজ্যের চিহ্ন নেয়, ঠিক C-র মতো। বিট-স্তরের two's complement-এর পুরো ব্যাখ্যা আছে Computer Architecture কোর্সের পর্ব ০৫-এ (Integer-এর বিট-রূপ).
৩ · Signed, unsigned আর C-র নীরব রূপান্তর
n বিটের unsigned integer রাখে 0 থেকে 2n − 1; two's complement-এর signed integer রাখে −2n−1 থেকে 2n−1 − 1. ৩২টি 1 বিট unsigned হিসেবে পড়লে 4294967295, signed হিসেবে −1. এখন C-তে যদি দুটি আলাদা type একসাথে আসে, যেমন int আর unsigned int, compiler-কে আগে একটি সাধারণ type বাছতে হয়। এই বাছাইয়ের নিয়ম C17-এর §6.3.1.1 আর §6.3.1.8-এ: প্রথমে integer promotion, তারপর usual arithmetic conversions. Integer-এর জন্য সারকথা:
- Rank-এ int-এর চেয়ে ছোট type (
_Bool char short) int হয়, যদি int তার সব মান ধরতে পারে; নইলে unsigned int. - দুটি type একই হলে সেটিই সাধারণ type.
- দুটিই signed বা দুটিই unsigned হলে বড় rank-এরটি।
- Unsigned-টির rank ≥ signed-টির rank হলে সাধারণ type ওই unsigned type.
- নইলে signed type যদি unsigned type-এর সব মান ধরতে পারে, সাধারণ type ওই signed type.
- নইলে signed type-এর unsigned রূপ।
ভাবুন, বাজারঘরের দুই কর্মী দুটি খাতা রাখেন। একজনের খাতায় বাকি (ধার) লেখা হয় ঋণাত্মক অঙ্কে, যেমন −১ টাকা। আরেকজনের খাতায় ঋণাত্মক ঘরই নেই; সেখানে সংখ্যা শুধু ০ থেকে ওপরে, আর শূন্যের নিচে নামলে কাউন্টার ঘুরে সবচেয়ে বড় সংখ্যায় চলে যায়, পুরোনো গাড়ির মিটারের মতো। দুই খাতা মেলাতে গিয়ে যদি নিয়ম হয় “সব অঙ্ক দ্বিতীয় খাতার নিয়মে লেখা হবে”, তবে −১ টাকার বাকি হঠাৎ বিশাল জমা হয়ে যায়। C-র নিয়ম ৪ ঠিক এটাই করে, আর কেউ জিজ্ঞেসও করে না।
মান রূপান্তরের নিয়ম (§6.3.1.3): unsigned type-এ নেওয়া মানে 2n দিয়ে ভাগশেষ নেওয়া। তাই −1 হয় 232 − 1. এই বাছাইয়ের কোনো চিহ্ন কোডে লেখা থাকে না; একে বলে implicit conversion. নিচের stepper-এ compiler-এর চোখ দিয়ে একটি তুলনা দেখুন; শেষ দুই লাইন সত্যিকারের Clang 22.1.8-এর output.
1int a = -1;2unsigned int b = 1;3if (a < b) …4IR: icmp ult i32 %a, %b5RV: sltu a0, a0, a1
| a | |
| b | |
| সাধারণ type |
- Type খোঁজা।
a-র typeint, মান −1, বিট 0xFFFFFFFF.b-র typeunsigned int, মান 1. দুটি আলাদা type, তাই তুলনার আগে একটি সাধারণ type লাগবে। - Integer promotion. দুটিই int-এর rank-এ বা তার ওপরে, তাই নিয়ম ১ কিছুই বদলায় না। (দুটি
shortহলে এখানেই দুটি int হয়ে যেত।) - Usual arithmetic conversions. Rank সমান, একটি signed একটি unsigned. নিয়ম ৪: unsigned-এর rank ≥ signed-এর rank, তাই সাধারণ type
unsigned int. - মান রূপান্তর। −1-কে unsigned int-এ নিতে 232 দিয়ে ভাগশেষ: −1 + 4294967296 = 4294967295. বিট বদলায়নি, বদলেছে বিট পড়ার নিয়ম।
- তুলনা। 4294967295 < 1 মিথ্যা, তাই ফল 0. গণিতে −1 < 1 সত্য, C-তে মিথ্যা। Clang
-Wall -Wextra-এ সতর্ক করে:comparison of integers of different signs. - Code generation. সাধারণ type unsigned, তাই LLVM IR-এ
icmp ult(unsigned less than), আর RISC-V-তেsltu. দুটি int হলে হতোicmp sltআরslt. Register-এ বিট একই; শুধু নির্দেশ বদলায়।
সত্যিকারের run — সতর্কবার্তা আর ফল
Windows x64-এ (Clang 22.1.8, zig cc -O0 -fno-sanitize=undefined -Wall -Wextra conv.c). মূল লাইনগুলো ছিল int a = -1; unsigned int b = 1; if (a < b) …, সঙ্গে আরও কয়েকটি printf:
conv.c:6:11: warning: comparison of integers of different signs: 'int' and 'unsigned int' [-Wsign-compare]
6 | if (a < b) printf("-1 < 1u : true\n");
-1 < 1u : false
(unsigned)-1 = 4294967295
-1 < (int)1u = 1
-1L < 1u = 0
sizeof(long) = 4
(char)200 = -56
আর signedness যে আসলে operation-এ থাকে, register-এ নয়, তা দেখা যায় -O2-এর output-এ। LLVM IR-এর integer type i32-এর কোনো চিহ্ন নেই; চিহ্ন বলে দেয় নির্দেশ (riscv64 target, -fomit-frame-pointer, directive বাদ):
| C function | LLVM IR | RISC-V (RV64) |
|---|---|---|
int a < int b | icmp slt i32 | slt a0, a0, a1 |
int a < unsigned b | icmp ult i32 | sltu a0, a0, a1 |
int → long long | sext i32 to i64 | কোনো নির্দেশ নেই, শুধু ret |
unsigned → long long | zext i32 to i64 | slli a0, a0, 32; srli a0, a0, 32 |
double + double | fadd double | fadd.d fa0, fa0, fa1 |
ছোট type থেকে বড় type-এ নিতে signed মানে sign extension (বাঁয়ের ফাঁকা বিটে চিহ্ন-বিটের কপি), unsigned মানে zero extension (ফাঁকায় 0). RV64-এর calling convention ৩২-বিট মানকে register-এ আগে থেকেই sign-extend করে রাখে, তাই signed রূপান্তরে কোনো নির্দেশই লাগেনি, আর unsigned-এ দুটি shift দিয়ে ওপরের ৩২ বিট মোছা হয়েছে। Compiler-এর semantic analysis-এর এই অংশটুকু Python-এ লিখে দেখা যাক:
# C17 6.3.1.1 + 6.3.1.8 for integers, as a C compiler's checker does it
RANK = {"short": 2, "int": 3, "long": 4, "long long": 5}
MODELS = {"LP64 (Linux x86-64)": {"short": 16, "int": 32, "long": 64, "long long": 64},
"LLP64 (Windows x64)": {"short": 16, "int": 32, "long": 32, "long long": 64}}
def promote(t, bits): # integer promotions
base, uns = t
if RANK[base] < RANK["int"]:
maxv = 2 ** bits[base] - 1 if uns else 2 ** (bits[base] - 1) - 1
return ("int", maxv > 2 ** (bits["int"] - 1) - 1) # int, else unsigned
return t
def common(a, b, bits): # usual arithmetic conversions
if a == b: return a
(ba, ua), (bb, ub) = a, b
if ua == ub: return a if RANK[ba] >= RANK[bb] else b
(U, S) = (a, b) if ua else (b, a)
if RANK[U[0]] >= RANK[S[0]]: return U
if bits[S[0]] > bits[U[0]]: return S # S holds every U value
return (S[0], True)
def convert(v, t, bits):
return v % 2 ** bits[t[0]] if t[1] else v
def name(t): return ("unsigned " if t[1] else "") + t[0]
cases = [((-1, ("int", False)), (1, ("int", True))),
((-1, ("long", False)), (1, ("int", True))),
((-1, ("short", False)), (1, ("short", True)))]
for model, bits in MODELS.items():
print("==", model)
for (x, tx), (y, ty) in cases:
t = common(promote(tx, bits), promote(ty, bits), bits)
cx, cy = convert(x, t, bits), convert(y, t, bits)
print(f" ({name(tx)})-1 < ({name(ty)})1 -> {name(t)}: {cx} < {cy} = {int(cx < cy)}")আসল আউটপুট (ব্রাউজারের Python):
== LP64 (Linux x86-64)
(int)-1 < (unsigned int)1 -> unsigned int: 4294967295 < 1 = 0
(long)-1 < (unsigned int)1 -> long: -1 < 1 = 1
(short)-1 < (unsigned short)1 -> int: -1 < 1 = 1
== LLP64 (Windows x64)
(int)-1 < (unsigned int)1 -> unsigned int: 4294967295 < 1 = 0
(long)-1 < (unsigned int)1 -> unsigned long: 4294967295 < 1 = 0
(short)-1 < (unsigned short)1 -> int: -1 < 1 = 1
দ্বিতীয় লাইনটি অংশ ২-এর রহস্যের উত্তর। LP64-এ long ৬৪ বিট, তাই নিয়ম ৫: long unsigned int-এর সব মান ধরতে পারে, সাধারণ type long, তুলনা গণিতের মতোই সত্য। LLP64-এ long মাত্র ৩২ বিট, ধরতে পারে না, তাই নিয়ম ৬: সাধারণ type unsigned long, আর −1 আবার 4294967295. তৃতীয় লাইনটি উল্টো চমক: দুটি short আগেই promotion-এ int হয়ে যায় (int unsigned short-এর সব মান ধরে), তাই unsigned থাকা সত্ত্বেও তুলনা সত্য। Clang-এর IR-এ একই তিনটি ধ্রুবক যাচাই করা হয়েছে: x86_64-linux-musl-এ 0, 1, 1 আর x86_64-windows-gnu-তে 0, 0, 1, এই simulator-এর সঙ্গে হুবহু মেলে।
অন্য ভাষাগুলো এই ফাঁদ এড়িয়েছে নকশা দিয়ে। Java-তে unsigned integer type-ই নেই (Java 8 থেকে Integer.compareUnsigned-এর মতো method আছে)। Rust কোনো implicit numeric conversion করে না: -1i32 < 1u32 লিখলে type mismatch-এর compile error (উদাহরণ, এখানে চালানো হয়নি), রূপান্তর চাইলে as লিখতে হয়। Haat-এ integer type মাত্র একটি, তাই প্রশ্নটিই ওঠে না। C-র রূপান্তরের আরও উদাহরণ আছে C কোর্সের পর্ব ০৮-এ (টাইপ কনভার্শন).
৪ · IEEE 754 binary64 — একটি double-এর ভেতরে
বিজ্ঞানের বইয়ে বড় সংখ্যা লেখা হয় 5.275 × 101 ধাঁচে: একটি চিহ্ন, কয়েকটি অঙ্ক আর দশের একটি ঘাত। Floating point ঠিক এটাই, শুধু ভিত্তি ২। আজকের প্রায় সব CPU আর ভাষা মানে IEEE 754 standard (১৯৮৫; সংশোধন ২০০৮ আর ২০১৯), যার নকশায় William Kahan-এর ভূমিকা সবচেয়ে বড়; এর জন্য তিনি ১৯৮৯ সালে Turing Award পান। C-র double, Java-র double, Python-এর float আর JavaScript-এর number, চারটিই একই format: binary64, অর্থাৎ double precision.
ছবি ২০.১ — binary64-এর তিনটি অংশ, উদাহরণ 52.75
৬৪ বিট = ১ sign + ১১ exponent + ৫২ fraction
নিয়মটি পূর্ণভাবে: exponent field e যদি 1 থেকে 2046-এর মধ্যে হয়, মান (−1)s × 1.f × 2e−1023; এখানে f হলো fraction (একে mantissa বা significand-এর অংশও বলা হয়)। দুই প্রান্তের দুটি e বিশেষ কাজে রাখা:
| e field | f | অর্থ | উদাহরণ (hex) |
|---|---|---|---|
| 0 | 0 | +0 বা −0 | 0000…0, 8000…0 |
| 0 | ≠ 0 | Subnormal: (−1)s × 0.f × 2−1022 | 0000000000000001 = 5e-324 |
| 1–2046 | যেকোনো | Normal সংখ্যা | 404A600000000000 = 52.75 |
| 2047 | 0 | +∞ বা −∞ (infinity) | 7FF0000000000000 |
| 2047 | ≠ 0 | NaN | 7FF8000000000000 |
এবার উল্টো কাজ: একটি বিট-প্যাটার্ন হাতে পেলে মান বের করা। পরীক্ষায় এটি খুব প্রচলিত প্রশ্ন।
1hex: 404A6000000000002s: 03e: 100000001004f: 1010011 000…05মান = (−1)^s × 1.f × 2^(e−1023)
| চিহ্ন | |
| ঘাত | |
| 1.f |
- Hex থেকে বিট। ১৬টি hex অঙ্ক মানে ৬৪ বিট; প্রতিটি hex অঙ্ক চারটি বিট। প্রথম পাঁচটি অঙ্ক 4, 0, 4, A, 6 থেকে আসে 0100 0000 0100 1010 0110, বাকি সব শূন্য।
- Sign. সবচেয়ে বাঁয়ের বিট (বিট ৬৩) 0, তাই সংখ্যাটি ধনাত্মক।
- Exponent. পরের ১১ বিট 10000000100 = 1024 + 4 = 1028. Bias 1023 বাদ দিলে আসল ঘাত 5. Field 0 বা 2047 নয়, তাই এটি normal সংখ্যা।
- Fraction. বাকি ৫২ বিট 1010011-এর পরে ৪৫টি শূন্য। লুকানো 1 সামনে বসালে 1.1010011₂ = 1 + 1/2 + 1/8 + 1/64 + 1/128 = 211/128 = 1.6484375.
- গুণ। 1.6484375 × 25 = 1.6484375 × 32 = 52.75. দশমিকে 105 দিয়ে গুণ মানে দশমিক বিন্দু পাঁচ ঘর ডানে; binary-তে 25 দিয়েও তাই।
- যাচাই। বিন্দু পাঁচ ঘর সরালে 110100.11₂: পূর্ণ অংশ 32 + 16 + 4 = 52, ভগ্নাংশ 0.5 + 0.25 = 0.75. মোট 52.75; নিচের Python block-ও একই কথা বলে।
import struct
def fields(x):
raw = struct.unpack(">Q", struct.pack(">d", x))[0] # 64 bits as an int
s = raw >> 63
e = (raw >> 52) & 0x7FF # 11 bits
f = raw & ((1 << 52) - 1) # 52 bits
return raw, s, e, f
def decode(s, e, f):
if e == 0x7FF:
return "nan" if f else ("-inf" if s else "inf")
if e == 0: # zero or subnormal
return (-1) ** s * (f / 2**52) * 2.0 ** -1022
return (-1) ** s * (1 + f / 2**52) * 2.0 ** (e - 1023)
for x in [52.75, 0.1, -0.0, float("inf"), float("nan"), 5e-324]:
raw, s, e, f = fields(x)
print(f"{x!r:>6} {raw:016x} s={s} e={e:<4} f={f:013x} -> {decode(s, e, f)!r}")
nan = float("nan")
print("nan == nan :", nan == nan, "| -0.0 == 0.0 :", -0.0 == 0.0)
print("next after 1.0:", struct.unpack(">d", struct.pack(">Q", 0x3FF0000000000001))[0])আসল আউটপুট (ব্রাউজারের Python):
52.75 404a600000000000 s=0 e=1028 f=a600000000000 -> 52.75
0.1 3fb999999999999a s=0 e=1019 f=999999999999a -> 0.1
-0.0 8000000000000000 s=1 e=0 f=0000000000000 -> -0.0
inf 7ff0000000000000 s=0 e=2047 f=0000000000000 -> 'inf'
nan 7ff8000000000000 s=0 e=2047 f=8000000000000 -> 'nan'
5e-324 0000000000000001 s=0 e=0 f=0000000000001 -> 5e-324
nan == nan : False | -0.0 == 0.0 : True
next after 1.0: 1.0000000000000002
struct.pack(">d", x) একটি double-এর আটটি byte দেয়, আর ">Q" সেগুলোকে একটি ৬৪-বিট unsigned integer হিসেবে পড়ে: একই বিট, অন্য type (একে বলে type punning). 52.75-এর সারি stepper-এর সঙ্গে মেলে। 0.1-এর fraction শেষ হয়েছে …999a-তে: পুনরাবৃত্ত 9-এর শেষে একটি a, অর্থাৎ গোল করা হয়েছে; পরের অংশে এর কারণ। −0.0-র শুধু sign বিট 1, তবুও -0.0 == 0.0 সত্য। 5e-324 সবচেয়ে ছোট ধনাত্মক subnormal. শেষ লাইন: 1.0-এর ঠিক পরের double 1 + 2−52; এই দূরত্বকে বলে machine epsilon. বিট-স্তরের আরও খুঁটিনাটি (single precision, hardware-এর যোগ-গুণ) আছে Computer Architecture কোর্সের পর্ব ২৩-এ (Floating point — IEEE 754).
৫ · 0.1 কেন হুবহু নেই — rounding, NaN আর −0.0
দশমিকে ১/৩ = 0.333… কখনো শেষ হয় না, কারণ ৩ দশের গুণনীয়ক নয়। Binary-তে একই সমস্যা ১/১০-এর: ১০-এর গুণনীয়ক ৫, যা ২-এর ঘাত নয়। তাই 0.1-এর binary রূপ অসীম, আর ৫৩ বিটে রাখতে গেলে কাটতে আর গোল করতে হয়। IEEE 754-এর ডিফল্ট নিয়ম round to nearest, ties to even: সবচেয়ে কাছের প্রকাশযোগ্য মান নেওয়া; ঠিক মাঝখানে পড়লে যার শেষ বিট 0, সেটি নেওয়া।
10.1×2=0.2→0 0.2×2=0.4→020.4×2=0.8→0 0.8×2=1.6→130.6×2=1.2→1 0.2×2=0.4→0 …40.1 = 1.1001 1001…₂ × 2^−45f = 9999999999999 | 9…
| binary অঙ্ক | |
| বাকি অংশ |
- দ্বিগুণ করার পদ্ধতি। ভগ্নাংশকে ২ দিয়ে গুণ করলে পূর্ণ অংশটি (0 বা 1) পরের binary অঙ্ক। 0.1 → 0.2 (অঙ্ক 0) → 0.4 (অঙ্ক 0). এখন পর্যন্ত 0.00₂, বাকি 0.4.
- প্রথম 1. 0.4 → 0.8 (অঙ্ক 0) → 1.6 (অঙ্ক 1); পূর্ণ অংশ বাদ দিয়ে বাকি 0.6. এখন 0.0001₂.
- চক্র। 0.6 → 1.2 (অঙ্ক 1, বাকি 0.2) → 0.4 (অঙ্ক 0)… বাকি 0.2 আগেও এসেছিল (প্রথম ধাপে), তাই এখান থেকে একই অঙ্কগুলো চিরকাল ঘুরবে: 0.1 = 0.0 0011 0011 0011…₂. দশমিকের 0.333…-এর মতোই অসীম।
- Normalize. প্রথম 1-এর পরে বিন্দু বসালে 1.1001 1001…₂ × 2−4. Exponent field = −4 + 1023 = 1019, যা Python block-এর সারির সঙ্গে মেলে।
- কাটা আর গোল করা। লুকানো 1-এর পরে ৫২ বিট রাখা যায়: 1001-এর তেরোটি দল, hex-এ 9999999999999. পরের বিটগুলো 1001 1001…, অর্থাৎ বাকি অংশ শেষ বিটের মানের (ulp, unit in the last place) 0.6 গুণ, অর্ধেকের বেশি। তাই নিচে কাটা নয়, ওপরে গোল: শেষ hex অঙ্ক 9 + 1 = a. (ঠিক অর্ধেক হলে ties-to-even লাগত; এখানে লাগেনি।)
- ফল। রাখা মান 0x3FB999999999999A, যা দশমিকে 0.1000000000000000055511151231257827…; ভুল প্রায় 5.55 × 10−18, এক ulp (প্রায় 1.39 × 10−17)-এর অর্ধেকের কম। নিচে কাটলে ভুল হতো প্রায় 8.33 × 10−18, যা বেশি; তাই এটিই “সবচেয়ে কাছের” double.
এখন বিখ্যাত ফলটি সহজ: 0.1 আর 0.2 দুটিই সামান্য ওপরে গোল হয়েছে, যোগফলও গোল হয়ে দাঁড়ায় 0.3000000000000000444…, অথচ 0.3 লিখলে রাখা হয় 0.2999999999999999888…; দুটি পাশাপাশি দুটি আলাদা double. তাই 0.1 + 0.2 == 0.3 মিথ্যা, আর Python বা JavaScript ছাপে 0.30000000000000004 (যে সবচেয়ে ছোট দশমিক লেখা থেকে ঠিক এই double ফেরত পাওয়া যায়)।
float বনাম double — একই 0.1, দুই নির্ভুলতা
C-র float সাধারণত IEEE 754-এর binary32: ১ sign, ৮ exponent (bias 127), ২৩ fraction, অর্থাৎ ২৪ বিটের নির্ভুলতা, দশমিকে মোটামুটি ৭টি অঙ্ক। একই 0.1 দুই type-এ রাখলে গোল-করার ভুলও দুই মাপের। সত্যিকারের run (Clang 22.1.8, Windows x64, -std=c17 -Wall -Wextra, printf("%.20f")):
0.1f = 0.10000000149011611938
0.1 = 0.10000000000000000555
0.1+0.2==0.3: 0
float-এ ভুল অষ্টম দশমিক ঘরেই দেখা দিল, double-এ আঠারোতম ঘরে। তাই C-তে 0.1f == 0.1 মিথ্যা: তুলনার আগে usual arithmetic conversions float-কে double-এ তোলে, আর তোলার সময় হারানো বিট ফিরে আসে না। Clang-এর -Wfloat-equal flag দিলে প্রতিটি floating-point ==-তে সতর্ক করে: comparing floating point with == or != is unsafe. উল্টো দিকের রূপান্তরও ফাঁদ: C-তে double থেকে int নিলে দশমিক অংশ কেটে যায়, আর মান int-এর সীমার বাইরে হলে আচরণ undefined; Java সেখানে নির্ধারিত নিয়মে সবচেয়ে কাছের সীমায় আটকে দেয়। এক ভাষার নিয়ম আরেক ভাষায় খাটে না, এই পর্বের মূল সুর আবারও।
আরও দুটি নিয়ম ভাষার semantics বদলে দেয়। NaN (Not a Number, যেমন ∞ − ∞-এর ফল) কোনো কিছুর সমান নয়, নিজেরও নয়: IEEE 754-এ NaN-এর সঙ্গে প্রতিটি তুলনা মিথ্যা, শুধু != সত্য। আর −0.0 আর +0.0 ==-তে সমান, অথচ 1/−0.0 = −∞ আর 1/+0.0 = +∞; অর্থাৎ সমান দুটি মান একই function-এ আলাদা ফল দিতে পারে। JavaScript-এ দেখুন, সঙ্গে number বনাম BigInt:
const big = 2 ** 53; // 9007199254740992
console.log("MAX_SAFE_INTEGER =", Number.MAX_SAFE_INTEGER);
console.log("2**53 + 1 =", big + 1); // cannot be represented
console.log("2n**53n + 1n =", (2n ** 53n + 1n).toString());
console.log("typeof 1, 1n =", typeof 1, typeof 1n);
console.log("7 / 2, 7n / 2n =", 7 / 2, (7n / 2n).toString());
console.log("0.1 + 0.2 =", 0.1 + 0.2);
console.log("NaN === NaN =", NaN === NaN, "| Object.is(NaN, NaN) =", Object.is(NaN, NaN));
console.log("-0 === 0 =", -0 === 0, "| Object.is(-0, 0) =", Object.is(-0, 0));
console.log("1 / -0 =", 1 / -0);
try {
console.log(1n + 1);
} catch (e) {
console.log("1n + 1 ->", e.name);
}
// Haat's Int: 64-bit two's complement wrap
const wrap64 = (x) => BigInt.asIntN(64, x);
const max = 2n ** 63n - 1n;
console.log("Haat max + 1 =", wrap64(max + 1n).toString());আসল আউটপুট (ব্রাউজারের JavaScript; Node.js 24.15.0-এও হুবহু একই):
MAX_SAFE_INTEGER = 9007199254740991
2**53 + 1 = 9007199254740992
2n**53n + 1n = 9007199254740993
typeof 1, 1n = number bigint
7 / 2, 7n / 2n = 3.5 3
0.1 + 0.2 = 0.30000000000000004
NaN === NaN = false | Object.is(NaN, NaN) = true
-0 === 0 = true | Object.is(-0, 0) = false
1 / -0 = -Infinity
1n + 1 -> TypeError
Haat max + 1 = -9223372036854775808
JavaScript-এ সাধারণ সংখ্যা মানেই binary64, তাই 253 + 1 রাখা যায় না: ৫৩ বিটের significand-এ পাশের double-এর দূরত্ব এখানে 2, ফলে যোগফল গোল হয়ে 253-এই থাকে। BigInt (ES2020) arbitrary-precision, আর এর / পূর্ণসংখ্যার ভাগ। === IEEE-র নিয়ম মানে (NaN অসমান, −0 সমান), আর Object.is মানে “একই মান”; একটি ভাষায় দুই রকম সমতা। 1n + 1 TypeError: JavaScript, যে ভাষা "5" * 2-কে নীরবে 10 বানায়, সেও BigInt আর number মেশাতে দেয় না, কারণ কোন দিকে রূপান্তর করলে নির্ভুলতা হারাবে না, তার কোনো নিরাপদ উত্তর নেই। শেষ লাইন: BigInt.asIntN(64, …) ঠিক Haat-এর wrap নিয়ম। JavaScript-এর সংখ্যা নিয়ে আরও আছে JavaScript কোর্সের পর্ব ০৬-এ (মান, টাইপ আর coercion-এর ফাঁদ).
৬ · টাকার হিসাব — float নয়, Decimal বা পয়সায় Int
বাজারঘরের হিসাবরক্ষক দিনের শেষে খাতা মেলান: খাতায় ১০০০.০০ টাকা, program বলছে 999.9999999999999. এক পয়সার এই ফাঁক ছোট, কিন্তু লাখো অর্ডারে জমে, আর অডিটে “হিসাব মেলে না” মানেই বড় সমস্যা। টাকা দশমিকে গোনা হয়, double গোনে binary-তে; তাই 0.10 টাকার মতো সাধারণ দামও double-এ হুবহু থাকে না। সমাধান দুটি: (১) Decimal-এর মতো দশ-ভিত্তিক type (Python-এর decimal, Java-র BigDecimal, C#-এর decimal); (২) fixed-point: সবচেয়ে ছোট একককে পূর্ণসংখ্যা ধরা, অর্থাৎ পয়সায় Int (১ টাকা = ১০০ পয়সা)।
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
print("0.1 + 0.2 =", 0.1 + 0.2)
total = 0.0
for _ in range(10):
total += 0.10 # ten items of 0.10 taka, as float
print("10 x 0.10 float =", total, "| == 1.0 ?", total == 1.0)
print("exact 0.1 =", Decimal(0.1)) # the double nearest 0.1
d = sum([Decimal("0.10")] * 10) # decimal arithmetic
print("10 x 0.10 dec =", d, "| == 1 ?", d == 1)
price = 2.675 # really 2.67499999...
print("round(2.675, 2) =", round(price, 2))
for t in ("2.665", "2.675"):
q, c = Decimal(t), Decimal("0.01")
print(t, "HALF_UP", q.quantize(c, ROUND_HALF_UP),
"| HALF_EVEN", q.quantize(c, ROUND_HALF_EVEN))
# Haat style: money as Int poisha (1 taka = 100 poisha)
qty, unit = 3, 1833 # 18.33 taka = 1833 poisha
p = qty * unit # exact: 5499 poisha
vat = (p * 15 + 50) // 100 # 15% VAT, round half up
print("subtotal", p // 100, "taka", p % 100, "poisha; VAT", vat, "poisha")আসল আউটপুট (ব্রাউজারের Python):
0.1 + 0.2 = 0.30000000000000004
10 x 0.10 float = 0.9999999999999999 | == 1.0 ? False
exact 0.1 = 0.1000000000000000055511151231257827021181583404541015625
10 x 0.10 dec = 1.00 | == 1 ? True
round(2.675, 2) = 2.67
2.665 HALF_UP 2.67 | HALF_EVEN 2.66
2.675 HALF_UP 2.68 | HALF_EVEN 2.68
subtotal 54 taka 99 poisha; VAT 825 poisha
দশবার 0.10 যোগে double-এ 1.0 হয়নি; প্রতিটি যোগে নতুন গোল-করার ভুল জমেছে। Decimal(0.1) দেখায় 0.1 লিখলে আসলে কোন double পাওয়া যায়, stepper-এর সেই 0.1000000000000000055…; তাই Decimal সবসময় string থেকে বানাতে হয়, float থেকে নয়। round(2.675, 2) 2.68 নয়, 2.67, কারণ 2.675-এর double আসলে 2.67499999…; গোল করার নিয়ম ভুল নয়, মানটিই আলাদা। Decimal-এ গোল করার নিয়ম আপনাকে বেছে নিতে হয়: HALF_UP (মাঝখানে পড়লে ওপরে, দোকানের প্রচলিত নিয়ম) আর HALF_EVEN (মাঝখানে পড়লে জোড় অঙ্কে, যাকে banker's rounding বলে; IEEE-র ties-to-even-এর দশমিক রূপ)। শেষ লাইন পয়সায় Int: ৩টি × ১৮.৩৩ টাকা = 5499 পয়সা, নির্ভুল; ১৫% VAT 824.85 পয়সা, যা (p * 15 + 50) // 100 দিয়ে হাতে লেখা half-up নিয়মে 825. Python-এর Decimal নিয়ে বিস্তারে আছে Python কোর্সের পর্ব ০৭-এ (সংখ্যা ও হিসাব).
ভেতরে Decimal দেখতে কেমন? ভাষা-বাস্তবায়নের দিক থেকে এটি আসলে fixed-point-এরই নমনীয় রূপ: একটি পূর্ণসংখ্যা আর দশের একটি ঘাত। CPython 3.14.4-এ Decimal("18.33").as_tuple() দেয় DecimalTuple(sign=0, digits=(1, 8, 3, 3), exponent=-2), অর্থাৎ 1833 × 10−2; আর Decimal("18.330")-এর exponent −3, অঙ্ক পাঁচটি, তবু দুটি ==-তে সমান। পার্থক্য হলো ঘাতটি প্রতিটি মানের সঙ্গে থাকে, তাই যোগের আগে ঘাত মেলাতে হয়, আর ভাগে নির্ভুলতার একটি সীমা লাগে: Python-এর ডিফল্ট context ২৮টি দশমিক অঙ্ক, তাই Decimal(1) / Decimal(3) দেয় 0.3333333333333333333333333333. অর্থাৎ Decimal-ও গোল করে, শুধু দশমিক নিয়মে, যা মানুষের খাতার সঙ্গে মেলে। একটি compiler বা VM-এর কাছে Decimal তাই একটি primitive নয়, ছোট একটি record আর তার ওপর library function; এজন্যই এর হিসাব double-এর একটি CPU নির্দেশের চেয়ে অনেক ধীর।
Haat v1-এ কোনো floating-point type-ই নেই; এটি সচেতন সিদ্ধান্ত, কারণ বাজারঘরের সব হিসাব পয়সায় Int-এ নির্ভুল। একই হিসাব Haat-এ, reference বাস্তবায়নে (run আর vm দুটিতেই একই ফল):
// বাজারঘর: দাম পয়সায় (১ টাকা = ১০০ পয়সা)
let unit = 1833;
let p = 3 * unit;
let vat = (p * 15 + 50) / 100;
print(p / 100); // 54
print(p % 100); // 99
print(vat); // 825
print(-55 / 10); // -5
শেষ লাইনটি সতর্কবার্তা: Haat-এর / শূন্যের দিকে কাটে, তাই −5.5 হয় −5, আর “+50 করে ১০০ দিয়ে ভাগ” কৌশলটি শুধু ধনাত্মক মানে half-up দেয়। ফেরত (refund)-এর মতো ঋণাত্মক অঙ্কে গোল করার নিয়ম আলাদা করে লিখতে হবে। IEEE 754-2008 দশ-ভিত্তিক format-ও (decimal64, decimal128) সংজ্ঞায়িত করেছে, যাকে বলে decimal floating point; তবে বেশিরভাগ ভাষা আর CPU-তে এটি এখনো software-এ চলে।
৭ · Boolean, character আর enum
Boolean: আলাদা type, না শুধু একটি সংখ্যা?
১৯৭২-এর C-তে আলাদা কোনো boolean type ছিল না: শর্তে 0 মানে মিথ্যা, অন্য যেকোনো সংখ্যা সত্য। C99 আনে _Bool আর <stdbool.h>, আর C23-এ bool, true, false keyword হয়েছে। তবু bool ভেতরে একটি ছোট integer, আর রূপান্তরের নিয়ম বিশেষ: যেকোনো অশূন্য মান bool-এ নিলে 1 হয় (C17 §6.3.1.2). সত্যিকারের run (Clang 22.1.8, Windows x64, -std=c17 -Wall -Wextra):
prim.c:14:23: warning: implicit conversion from 'int' to 'unsigned char' changes value from 256 to 0 [-Wconstant-conversion]
bool b = 256 -> 1
unsigned char u = 256 -> 0
if (2) runs
একই 256, দুটি ছোট type, দুই ফল: bool “অশূন্য কি না” প্রশ্নের উত্তর রাখে, unsigned char রাখে নিচের ৮ বিট। Python-এ bool আসলে int-এর subclass (True + True হয় 2), আর শর্তে যেকোনো মান চলে: খালি list বা 0 মিথ্যা, এই নিয়মকে বলে truthiness. Haat এর কোনোটিই মানে না: Bool একটি আলাদা type, আর Int থেকে Bool-এ কোনো implicit conversion নেই। Reference বাস্তবায়নের আসল বার্তা (প্রতিটি আলাদা ফাইল):
let stock = 1; if stock { print("ache"); } --> 2:4: error: type mismatch: expected Bool, found Int
let ok: Bool = 0; --> 1:16: error: type mismatch: expected Bool, found Int
print(1 + true); --> 1:11: error: type mismatch: expected Int, found Bool
let a = 5; print(a == true); --> 2:12: error: type mismatch: expected Int, found Bool
চারটি ভুলই চালানোর আগে, type checker-এর স্তরে ধরা পড়ল। প্রথমটি C-তে বৈধ আর নীরব; Haat-এ লিখতে হয় if stock > 0 {, যা পাঠকের কাছেও স্পষ্ট।
Character: কত বিট, আর signed কি না
“একটি অক্ষর” কথাটি ভাষাভেদে আলাদা জিনিস বোঝায়; প্রতিটি character type-এর পেছনে একটি encoding-এর সিদ্ধান্ত লুকিয়ে আছে:
| ভাষা | Type | আসলে কী |
|---|---|---|
| C17 | char | একটি byte (প্রচলিত সব যন্ত্রে ৮ বিট); signed কি না implementation-defined |
| Java 21 | char | ১৬-বিট unsigned, একটি UTF-16 code unit; 'ক' ধরে, কিন্তু অনেক emoji-র জন্য দুটি char লাগে |
| Python 3.14 | (নেই) | “অক্ষর” মানে দৈর্ঘ্য ১-এর str; ord('ক') = 2453, অর্থাৎ code point U+0995 |
| Rust | char | ৪ byte, একটি Unicode scalar value |
| Haat | (নেই) | শুধু Str |
C-র char-এর signedness কোনো তাত্ত্বিক খুঁটিনাটি নয়। অংশ ২-এর run-এ দেখেছেন CHAR_MIN x86-64-এ −128, ARM64 আর RISC-V Linux-এ 0. ফলে (char)200 Windows x64-এর সত্যিকারের run-এ ছাপল −56, অথচ riscv64-linux-musl target-এর IR-এ একই expression-এর ধ্রুবক 200. ফাইলের byte পড়ে char-এ রাখলে আর তুলনা করলে এক যন্ত্রে ঠিক, আরেক যন্ত্রে ভুল; তাই byte রাখতে unsigned char বা uint8_t লেখাই নিরাপদ। String আর Unicode-এর পুরো গল্প পরের পর্বে।
Enum: নামওয়ালা পূর্ণসংখ্যা
বাজারঘরে পেমেন্টের তিনটি উপায়: নগদ, কার্ড, bKash. C-তে লেখা যায় enum pay { CASH, CARD, BKASH };, আর ভেতরে এরা 0, 1, 2. C-র enum আলাদা type-এর নিরাপত্তা দেয় না। সত্যিকারের run (একই compile):
enum pay p = 7 -> 7, sizeof = 4
CARD + BKASH = 3
enum pay p = 7; -Wall -Wextra-এও কোনো সতর্কবার্তা দেয়নি; শুধু Clang-এর আলাদা flag -Wassign-enum দিলে বলে integer constant not in range of enumerated type 'enum pay'. “কার্ড যোগ bKash” অর্থহীন, তবু 3. Java-র enum একটি পূর্ণ class, তাই সেখানে 7 বসানো যায় না (Java কোর্সের পর্ব ২৪-এ বিস্তারে)। আর Rust বা Haskell-এর enum প্রতিটি বিকল্পের সঙ্গে ডেটাও রাখতে পারে (যেমন কার্ডের সঙ্গে শেষ চার অঙ্ক); সেটি algebraic data type, পর্ব ২৪-এর বিষয়, যেখানে Haat-এর বর্ধিত রূপে enum Payment প্রস্তাব করা হবে।
৮ · Compiler-এর চোখে primitive type — কোন optimization বৈধ
Optimizer-এর মূল নিয়ম: program-এর অর্থ না বদলে রূপ বদলানো। কিন্তু “অর্থ” ঠিক করে type-এর semantics. বীজগণিতে x = x আর x + 0 = x চিরসত্য; কম্পিউটারের type-এ কি? দুটি ছোট উপপাদ্য।
n-বিট two's complement-এ −2n−1 ≤ v < 0 হলে, C-র নিয়মে v-কে n-বিট unsigned-এ নিলে মান হয় v + 2n, আর বিট-প্যাটার্ন অপরিবর্তিত থাকে।
- Two's complement-এর সংজ্ঞা: বিট-প্যাটার্ন B-র signed মান = u(B) − 2n·bn−1, যেখানে u(B) একই বিটকে unsigned হিসেবে পড়া মান, আর bn−1 সবচেয়ে বাঁয়ের বিট।
- v < 0, তাই bn−1 = 1, আর v = u(B) − 2n; অর্থাৎ u(B) = v + 2n.
- C17 §6.3.1.3: unsigned-এ রূপান্তরের ফল সেই একমাত্র u, যেখানে 0 ≤ u < 2n আর u ≡ v (mod 2n).
- v + 2n দুটি শর্তই মানে: −2n−1 ≤ v < 0 থেকে 2n−1 ≤ v + 2n < 2n, আর পার্থক্য 2n-এর গুণিতক।
- একমাত্রতার কারণে ফল = v + 2n = u(B), অর্থাৎ ঠিক একই বিট। ∎
তাই compiler-কে এই রূপান্তরে কোনো নির্দেশ বসাতে হয় না; −1-এর 0xFFFFFFFF সরাসরি 4294967295. শুধু পরের নির্দেশটি বদলায় (slt থেকে sltu).
Haat-এর Int-এ (আর C-র int-এ) x == x ⇒ true আর x + 0 ⇒ x বৈধ। IEEE 754 binary64-এ দুটিই অবৈধ; কিন্তু x - 0.0 ⇒ x বৈধ।
- Int-এর অংশ: Haat-এর Int-এর মানগুলো 264 দিয়ে ভাগশেষের গণিত মেনে চলে, যেখানে 0 যোগের একক আর
==সাধারণ সমতা, যা প্রতিফলক (x = x). তাই প্রতিটি x-এ দুই পাশ সমান। (C-র int-এ x + 0 কখনো overflow করে না, তাই undefined behavior-এর প্রশ্নও ওঠে না।) x == x-এর প্রতি-উদাহরণ: x = NaN হলে IEEE-র নিয়মেNaN == NaNমিথ্যা, অথচ rewrite দেয় true.x + 0.0-এর প্রতি-উদাহরণ: x = −0.0. ডিফল্ট rounding-এ −0.0 + 0.0 = +0.0, যার sign বিট আলাদা; 1/ফল −∞-এর বদলে +∞ হয়ে যায়। তাই ফল x নয়।x - 0.0: x = −0.0 হলে −0.0 − 0.0 = −0.0; +0.0 হলে +0.0; NaN হলে NaN; অন্য প্রতিটি x-এ শূন্য বিয়োগ নির্ভুল, তাই ফল x. ∎
সত্যিকারের Clang 22.1.8-এর -O2 output (x86_64-linux-musl, LLVM IR, metadata বাদ) ঠিক এই উপপাদ্য মেনে চলে:
int eq_self_i(int x) { return x == x; } --> ret i32 1
int eq_self_d(double x) { return x == x; } --> %2 = fcmp ord double %0, 0.0
int add_zero_i(int x) { return x + 0; } --> ret i32 %0
double add_zero_d(double x) { return x + 0.0; } --> %2 = fadd double %0, 0.0
double sub_zero_d(double x) { return x - 0.0; } --> ret double %0
Int-এর দুটি function একটি নির্দেশে নেমে এসেছে; Clang int-এর x == x-এ সতর্কও করেছে (self-comparison always evaluates to true). Double-এর x == x বদলে হয়েছে fcmp ord, অর্থাৎ “x NaN নয় তো?”: optimizer আসল অর্থটিই রেখেছে। x + 0.0-এর যোগ রয়ে গেছে, আর x - 0.0 পুরোপুরি মুছে গেছে। -ffast-math দিলে compiler-কে ধরে নিতে বলা হয় যে NaN বা −0.0 আসবে না, তখন এই rewrite-গুলো চালু হয়; তাই fast-math আর অর্থ-রক্ষা একসাথে চলে না। Haat-এর optimizer (পর্ব ৬৫) নিশ্চিন্তে x + 0 মুছতে পারবে, কারণ Haat-এ শুধু Int আছে।
আরও গভীরে: IEEE 754-এর আগে প্রতিটি কোম্পানির কম্পিউটারে floating point-এর নিয়ম আলাদা ছিল, একই program যন্ত্রভেদে আলাদা উত্তর দিত। Intel-এর 8087 coprocessor (১৯৮০) Kahan-এর পরামর্শে তখনকার খসড়া নিয়ম মেনে বানানো হয়, আর ১৯৮৫ সালে standard গৃহীত হয়। 8087-এর উত্তরসূরি x87 ভেতরে ৮০-বিটে হিসাব করত, ফলে একই C কোড অনেক সময় double-এর চেয়ে বেশি নির্ভুলতায় চলত আর “double rounding”-এ ভিন্ন ফল দিত; x86-64-এ SSE2 নির্দেশ খাঁটি binary64 ব্যবহার করে বলে এই সমস্যা অনেক কমেছে। LLVM IR-এ প্রতিটি floating-point নির্দেশে nnan, nsz-এর মতো fast-math flag বসানো যায়, যা নির্দেশ ধরে ধরে বলে দেয় কোন IEEE নিয়ম ভাঙা চলবে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- Primitive type কী? ভাষার মৌলিক type, অন্য type জুড়ে তৈরি নয়; মানের সেট আর operation ভাষাই ঠিক করে (যেমন Java-র আটটি)।
- C-তে
-1 < 1uকত, কেন? 0; usual arithmetic conversions −1-কে unsigned int-এ নেয়, মান 4294967295. - binary64-এর গঠন? ১ sign, ১১ exponent (bias 1023), ৫২ fraction, লুকানো 1 মিলিয়ে ৫৩ বিট নির্ভুলতা।
0.1 + 0.2 == 0.3কেন মিথ্যা? 0.1, 0.2, 0.3 কোনোটিই binary-তে হুবহু নেই; গোল করা মানগুলোর যোগফল 0.3-এর double-এর পাশের double.- টাকার হিসাবে কোন type? সবচেয়ে ছোট এককে integer (পয়সা) বা decimal type, স্পষ্ট rounding নিয়মসহ; কখনো binary float নয়।
৯ · AI-এর যুগে primitive type
সংখ্যার প্রশ্নে AI assistant-এর উত্তর প্রায়ই এক ভাষার নিয়মকে সব ভাষায় চাপায়: “long মানে ৬৪ বিট”, “char signed”, “float-এ টাকা রাখলে সমস্যা নেই, round করলেই হলো”। এই বিষয়ে বারবার দেখা ভুল আর যাচাইয়ের উপায়:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
| “C-তে long ৬৪ বিট”, “char signed”: এক target-এর ফলকে নিয়ম বলা | দুটি target-এ (-target) compile করে sizeof, CHAR_MIN দেখা; int64_t ব্যবহার |
| Signed-unsigned তুলনার ফল ভুল বলা, বা warning-কে অপ্রয়োজনীয় বলা | Usual arithmetic conversions হাতে চালানো; -Wall -Wextra-এ -Wsign-compare শূন্য রাখা |
Float-এ টাকা, == দিয়ে double তুলনা | Decimal বা পয়সায় Int; কোণের মান (0.1 দশবার যোগ, 2.675-এর round) দিয়ে test |
| “NaN == NaN সত্য”, “−0.0 আর 0.0 সব দিক থেকে এক” | ভাষায় চালিয়ে দেখা; IEEE 754-এর তুলনার নিয়ম আর ভাষার নিজের সমতা (Object.is, Java-র Double.equals) আলাদা করে পড়া |
“Optimize” করতে x + 0.0 মুছে দেওয়া বা -ffast-math পরামর্শ দেওয়া | -O2 -emit-llvm দেখা; NaN, −0.0, ∞ দিয়ে আগের আর পরের সংস্করণ চালিয়ে মেলানো |
| বিট-প্যাটার্ন বা hex ভুল হিসাব করা | struct.pack বা DataView দিয়ে বিট বের করে মেলানো |
AI-কে ভালোভাবে কাজে লাগাতে ভাষা, version আর target বলে দিন, আর প্রতিটি দাবির জন্য যাচাইয়ের উপায় চান:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Java কেন সব যন্ত্রে int-কে ৩২ বিটে বেঁধে দিল, আর C কেন দেয়নি?
দুটি ভাষা জন্মেছে দুটি আলাদা জগতে। C তৈরি হয় ১৯৭০-এর দশকের শুরুতে, Unix-কে নানা যন্ত্রে নিয়ে যাওয়ার জন্য, আর তখনকার যন্ত্রগুলোর word-এর আকার ছিল খুব আলাদা। Kernighan আর Ritchie-র বইয়ের ১৯৭৮ সালের প্রথম সংস্করণে একটি টেবিল আছে, যেখানে PDP-11-এ int ১৬ বিট, আর Honeywell 6000-এ int ৩৬ বিট ও char ৯ বিট। C-র লক্ষ্য ছিল প্রতিটি যন্ত্রে সবচেয়ে স্বাভাবিক, সবচেয়ে দ্রুত আকারটি ব্যবহার করা: int মানে “এই যন্ত্রের স্বাভাবিক integer”. তাই standard শুধু ন্যূনতম সীমা দেয়, বাকিটা implementation-defined.
Java এল ১৯৯৫ সালে, “একবার লিখুন, সবখানে চালান” প্রতিশ্রুতি নিয়ে। Bytecode এক যন্ত্রে compile হয়ে আরেক যন্ত্রে চলে, তাই int-এর আকার যন্ত্রভেদে বদলালে প্রতিশ্রুতিটিই ভাঙে। Java Language Specification তাই byte, short, int, long-কে ৮, ১৬, ৩২, ৬৪ বিটের two's complement বলে বেঁধে দিয়েছে, আর float, double-কে IEEE 754-এ। floating point-এ Java কিছুদিন আপসও করেছিল: পুরোনো x87 hardware-এ দ্রুত চলার জন্য non-strict নিয়ম ছাড়া ছিল, আর Java 17 (JEP 306) আবার সবখানে কঠোর একই নিয়ম ফিরিয়ে আনে।
দাম কোথায়? ৩৬-বিটের যন্ত্রে Java-কে প্রতিটি হিসাবের পরে বিট কেটে ৩২-বিট বানাতে হতো; আজকের ৩২/৬৪-বিট জগতে এই খরচ প্রায় নেই, কারণ সব প্রচলিত CPU এই আকারগুলো সরাসরি সমর্থন করে। C নিজেও ধীরে ধীরে Java-র দিকে সরেছে: C99-এর <stdint.h> নির্দিষ্ট আকারের int32_t দিল, আর C23 signed integer-এর রূপ two's complement বাধ্যতামূলক করল।
মূল উপলব্ধি: type-এর আকার একটি portability বনাম efficiency-র সিদ্ধান্ত। যন্ত্রগুলো একরকম হয়ে যাওয়ায় নির্দিষ্ট আকারের দাম কমেছে, তাই নতুন ভাষাগুলো (Java, Rust, Go, Haat) আকার নামেই বা specification-এ বেঁধে দেয়।
প্র ০২0.1 + 0.2 != 0.3 — এটা কি floating point-এর “bug”? Hardware কেন দশ-ভিত্তিক হিসাব করে না?
Bug নয়, নকশার সচেতন আপস। Binary floating point-এর লক্ষ্য বিজ্ঞান আর প্রকৌশলের হিসাব: খুব বড় থেকে খুব ছোট সংখ্যা, প্রতিটি হিসাবে সীমিত আপেক্ষিক ভুল, আর দ্রুত hardware. ভিত্তি ২ হলে circuit সবচেয়ে সরল আর দ্রুত, আর একই বিটে নির্ভুলতা সবচেয়ে বেশি। পদার্থবিদ্যার মাপজোখ এমনিতেই আনুমানিক, তাই 0.1-এর ১৭তম অঙ্কে 5 × 10−18-এর ভুল সেখানে কোনো সমস্যা নয়।
সমস্যা হয় যখন মানুষের দশমিক নিয়মের হিসাব (টাকা, ভ্যাট, শতাংশ) binary-তে করা হয়, যেখানে প্রত্যাশা হুবহু মিল। এজন্য IEEE 754-2008 দশ-ভিত্তিক format-ও সংজ্ঞায়িত করেছে (decimal64, decimal128), আর IBM-এর কিছু প্রসেসর (যেমন POWER6, ২০০৭ সালের দিকে) hardware-এ দশমিক হিসাব যোগ করেছিল। তবু সাধারণ CPU-তে এটি এখনো বিরল, কারণ দশমিক circuit বড় ও ধীর, আর বেশিরভাগ ব্যবহারকারীর দরকার নেই। ভাষাগুলো তাই software-এ Decimal দেয়: Python-এর decimal (General Decimal Arithmetic specification অনুযায়ী), Java-র BigDecimal, C#-এর decimal.
JavaScript-এর গল্প শিক্ষণীয়: এর একমাত্র সাধারণ সংখ্যা-type binary64, তাই web-এর টাকার হিসাবে বহু বছর ধরে লাইব্রেরি বা পয়সায় integer-এর কৌশল লাগে। ভাষায় একটি Decimal type যোগের প্রস্তাব নিয়ে আলোচনা চলছে বলে জানা যায়, তবে তা এখনো standard-এর অংশ নয়।
মূল উপলব্ধি: floating point-এর “ভুল” আসলে প্রতিশ্রুতির পার্থক্য: binary float প্রতিশ্রুতি দেয় সীমিত আপেক্ষিক ভুলের, হুবহু দশমিকের নয়। যে কাজে হুবহু দশমিক দরকার, সেখানে type-টাই বদলাতে হবে, round() দিয়ে ঢাকা যাবে না।
প্র ০৩NaN কেন নিজের সমান নয়? এই সিদ্ধান্তের দাম কে দেয়?
NaN মানে “অর্থহীন হিসাবের ফল”, যেমন 0/0 বা ∞ − ∞. দুটি NaN দুটি আলাদা অর্থহীন হিসাব থেকে আসতে পারে, তাই তাদের “সমান” বলাও অর্থহীন; IEEE 754 সিদ্ধান্ত নিল NaN-এর সঙ্গে প্রতিটি ক্রম-তুলনা আর == মিথ্যা। প্রচলিত একটি ব্যাখ্যা অনুযায়ী আরেকটি ব্যবহারিক কারণও ছিল: যখন প্রায় কোনো ভাষায় isnan() ছিল না, তখন x != x লিখেই NaN চেনা যেত। তার ওপর NaN হিসাবের মধ্য দিয়ে ছড়িয়ে পড়ে, ফলে মাঝপথে একটি ভুল হলে শেষ ফলেই তা দেখা যায়, program থামে না।
দাম দিতে হয় ভাষা আর library-কে। Sort algorithm ধরে নেয় তুলনা একটি পূর্ণ ক্রম; NaN থাকলে এই ধারণা ভাঙে, আর ফল অনির্ভরযোগ্য হতে পারে। Hash table ধরে নেয় একটি key নিজের সমান; NaN key রাখলে আর খুঁজে পাওয়া কঠিন। ভাষাগুলো তাই নিজের মতো জোড়াতালি দিয়েছে। Java-র Double.equals IEEE মানে না: NaN-কে নিজের সমান ধরে আর −0.0 ও 0.0-কে আলাদা, যাতে collection ঠিকমতো চলে। JavaScript-এ [NaN].includes(NaN) true কিন্তু [NaN].indexOf(NaN) −1, কারণ দুটি method দুই রকম সমতা ব্যবহার করে। Python-এ একই NaN object list-এ খুঁজলে পাওয়া যায় (পরিচয় আগে দেখা হয়), কিন্তু দুটি আলাদা float('nan') পাওয়া যায় না। IEEE 754-2008 সমস্যাটি স্বীকার করে একটি আলাদা totalOrder সংজ্ঞায়িত করেছে।
Compiler-এর দামও আছে, অংশ ৮-এ দেখেছেন: x == x double-এ true বানানো যায় না।
মূল উপলব্ধি: একটি primitive type-এর “সমতা” কোনো স্বতঃসিদ্ধ নয়, নকশার সিদ্ধান্ত। একই ভাষায় একাধিক সমতা থাকতে পারে, আর কোনটি কোথায় খাটে তা জানা না থাকলে ভুল নীরবে ঢোকে।
প্র ০৪Haat-এ Bool আলাদা type আর কোনো implicit conversion নেই — এতে লেখা কি অযথা কঠিন হলো না?
লেখা সামান্য লম্বা হয়েছে, তা সত্যি: if stock {-এর বদলে if stock > 0 {. কিন্তু বদলে কী পাওয়া গেল, দেখুন। C-র সবচেয়ে পুরোনো ভুলগুলোর একটি if (x = 0), যা বৈধ কারণ int-ই শর্ত হতে পারে; পর্ব ০৬-এ দেখেছেন। Python-এর truthiness-এ if items: সুন্দর, কিন্তু if count: লিখলে 0 আর None একসাথে মিথ্যা হয়, অথচ “গণনা শূন্য” আর “গণনাই হয়নি” আলাদা অবস্থা। Python-এ bool এসেছে ২০০৩ সালে (Python 2.3, PEP 285), পুরোনো কোড না ভাঙতে int-এর subclass হিসেবে; তাই আজও True + True == 2. এটি নকশা নয়, ইতিহাসের দায়।
সংখ্যার implicit conversion-এর ক্ষেত্রেও একই হিসাব। অংশ ৩-এ দেখেছেন C-র নিয়মে -1L < 1u target বদলালে উল্টে যায়, আর কোডে তার কোনো চিহ্ন নেই। Go আর Rust তাই সংখ্যার type মেশাতে স্পষ্ট রূপান্তর বাধ্য করে (Rust-এ as, Go-তে int64(x)); Haat একধাপ এগিয়ে integer type-ই একটি রেখেছে।
Implementation-এর দিকেও লাভ: type checker-এর নিয়ম ছোট আর স্পষ্ট (T-Eq-এ দুই পাশে একই τ), রূপান্তরের কোনো টেবিল লাগে না, আর ভুলের বার্তা নির্দিষ্ট: type mismatch: expected Bool, found Int. C compiler-কে usual arithmetic conversions-এর পুরো যন্ত্র বানাতে হয়, অংশ ৩-এর simulator-এর মতো, আর প্রতিটি data model-এ আলাদা ফল সামলাতে হয়।
মূল উপলব্ধি: implicit conversion writability কেনে readability আর reliability দিয়ে। শেখার আর হিসাবের ভাষায় (Haat-এর মতো) স্পষ্টতাই বেশি মূল্যবান; কয়েকটি বাড়তি অক্ষরের দামে পুরো একটি ভুলের শ্রেণি চালানোর আগেই ধরা পড়ে।
প্র ০৫Python-এর int কীভাবে “সীমাহীন” হয়, আর তার দাম কী?
CPython-এ একটি int হলো heap-এ রাখা একটি object, যার ভেতরে সংখ্যাটি অনেকগুলো “অঙ্কে” ভাগ করা, তবে দশমিক অঙ্ক নয়: সাধারণ ৬৪-বিট build-এ প্রতিটি অঙ্ক ৩০ বিটের (sys.int_info এই লেখকের CPython 3.14.4-এ দেখায় bits_per_digit=30). যোগ বা গুণ মানে স্কুলের খাতায় হাতে করা হিসাবের মতো অঙ্ক ধরে ধরে কাজ, প্রয়োজনে নতুন অঙ্ক যোগ। তাই overflow হয় না; সংখ্যা বড় হলে object-ও বড় হয়।
দাম তিনটি। এক, প্রতিটি যোগে type পরীক্ষা, আকার পরীক্ষা আর প্রায়ই নতুন object বানানো; Haat বা C-র মতো একটি CPU নির্দেশ নয়। CPython ছোট সংখ্যাগুলোর জন্য বিশেষ দ্রুত পথ রাখে, আর −5 থেকে 256 পর্যন্ত int আগে থেকে বানিয়ে রাখে (এটি CPython-এর বাস্তবায়নের খুঁটিনাটি, ভাষার নিয়ম নয়)। দুই, মেমরি: সবচেয়ে ছোট int-ও কয়েক ডজন byte (পর্ব ০৬-এ মাপা হয়েছে)। তিন, সময়ের অনুমান কঠিন: খুব বড় সংখ্যায় কিছু কাজ খুব ধীর হতে পারে। ২০২২ সালে একটি নিরাপত্তা-সমস্যা (CVE-2020-10735) ধরা পড়ে: খুব লম্বা দশমিক string-কে int বানাতে সময় অঙ্কের সংখ্যার বর্গের অনুপাতে বাড়ে, যা দিয়ে server আটকে দেওয়া যেত। Python 3.11 (আর পুরোনো সংস্করণের নিরাপত্তা-আপডেট) তাই ডিফল্টে ৪৩০০ অঙ্কের সীমা বসায়, যা sys.int_info-এর default_max_str_digits=4300-এ দেখা যায়।
অন্য ভাষাগুলো দুই রকম integer পাশাপাশি রাখে: Haskell-এ নির্দিষ্ট আকারের Int আর সীমাহীন Integer, JavaScript-এ number আর BigInt, Java-তে long আর BigInteger. বেছে নেওয়ার দায় programmer-এর।
মূল উপলব্ধি: “সীমাহীন integer” নির্ভুলতা কেনে পূর্বানুমেয় খরচের বিনিময়ে। কোন ভাষা কোনটি ডিফল্ট রাখবে, তা ঠিক করে ভাষার লক্ষ্য: Python সঠিক উত্তরকে আগে রাখে, Haat আর C রাখে নির্দিষ্ট খরচ আর যন্ত্রের সঙ্গে সরাসরি মিল।
অনুশীলন
প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।
-
হাতে decode আর encode: (ক) binary64 বিট-প্যাটার্ন
0xC05A400000000000-এর দশমিক মান কত? (খ) 1040.0 (দুই কেজি চালের অর্ডারের ১০৪০ টাকা) binary64-এ লিখলে hex কী হবে?(ক) C = 1100, তাই sign বিট 1 (ঋণাত্মক), আর exponent-এর প্রথম তিন বিট 100. পুরো exponent: 100 0000 0101 = 0x405 = 1029, ঘাত 1029 − 1023 = 6. Fraction শুরু হয় A, 4 থেকে: 1010 0100 0…, অর্থাৎ 1.1010010₂ = 1 + 1/2 + 1/8 + 1/64 = 1.640625. মান −1.640625 × 64 = −105.0.
(খ) 1040 = 10000010000₂ = 1.0000010000₂ × 210. Exponent field 10 + 1023 = 1033 = 0x409, sign 0, তাই প্রথম তিন hex অঙ্ক 409. Fraction-এর প্রথম দশ বিট 0000010000, বাকি শূন্য: hex-এ 0, 4, 0, …. উত্তর 0x4090400000000000.
যাচাই (CPython 3.14.4):
struct.unpack('>d', bytes.fromhex('C05A400000000000'))[0]দেয়-105.0, আরstruct.pack('>d', 1040.0).hex()দেয়4090400000000000. -
ভুল খুঁজুন আর প্রমাণ করুন: বাজারঘরের কুপন-কোডে পাশাপাশি একই অক্ষর কতবার আছে, তা গুনতে নিচের C function লেখা হলো। খালি কোড
""দিলে কী ঘটবে, কেন? ঠিক করুন।int count_pairs(const char *code) { int pairs = 0; for (int i = 0; i < strlen(code) - 1; i++) if (code[i] == code[i + 1]) pairs++; return pairs; }strlenফেরত দেয়size_t, একটি unsigned type. খালি string-এstrlen(code) - 1= 0 − 1, unsigned-এ যা wrap করে সবচেয়ে বড় মান হয়। সত্যিকারের run (Clang 22.1.8, Windows x64) ছাপলstrlen("") - 1 = 18446744073709551615. তারপর তুলনাi < …:intআরsize_t(৬৪-বিট unsigned) মিশল; usual arithmetic conversions-এর নিয়ম ৪-এ সাধারণ type unsigned, তাই শর্ত প্রায় চিরকাল সত্য। Loop খালি string-এর বাইরের মেমরি পড়তে থাকে: undefined behavior (এখানে ইচ্ছা করে চালানো হয়নি)। “আধা-প্রমাণ”: উপপাদ্য ২০.১ অনুযায়ী unsigned-এ নেওয়া মানে 264 দিয়ে ভাগশেষ, আর 0 − 1 ≡ 264 − 1.Compiler আগেই সতর্ক করে:
loop.c:4:23: warning: comparison of integers of different signs: 'int' and '__size_t' (aka 'unsigned long') [-Wsign-compare](x86_64-linux-musl target,-Wall -Wextra). ঠিক করার উপায়: বিয়োগ না করে যোগ করুন,for (size_t i = 0; i + 1 < strlen(code); i++). এখন খালি string-এ 0 + 1 < 0 মিথ্যা, loop চলে না, আর দুই পাশইsize_t. -
ভাষার feature নকশা (Haat-এর বর্ধিত রূপ): Haat-এ একটি
Floattype (binary64) যোগ করতে চান। (ক) Int আর Float মেশালে কী হবে? (খ)==Float-এ চলবে কি? (গ)1.0 / 0.0-এর ফল কী হবে? Type checker-এর binary operator-এর নিয়মটি Python-এ লিখুন।একটি সম্ভাব্য নকশা (একমাত্র সঠিক উত্তর নয়): (ক) Haat-এর নীতি মেনে কোনো implicit conversion নয়;
1 + 2.5type error, রূপান্তর চাইলে স্পষ্ট function (যেমনto_float(1)). (খ) NaN-এর কারণে==বিপজ্জনক; একটি পথ হলো Float-এ==নিষেধ করে ক্রম-তুলনা (<) আর একটিapprox_eqfunction দেওয়া। (গ) Int-এর ভাগে শূন্য runtime error; Float-এ IEEE মেনে ∞ দেওয়া যায়, অথবা সামঞ্জস্যের জন্য error. যেটিই বাছুন, interpreter আর VM-কে একই নিয়ম মানতে হবে, আর VM-এ নতুন opcode (যেমনFADD) বা চলার সময় type দেখে কাজ লাগবে।# Haat-এর বর্ধিত রূপ (নকশার খসড়া, reference-এ নেই) def check_binary(op, lt, rt): if op in {"+", "-", "*", "/"}: if lt == rt and lt in ("Int", "Float"): return lt if op == "+" and lt == rt == "Str": return "Str" return f"error: type mismatch: expected {lt}, found {rt}" if op in ("<", "<=", ">", ">="): return "Bool" if lt == rt and lt in ("Int", "Float") else "error" if op in ("==", "!="): if lt == rt == "Float": return "error: operator '==' cannot compare values of type Float" return "Bool" if lt == rt and lt in ("Int", "Bool", "Str") else "error"লেখকের CPython 3.14.4-এ চালিয়ে:
('+', 'Int', 'Float')দেয়error: type mismatch: expected Int, found Float;('<', 'Float', 'Float')দেয়Bool;('==', 'Float', 'Float')দেয় error. বার্তাগুলো reference-এর বার্তার ধাঁচেই রাখা হয়েছে। -
আউটপুট অনুমান করুন: চালানোর আগে লিখুন। Python 3.14: (ক)
0.1 * 3 == 0.3(খ)round(0.5), round(1.5), round(2.5)(গ)int(2.9999999999999999)(ঘ)True + True. JavaScript: (ঙ)9007199254740993 === 9007199254740992. C: (চ)(char)200-এর মান x86-64 আর riscv64 Linux-এ।সত্যিকারের run (CPython 3.14.4, Node.js 24.15.0, Clang 22.1.8): (ক)
False; 0.1 * 3 = 0.30000000000000004. (খ)0 2 2: Python 3-এরroundমাঝখানে পড়লে জোড়ে যায় (ties-to-even), আর 0.5, 1.5, 2.5 binary-তে হুবহু আছে বলে সত্যিই “মাঝখানে” পড়ে। (গ)3: literal-টি নিজেই গোল হয়ে 3.0 double হয়, int() কিছু কাটার সুযোগই পায় না। (ঘ)2, কারণ bool int-এর subclass. (ঙ)true: 9007199254740993 number-এ রাখা যায় না, গোল হয়ে 9007199254740992 হয়। (চ) x86-64-এ −56 (char signed: 200 − 256), riscv64-linux-musl-এর IR-এ 200 (char unsigned). এক ঘর অনুমানও ভুল হলে নিজের মডেলটি আবার দেখুন: কোথায় গোল হলো, কোন type-এ রূপান্তর হলো।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমC-তে a < b (a: int, b: unsigned int) দেখে compiler-এর কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- দুই operand-এর type বের করা (int আর unsigned int)
- Integer promotion: int-এর চেয়ে ছোট type থাকলে int বানানো
- Usual arithmetic conversions: একটি সাধারণ type বাছাই
- দুটি মানকে সাধারণ type-এ রূপান্তর (−1 থেকে 4294967295)
- সাধারণ type অনুযায়ী তুলনার নির্দেশ বাছাই (unsigned হলে
sltu)
C17 standard নিচের কোনটির নিশ্চয়তা দেয়?
intঠিক ৩২ বিটlongঠিক ৬৪ বিটlong longঅন্তত ৬৪ বিটcharসবসময় signed
C-তে int a = -1; unsigned int b = 1; হলে a < b-এর মান কত, আর কেন?
- 1, কারণ −1 < 1
- 0, কারণ −1 unsigned int-এ 4294967295 হয়ে যায়
- Compile error হয়
- Undefined behavior, কিছুই বলা যায় না
IEEE 754 binary64-এ exponent field-এর মান 1023 আর fraction শূন্য, sign 0. সংখ্যাটি কত?
- 0
- 21023
- +∞
- 1.0
IEEE 754 অনুযায়ী double x NaN হলে নিচের কোনটি সত্য?
x != xসত্যx == xসত্যx < 0অথবাx > 0, একটি অবশ্যই সত্যx + 1একটি সাধারণ সংখ্যা
একটি দোকানের হিসাব-program-এ টাকার পরিমাণ রাখার সবচেয়ে নিরাপদ উপায় কোনটি?
- টাকায়
double, প্রতিবার ছাপার সময় round - টাকায়
float, জায়গা বাঁচাতে - সবচেয়ে ছোট এককে (পয়সা) integer, অথবা Decimal type, স্পষ্ট rounding নিয়মসহ
- টাকা string হিসেবে রাখা
শেখার ভাষা Haat-এ (Bool আলাদা type, কোনো implicit conversion নেই) let ok: Bool = 0; লিখলে কী হয়?
- ok হয় false, কারণ 0 মানে মিথ্যা
- চালানোর আগেই type error: expected Bool, found Int
- Program চলে, আর ok ব্যবহার করার সময় runtime error
- শুধু একটি warning, তারপর ok = false
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Type = মানের সেট + operation-এর সেট, আর বাস্তবায়নে representation; একই বিট type অনুযায়ী আলাদা মান আর আলাদা নির্দেশ পায় (
sltবনামsltu). - Integer-এর আকার: C-তে implementation-defined (LP64-এ long ৬৪, LLP64-এ ৩২), Java-তে নির্দিষ্ট, Python-এ সীমাহীন, Haat-এ ৬৪-বিট wrap.
- C-র usual arithmetic conversions signed-কে নীরবে unsigned বানাতে পারে:
-1 < 1uমিথ্যা;-Wsign-compareচালু রাখুন। - binary64 = ১ + ১১ + ৫২ বিট, bias 1023, লুকানো 1; 0.1 গোল হয়, NaN নিজের সমান নয়, −0.0 == 0.0; তাই
x == xবাx + 0.0double-এ মুছে ফেলা যায় না। - টাকা Decimal বা পয়সায় Int-এ; Haat-এর Bool আলাদা type; C-র char-এর signedness আর enum-এর int-রূপ যন্ত্রভেদে ও নিরাপত্তায় ফাঁদ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ২১ · String আর Unicode — code point, UTF-8 আর বাংলা লেখাপরবর্তী পর্বCharacter থেকে string: encoding আর দৈর্ঘ্যের চার মানে।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ০৬ · ভাষা নকশার লক্ষ্য আর আপসএই কোর্সেInteger overflow পাঁচ ভাষায়, সত্যিকারের run-সহ।
- Floating point — IEEE 754, normalized, denormal আর বিশেষ মানপাশের ট্র্যাকbinary32/binary64-এর বিট-স্তরের খুঁটিনাটি।
- টাইপ কনভার্শন — C যখন নীরবে মানের টাইপ বদলে দেয়পাশের ট্র্যাকC-র রূপান্তরের নিয়ম আরও উদাহরণসহ।
- সংখ্যা ও হিসাব — int, float-এর ফাঁদ আর Decimalপাশের ট্র্যাকPython-এ টাকার নিরাপদ হিসাব।