সংখ্যার ভেতরের গল্প — number, floating-point, Math আর BigInt

১ · একটিই number টাইপ — ছোট-বড়, পূর্ণ-দশমিক সবই এক ঘরে

একটি পরিচিত দৃশ্য দিয়ে শুরু করি। নাদিয়া একটি অনলাইন দোকানের কার্ট বানাচ্ছেন। তিনটি পণ্যের দাম ১২০.৪৫, ৮০.১০ আর ৪৫.৩০ টাকা। যোগফল দেখানোর লাইনে স্ক্রিনে এলো 245.85000000000002. নাদিয়া ভাবলেন ব্রাউজারে বাগ আছে। আসলে বাগ নেই — কম্পিউটার যেভাবে সংখ্যা রাখে, এটি তারই স্বাভাবিক ফল। এই পর্ব শেষে আপনি ব্যাখ্যা করতে পারবেন এই শেষের 2 কোথা থেকে এলো, আর টাকার হিসাব কীভাবে প্রতি পয়সায় নির্ভুল রাখা যায়।

C বা Java-তে সংখ্যার অনেক টাইপ — int, long, float, double. JavaScript-এ সাধারণ কাজের জন্য টাইপ মাত্র একটি: number. 7, -3, 3.14, 1e21 — সবার typeof হলো "number". ভেতরে প্রতিটি number হলো একটি floating-point সংখ্যা, ৬৪টি বিটে রাখা — যাকে বলে double precision বা সংক্ষেপে double. পর্ব ০৬-এ দেখেছেন JavaScript-এর আটটি টাইপের মধ্যে number একটি; এখানে আমরা তার ভেতরটা খুলব।

সংখ্যা লেখার নানা রূপ — literal

কোডে সরাসরি লেখা সংখ্যাকে বলে literal. একই সংখ্যা কয়েকভাবে লেখা যায়, আর লম্বা সংখ্যা পড়ার সুবিধার জন্য আছে numeric separator (_)।

একটি পুরোনো ফাঁদ: শুরুতে 0 দিয়ে 017 লিখলে পুরোনো নিয়মে সেটি octal (মান ১৫) ধরা হতো। Strict mode-এ এটি SyntaxError. তাই octal লিখতে চাইলে সবসময় 0o17, আর দশমিক সংখ্যার শুরুতে বাড়তি শূন্য দেবেন না। আরেকটি বিষয়: 1_000 কোডে চলে, কিন্তু Number("1_000") দেয় NaN — separator শুধু source code-এর জন্য, string পড়ার নিয়মে নেই।

২ · IEEE 754-এর ভেতরে — ৬৪টি বিটের তিন ভাগ

বিজ্ঞানের বইয়ে খুব বড় বা ছোট সংখ্যা লেখা হয় এভাবে: পৃথিবী থেকে সূর্যের দূরত্ব প্রায় 1.496 × 10¹¹ মিটার। এখানে তিনটি অংশ — চিহ্ন (+), অঙ্কগুলো (1.496) আর ঘাত (11). দশমিক বিন্দুটি ঘাতের সাথে “ভেসে” সরে যায় — এজন্যই নাম floating-point. কম্পিউটার ঠিক এই কাজটি করে, শুধু ১০-এর বদলে ২-এর ঘাতে।

এই নকশার দুটি ফল মনে রাখুন। এক: mantissa-য় ৫২টি বিট (আর লুকানো একটি “1”) — অর্থাৎ যেকোনো সংখ্যার মাত্র ৫৩টি binary অঙ্ক রাখা যায়, দশমিকে প্রায় ১৫–১৭টি অঙ্ক। তার পরের সব অঙ্ক কেটে কাছের মানে গোল করা হয়। দুই: exponent-এর ১১ বিটের কারণে পরিসর বিশাল — প্রায় 10⁻³⁰⁸ থেকে 10³⁰⁸ (Number.MAX_VALUE = 1.7976931348623157e+308). পরিসর বড়, কিন্তু অঙ্কের সংখ্যা সীমিত — এই দুইয়ের টানাপোড়েনই পুরো পর্বের মূল বিষয়।

কোন দশমিক binary-তে হুবহু লেখা যায়? যার হর (denominator) শুধু ২-এর ঘাত — যেমন 0.5 (১/২), 0.25 (১/৪), 0.375 (৩/৮)। 0.1, 0.2, 0.3, 0.7 — এদের হরে ৫ আছে, তাই অন্তহীন। নিচের ডায়াগ্রামে ধাপে ধাপে দেখুন 0.1 + 0.2-এর আসল যাত্রা।

0.1 × 2 = 0.2  → 0
0.2 × 2 = 0.4  → 0
0.4 × 2 = 0.8  → 0
0.8 × 2 = 1.6  → 1
0.6 × 2 = 1.2  → 1
0.2 × 2 = 0.4  → 0   ← আবার 0.2! চক্র শুরু
0.1 = 0.00011 0011 0011 0011 … (চিরকাল)

লেখেন:       0.1
জমা থাকে:    0.1000000000000000055511151231257827…
(0.1).toFixed(20) → "0.10000000000000000555"

0.2 জমা থাকে: 0.2000000000000000111022302462515654…  (একটু বেশি)
0.3 জমা থাকে: 0.2999999999999999888977697537484345…  (একটু কম)

সঠিক যোগফল:   0.30000000000000001665…
নিচের double:  0.29999999999999998889…  (= literal 0.3)
ওপরের double:  0.30000000000000004440…
ঠিক মাঝখানে → নিয়ম “ties to even” → ওপরেরটি

> 0.1 + 0.2
0.30000000000000004
> 0.1 + 0.2 === 0.3
false     // দুটি আলাদা double

৩ · দশমিক তুলনা, Number.EPSILON আর safe integer-এর সীমা

তাহলে দুটি দশমিক সমান কি না কীভাবে দেখবেন? উত্তর: “হুবহু সমান” না দেখে দেখুন “যথেষ্ট কাছাকাছি” কি না। এর জন্য একটি ছোট সহনসীমা (tolerance) লাগে। JavaScript দেয় Number.EPSILON — 1 আর তার ঠিক পরের double-এর ব্যবধান, প্রায় 2.22e-16.

• ১-এর কাছাকাছি সংখ্যায়: Math.abs(a - b) < Number.EPSILON যথেষ্ট।
• বড় সংখ্যায়: double-এর ফাঁক সংখ্যার আকারের সাথে বাড়ে — 1000-এর কাছে ফাঁক ১-এর কাছের ফাঁকের প্রায় ৫০০ গুণ। তাই সহনসীমাকেও আকার অনুযায়ী বাড়ান: Number.EPSILON * Math.max(1, |a|, |b|).
• ব্যবসার হিসাবে: সমস্যার মাপে সহনসীমা ঠিক করুন — দূরত্ব মাপায় ১ মিলিমিটার, টাকায় আধা পয়সা। অথবা আরও ভালো: integer-এ কাজ করুন (অংশ ৭)।

2⁵³ — যেখানে পূর্ণসংখ্যাও ফসকে যায়

Mantissa-য় ৫৩ বিট — তাই 0 থেকে 2⁵³ পর্যন্ত প্রতিটি পূর্ণসংখ্যা হুবহু রাখা যায়। এর সবচেয়ে বড় “নিরাপদ” মান হলো Number.MAX_SAFE_INTEGER = 2⁵³ − 1 = 9007199254740991 (প্রায় ৯০ কোটি কোটি)। Safe integer মানে: এই সংখ্যা আর তার প্রতিবেশী দুটিও আলাদা আলাদাভাবে রাখা যায়। সীমার ওপারে কী ঘটে, দেখুন:

… 9007199254740989, 9007199254740990, 9007199254740991
Number.MAX_SAFE_INTEGER = 2**53 - 1

> 2 ** 53
9007199254740992
> Number.isSafeInteger(2 ** 53)
false   // নিজে ঠিক আছে, কিন্তু প্রতিবেশী নেই

double আছে: 9007199254740992, (…993 নেই), 9007199254740994
> 2 ** 53 + 1
9007199254740992   // …993 গোল হয়ে …992
> 2 ** 53 + 1 === 2 ** 53
true

> JSON.parse('{"id": 1234567890123456789}').id
1234567890123456800    // শেষের অঙ্কগুলো বদলে গেছে!
কোনো error নেই, কোনো warning নেই

{"id_str": "1234567890123456789"}   // string হিসেবে পাঠান
BigInt("1234567890123456789")       // হিসাব লাগলে
1234567890123456789n

এবার নিজে চালিয়ে দেখুন। প্রতিটি লাইনের ফল আগে মনে মনে অনুমান করুন, তারপর মিলিয়ে নিন:

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);
console.log((0.1).toFixed(20));       // আসলে কী জমা আছে

// আকার অনুযায়ী সহনসীমা দিয়ে তুলনা
const near = (a, b) =>
  Math.abs(a - b) < Number.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
console.log(near(0.1 + 0.2, 0.3));

console.log(2 ** 53 + 1 === 2 ** 53);
console.log(Number.MAX_SAFE_INTEGER, Number.isSafeInteger(2 ** 53));

const api = JSON.parse('{"id": 1234567890123456789, "idStr": "1234567890123456789"}');
console.log(api.id, api.idStr);

console.log(Object.is(-0, 0), -0 === 0, 1 / -0);
console.log(Number(""), Number("12px"), parseInt("12px", 10));

৪ · বিশেষ মান — Infinity, -0, NaN আর Number.is… পরিবার

IEEE 754 শুধু সাধারণ সংখ্যা নয়, কয়েকটি বিশেষ মানও রাখে। C-তে পূর্ণসংখ্যাকে ০ দিয়ে ভাগ করলে প্রোগ্রাম crash করতে পারে; JavaScript-এ কখনো crash হয় না — বদলে আসে এই বিশেষ মানগুলো। সুবিধা হলো প্রোগ্রাম থামে না; অসুবিধা হলো ভুলটি নীরবে সামনে এগিয়ে যায়।

-0 কোথায় কাজে লাগে? দিক বোঝাতে — যেমন একটি গাড়ির বেগ গোল করে শূন্য হলেও সে কোন দিকে যাচ্ছিল, সেই তথ্য sign-এ থেকে যায়। আবার বিপদও আছে: তাপমাত্রা দেখানোর অ্যাপে Math.round(-0.4) থেকে আসা -0 কিছু জায়গায় “-0” হয়ে দেখা দিতে পারে। String(-0) আর JSON.stringify(-0) অবশ্য "0" দেয়। NaN আর coercion-এর মূল নিয়মগুলো পর্ব ০৬-এ আছে; এখানে শুধু যাচাইয়ের সঠিক টুলগুলো দেখি।

৫ · String থেকে সংখ্যা, সংখ্যা থেকে সুন্দর লেখা

ফর্মের ইনপুট, URL, CSV ফাইল, API — বাইরে থেকে আসা প্রায় সব সংখ্যাই আসলে string. তাকে number বানানোর তিনটি প্রধান পথ আছে, আর তিনটির আচরণ বেশ আলাদা।

• Number(s) কড়া: পুরো string (দুই পাশের ফাঁকা বাদে) বৈধ সংখ্যা হতে হবে, নইলে NaN. ব্যবহারকারীর ইনপুট যাচাইয়ে এটিই সাধারণত ঠিক পছন্দ। +s (unary plus) একই কাজ করে।
• parseInt উদার: শুরু থেকে যতদূর অঙ্ক পায় পড়ে, বাকিটা ফেলে দেয়। CSS-এর "12px" পড়তে কাজের, কিন্তু "12abc"-কেও চুপচাপ 12 বানায়।
• Radix সবসময় দিন: parseInt(s, 10). দ্বিতীয় argument না দিলে "0x1F"-এর মতো string-কে hex ধরে নেয়। parseInt("101", 2) → 5 — অন্য ভিত্তির সংখ্যা পড়তেও এটিই পথ।
• parseInt number-এ দেবেন না: parseInt(0.0000005) দেয় 5! কারণ আগে string বানায় — "5e-7" — তারপর শুরুর 5 পড়ে। দশমিক কাটতে Math.trunc ব্যবহার করুন।

সংখ্যা থেকে লেখা — toFixed, toPrecision আর Intl

• toFixed(n): দশমিকের পরে ঠিক n অঙ্ক। (1234.5678).toFixed(2) → "1234.57". মনে রাখুন, ফল string — এর সাথে + করলে যোগ নয়, জোড়া লাগে (পর্ব ০৮)।
• toPrecision(n): মোট n টি অর্থবহ অঙ্ক। (123.456).toPrecision(4) → "123.5", (123456).toPrecision(2) → "1.2e+5". বৈজ্ঞানিক মাপজোখে কাজের।
• Intl.NumberFormat: ভাষা ও দেশের নিয়মে সাজানো। "bn-BD" locale দিলে বাংলা অঙ্ক আর লাখ-কোটির কমা: 1234567.5 হয় ১২,৩৪,৫৬৭.৫; মুদ্রা চাইলে ১২,৩৪,৫৬৭.৫০৳. toLocaleString("bn-BD") একই কাজের ছোট রূপ। তারিখসহ Intl-এর পুরো ব্যবহার পর্ব ২০-এ।

কিন্তু toFixed-এর গোল করা মাঝে মাঝে অবাক করে: (1.005).toFixed(2) দেয় "1.00", "1.01" নয়! কেন — আর অন্য পদ্ধতিগুলো কী দেয় — দেখুন:

> (1.005).toFixed(20)
"1.00499999999999989342"

> (1.005).toFixed(2)
"1.00"   // 1.00499… → নিচে

> 1.005 * 100
100.49999999999999
> Math.round(1.005 * 100) / 100
1

> new Intl.NumberFormat("en", { maximumFractionDigits: 2 }).format(1.005)
"1.01"

100.5 পয়সা → নিয়ম লিখে নিন: Math.round → 101 পয়সা
দেখানোর সময় শুধু format, হিসাব নয়

৬ · Math — গোল করা, বড়-ছোট, ঘাত আর random

Math একটি built-in object — ক্লাস নয়, new Math() লেখা যায় না। এর ভেতরে গণিতের প্রস্তুত function আর ধ্রুবক (Math.PI, Math.E). সবচেয়ে বেশি ভুল হয় চারটি গোল করার function নিয়ে, বিশেষ করে ঋণাত্মক সংখ্যায়।

খেয়াল করুন Math.round(-2.5) → -2, কারণ JavaScript-এ .5 সবসময় +∞-এর দিকে যায়। স্কুলের নিয়মে (শূন্য থেকে দূরে) উত্তর হতো -3. আবার (-1.5).toFixed(0) দেয় "-2" — একই ভাষায় দুই নিয়ম! ঋণাত্মক টাকা (ফেরত, ছাড়) গোল করার আগে নিয়মটি নিশ্চিত করুন।

বাকি কাজের টুল

• Math.abs(x) — পরম মান। দুটি মানের ব্যবধান মাপতে: Math.abs(a - b).
• Math.max / Math.min — অনেকগুলো argument নেয়, array নেয় না। Array থেকে নিতে spread: Math.max(...marks) (পর্ব ১৭)। খালি হলে Math.max() → -Infinity. লাখ লাখ উপাদানের array spread করলে argument-এর সীমা ছাড়িয়ে RangeError হতে পারে — তখন লুপ বা reduce.
• Math.pow(2, 10) বা 2 ** 10 — ঘাত (** ES2016 থেকে)। Math.sqrt বর্গমূল, Math.cbrt ঘনমূল; Math.sqrt(-1) → NaN.
• Math.hypot(3, 4) → 5 — দুটি বিন্দুর দূরত্ব; ভেতরে বড় সংখ্যার বর্গ করেও overflow এড়ায়।
• Math.sign(x) — 1, -1, 0 বা -0: শুধু চিহ্নটুকু।

Integer ভাগ আর ভাগশেষ

JavaScript-এ / সবসময় দশমিক ভাগ: 7 / 2 → 3.5. পূর্ণ ভাগফল চাইলে Math.trunc(7 / 2) → 3, আর ভাগশেষ 7 % 2 → 1. ঋণাত্মকে সাবধান: -7 % 3 → -1 (চিহ্ন আসে ভাজ্য থেকে), আর Math.floor(-7 / 3) → -3 কিন্তু Math.trunc(-7 / 3) → -2. ঘড়ির মতো “ঘুরে আসা” ভাগশেষ লাগলে লিখুন ((n % m) + m) % m.

Math.random — খেলার জন্য, নিরাপত্তার জন্য নয়

Math.random() 0 (সহ) থেকে 1 (বাদে) পর্যন্ত একটি দশমিক দেয়। একটি পরিসরে random পূর্ণসংখ্যা — যেমন লুডুর ছক্কা:

// min থেকে max পর্যন্ত (দুটিসহ) একটি random পূর্ণসংখ্যা
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
randomInt(1, 6);   // 1, 2, 3, 4, 5 বা 6 — প্রতিবার আলাদা

// নিরাপত্তার কাজে (OTP, token, পাসওয়ার্ড রিসেট লিংক):
const bytes = crypto.getRandomValues(new Uint32Array(1));
const id = crypto.randomUUID();

৭ · BigInt — যত বড় খুশি পূর্ণসংখ্যা

2⁵³-এর সীমা পার হতে ES2020-এ যুক্ত হয় নতুন primitive টাইপ BigInt. সংখ্যার শেষে n লিখলেই BigInt: 10n, typeof 10n → "bigint". মেমরি যতটা দেয়, ততটা বড় পূর্ণসংখ্যা হুবহু রাখা যায় — 2n ** 64n → 18446744073709551616n.

• শুধু পূর্ণসংখ্যা: ভাগে দশমিক অংশ কেটে যায় — 7n / 2n → 3n, -7n / 2n → -3n (০-এর দিকে)। BigInt(1.5) দেয় RangeError: The number 1.5 cannot be converted to a BigInt because it is not an integer.
• মেশানো নিষেধ: 10n + 1 → TypeError: Cannot mix BigInt and other types, use explicit conversions. Engine চুপচাপ রূপান্তর করে না, কারণ যেদিকেই করুক তথ্য হারাতে পারে। নিজে লিখুন: 10n + BigInt(1) বা Number(10n) + 1.
• তুলনা চলে: 10n > 5 → true, 10n == 10 → true, কিন্তু 10n === 10 → false (টাইপ আলাদা)।
• Math চলে না: Math.sqrt(4n) → TypeError: Cannot convert a BigInt value to a number.
• JSON সরাসরি নেয় না: JSON.stringify({ id: 10n }) → TypeError: Do not know how to serialize a BigInt (V8-এর বার্তা)। পাঠানোর আগে String(id) করুন।
• দামি: BigInt-এর হিসাব number-এর চেয়ে ধীর — দরকার হলেই ব্যবহার করুন।

৮ · টাকার হিসাব — পয়সায় রাখুন, শেষে সাজান

এবার নাদিয়ার কার্টে ফিরি। পেশাদার নিয়মটি সহজ: টাকাকে সবসময় পূর্ণসংখ্যা পয়সায় রাখুন। ১২০.৪৫ টাকা মানে 12045 পয়সা। পূর্ণসংখ্যার যোগ-বিয়োগ-গুণ safe সীমার ভেতরে হুবহু নির্ভুল — প্রায় ৯০ লক্ষ কোটি টাকা পর্যন্ত। ভাগ বা শতাংশে দশমিক এলে আপনি নিজে ঠিক করবেন কোথায় আর কোন নিয়মে গোল হবে। নিচের debugger-এ দুই পদ্ধতি পাশাপাশি দেখুন (VAT-এর ১৫% হারটি শুধু উদাহরণ — পণ্য অনুযায়ী আসল হার আলাদা হতে পারে)।

1const f = 120.45 + 80.10 + 45.30;  // টাকায়2const cart = [12045, 8010, 4530];  // পয়সায়3const sub = cart[0] + cart[1] + cart[2];4const vat = Math.round(sub * 15 / 100);5const total = sub + vat;6console.log(tk.format(total / 100));

বিল ভাগ — হারিয়ে যাওয়া এক পয়সা

তিন বন্ধু রেস্টুরেন্টে ১০০০ টাকা বিল দেবেন। 1000 / 3 = 333.333… — কেউ ৩৩৩.৩৩ দিলে মোট হয় ৯৯৯.৯৯; এক পয়সা কোথায় গেল? পয়সায় ভাবলে সমাধান পরিষ্কার: 100000 পয়সা, Math.trunc(100000 / 3) = 33333 প্রত্যেকে, আর 100000 % 3 = 1 পয়সা বাকি — সেটি একজনের ভাগে যোগ হবে। মোট সবসময় মিলবে। বেতন ভাগ, কিস্তি, ডিসকাউন্ট ভাগ — সব জায়গায় এই “ভাগফল + ভাগশেষ বিলি” কৌশল কাজে লাগে।

এবার পুরো কৌশলটি চালিয়ে দেখুন — কার্ট, VAT, বিল ভাগ, বাংলায় সাজানো আর BigInt-এর আচরণ:

const cart = [12045, 8010, 4530];           // দাম পয়সায়
let subtotal = 0;
for (const p of cart) subtotal += p;
const vat = Math.round(subtotal * 15 / 100); // উদাহরণ হার 15%
const total = subtotal + vat;
const tk = new Intl.NumberFormat("bn-BD", { style: "currency", currency: "BDT" });
console.log(subtotal, vat, total, tk.format(total / 100));

const bill = 100000, people = 3;             // ১০০০ টাকা, ৩ জন
console.log(Math.trunc(bill / people), bill % people);

const bn = new Intl.NumberFormat("bn-BD", { minimumFractionDigits: 2 });
console.log(bn.format(1234567.5));
console.log((1.005).toFixed(2), new Intl.NumberFormat("en", { maximumFractionDigits: 2 }).format(1.005));

let f = 1n;
for (let i = 1n; i <= 25n; i++) f *= i;      // 25!
console.log(f, Number(f));
try { f + 1; } catch (e) { console.log(e.name + ": " + e.message); }
try { JSON.stringify({ id: 10n }); } catch (e) { console.log(e.message); }

৯ · AI-এর যুগে — হিসাবের কোডে AI-এর চেনা ভুল

AI সংখ্যার কোড খুব দ্রুত লেখে, আর বেশিরভাগ সময় সাধারণ ইনপুটে ঠিকঠাক চলে। সমস্যা লুকিয়ে থাকে সীমানায় — .5-এ গোল করা, খালি ইনপুট, বড় ID, ঋণাত্মক টাকা। AI যে কোড থেকে শিখেছে, তার বড় অংশেই এই ভুলগুলো আছে, তাই সে-ও একই ভুল আত্মবিশ্বাসের সাথে দেয়।

AI-এর লেখা সংখ্যার কোড — যাচাইয়ের চেকলিস্ট

• টাকার হিসাব integer পয়সায় (বা BigInt-এ) হচ্ছে; টাকা থেকে পয়সা বানাতে Math.round আছে
• কোথায়, কোন নিয়মে গোল হচ্ছে স্পষ্ট লেখা আছে; toFixed শুধু দেখানোর কাজে
• ইনপুট পার্সে খালি string, "12abc", NaN আর Infinity যাচাই হয়েছে; parseInt থাকলে radix 10 দেওয়া
• ID আর বড় সংখ্যা string বা BigInt হিসেবে আছে; Number.isSafeInteger দিয়ে সীমা যাচাই
• নিরাপত্তার কাজে Math.random নেই — আছে crypto.getRandomValues
• নিজে অন্তত তিনটি সীমানার কেস চালিয়েছি: .5-এ পড়া ভাগ, ঋণাত্মক মান আর খুব বড় মান