`Math` ऑब्जेक्ट
यह लेख Math ऑब्जेक्ट के बारे में समझाता है।
यह चरण-दर-चरण, बुनियादी उपयोग से लेकर सामान्य व्यावहारिक पैटर्न, साथ ही संभावित गलतियाँ और उनके समाधान को समझाता है।
YouTube Video
Math ऑब्जेक्ट
जावास्क्रिप्ट का Math ऑब्जेक्ट संख्यात्मक गणनाओं के लिए इनबिल्ट यूटिलिटीज का एक सेट प्रदान करता है।
कॉन्स्टैंट्स (स्थिरांक)
Math में परिभाषित स्थिरांक उच्च-परिशुद्धता मानों के साथ काम करते समय उपयोगी होते हैं।
निम्नलिखित कोड कुछ सामान्य स्थिरांक दिखाता है।
1// Show common Math constants
2console.log("Math.PI:", Math.PI); // 3.141592653589793
3console.log("Math.E:", Math.E); // Euler's number
4console.log("Math.LN2:", Math.LN2); // Natural log of 2
5console.log("Math.SQRT2:", Math.SQRT2); // Square root of 2
- इन स्थिरांकों का उपयोग त्रिकोणमितीय कार्यों, लघुगणक रूपांतरण, सामान्यीकरण आदि के लिए सीधे किया जा सकता है। उदाहरण के लिए, कोणों को रैडियन में बदलने के लिए
Math.PIकी आवश्यकता होती है।
मूल राउंडिंग और परास मूल्य (abs, floor, ceil, round, trunc)
राउंडिंग और संकेतों को संभालना अक्सर उपयोग होता है, इसलिए Math.floor, Math.ceil, और Math.round के बीच के अंतर को सही ढंग से समझना जरूरी है। विशेषकर नकारात्मक संख्याओं को संभालते समय, परिणाम आपकी अपेक्षा से अलग हो सकते हैं, इसलिए यह जानना जरूरी है कि प्रत्येक राउंडिंग नियम कैसे काम करता है और उनका सही उपयोग करें।
निम्नलिखित उदाहरण राउंडिंग फंक्शन के अंतर को स्पष्ट करते हैं।
1// Examples of rounding and absolute value functions
2const pos = 3.7;
3const neg = -3.7;
4
5// --- floor ---
6console.log("Math.floor(3.7):", Math.floor(pos)); // 3
7console.log("Math.floor(-3.7):", Math.floor(neg)); // -4
8// (rounds toward smaller value)
9
10// --- ceil ---
11console.log("Math.ceil(3.7):", Math.ceil(pos)); // 4
12console.log("Math.ceil(-3.7):", Math.ceil(neg)); // -3
13// (rounds toward larger value)
14
15// --- round ---
16console.log("Math.round(3.5):", Math.round(3.5)); // 4
17// (.5 goes up for positive numbers)
18console.log("Math.round(-3.5):", Math.round(-3.5)); // -3
19// (.5 moves toward zero for negative numbers)
20
21// --- trunc ---
22console.log("Math.trunc(3.7):", Math.trunc(pos)); // 3
23console.log("Math.trunc(-3.7):", Math.trunc(neg)); // -3
24// (fraction removed toward zero)
25
26// --- abs ---
27console.log("Math.abs(-3.7):", Math.abs(neg)); // 3.7
Math.floorनकारात्मक संख्याओं के लिए छोटी दिशा में राउंड करता है, इसलिए-3.7-4बन जाता है।Math.ceilनकारात्मक संख्याओं के लिए बड़ी दिशा में राउंड करता है, इसलिए-3.7-3बन जाता है।Math.roundधनात्मक अंकों के लिए .5 को ऊपर की ओर राउंड करता है, और ऋणात्मक अंकों के लिए शून्य की ओर राउंड करता है।- ऋणात्मक संख्याएँ अपेक्षा से भिन्न परिणाम दे सकती हैं, इसलिए यह स्पष्ट रूप से समझना जरूरी है कि राउंडिंग किस दिशा में हो रही है।
- राउंडिंग फ़ंक्शन्स का चयन उपयोग के अनुसार करना चाहिए। उदाहरण के लिए, इंडेक्स गणना के लिए
Math.floor, ऊपरी सीमा के लिएMath.ceil, और केवल दशमलव भाग हटाने के लिएMath.truncका उपयोग करें।
गुणा, घातांक, और मूल (pow, **, sqrt, cbrt, hypot)
घातांक और वर्गमूल Math.pow या ** ऑपरेटर के साथ किया जा सकता है। Math.hypot सुरक्षित रूप से वर्गों के योग का वर्गमूल (दूरी) निकालता है।
नीचे घातांक और hypot के उदाहरण दिए गए हैं। Math.hypot ओवरफ्लो और अंडरफ्लो के प्रभाव को कम करता है।
1// Power, root and hypot examples
2console.log("2 ** 10:", 2 ** 10); // 1024
3console.log("Math.pow(2, 10):", Math.pow(2, 10));// 1024
4console.log("Math.sqrt(16):", Math.sqrt(16)); // 4
5console.log("Math.cbrt(27):", Math.cbrt(27)); // 3
6console.log("Math.hypot(3, 4):", Math.hypot(3, 4));// 5 (3-4-5 triangle)
- त्रिभुज की भुजाओं या बहु-आयामी वेक्टर की लंबाइयों में काम करते समय
Math.hypotउपयोगी है।
घातांकीय और लघुगणकीय फंक्शन (exp, log, log10, log2)
घातांकीय और लघुगणकीय प्रायिकता, घातांकीय क्षय और स्केलिंग में प्रायः उपयोग होते हैं।
इसके बाद, exp और लघुगणक के मूल उदाहरण दिए गए हैं। लघुगणक का आधार देखकर उपयुक्त फंक्शन का उपयोग करना सुनिश्चित करें।
1// Exponential and logarithm examples
2console.log("Math.exp(1):", Math.exp(1)); // e^1
3console.log("Math.log(Math.E):", Math.log(Math.E)); // natural log, 1
4console.log("Math.log10(100):", Math.log10(100)); // 2
5console.log("Math.log2(8):", Math.log2(8)); // 3
- प्राकृतिक लघुगणक (
Math.log) सांख्यिकी और अवकल समीकरणों में मानक हैं। सामान्य लघुगणक और आधार-2 लघुगणक का भी अनुप्रयोग के अनुसार चयन किया जाता है।
त्रिकोणमितीय फंक्शन (sin, cos, tan, asin, acos, atan2)
त्रिकोणमितीय फंक्शन कोण गणना, घूर्णन और निर्देशांक परिवर्तन के लिए आवश्यक हैं। Math.atan2(y, x) कोण की गणना के लिए उपयोगी है, क्योंकि यह चतुर्थांश को सही तरीके से ध्यान में रखता है।
नीचे atan2 के मूल उदाहरण और उपयोग दिए गए हैं। कोणों को रैडियन्स में ही लिया जाना चाहिए।
1// Trigonometry examples (angles in radians)
2const degToRad = deg => deg * (Math.PI / 180);
3const radToDeg = rad => rad * (180 / Math.PI);
4
5console.log("Math.sin(PI/2):", Math.sin(Math.PI / 2)); // 1
6console.log("Math.cos(0):", Math.cos(0)); // 1
7console.log("Math.tan(Math.PI / 4):", Math.tan(Math.PI / 4)); // ~1
8
9// Using atan2 to compute angle of vector (x, y)
10const x = -1, y = 1;
11const angle = Math.atan2(y, x); // returns angle in radians taking quadrant into account
12console.log("atan2(1, -1) in degrees:", radToDeg(angle)); // 135
atan2वेक्टर के कोण को सुरक्षित रूप से निर्धारित कर सकता है, जिससे यह घूर्णन और दिशा गणना के लिए उपयुक्त बनता है।
यादृच्छिक संख्या जनन (Math.random और व्यावहारिक पैटर्न)
Math.random() [0, 1) सीमा में एक समान वितरण वाली यादृच्छिक संख्या लौटाता है। आप इसे आवश्यकता अनुसार पूर्णांक सीमा या सामान्य वितरण आदि के लिए बदल सकते हैं या विस्तारित कर सकते हैं।
निम्नलिखित यादृच्छिक संख्या यूटिलिटी फंक्शन के उदाहरण हैं। यदि आपको क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिक संख्याएँ चाहिए, तो crypto.getRandomValues का उपयोग करें।
1// Random utilities using Math.random
2
3// Get integer in [min, max] inclusive
4function randomInt(min, max) {
5 // Returns integer between min and max (inclusive)
6 return Math.floor(Math.random() * (max - min + 1)) + min;
7}
8console.log("randomInt(1, 6):", randomInt(1, 6)); // dice roll example
9
10// Get float in [min, max)
11function randomFloat(min, max) {
12 return Math.random() * (max - min) + min;
13}
14console.log("randomFloat(0, 5):", randomFloat(0, 5));
15
16// Fisher-Yates shuffle
17function shuffle(array) {
18 for (let i = array.length - 1; i > 0; i--) {
19 const j = Math.floor(Math.random() * (i + 1));
20 // swap array[i] and array[j]
21 [array[i], array[j]] = [array[j], array[i]];
22 }
23 return array;
24}
25console.log("shuffle([1,2,3,4,5]):", shuffle([1,2,3,4,5]));Math.randomसामान्य उपयोग के लिए आसान है, लेकिन गेम रिप्ले या क्रिप्टोग्राफी के लिए पुनरुत्पादन या सुरक्षा के लिए अतिरिक्त उपाय आवश्यक हैं।
व्यावहारिक सहायक (clamp, lerp, mapRange, कोण सामान्यीकरण)
अक्सर उपयोग होने वाले गणितीय कार्यों के लिए खुद छोटी यूटिलिटी फंक्शन लिखना सहायक होता है।
यहाँ सामान्य यूटिलिटीज के कार्यान्वयन उदाहरण दिए गए हैं।
1// Utility functions: clamp, lerp, mapRange, normalizeAngle
2
3// Clamp value between min and max
4function clamp(v, min, max) {
5 return Math.max(min, Math.min(max, v));
6}
7console.log("clamp(10, 0, 5):", clamp(10, 0, 5)); // 5
8
9// Linear interpolation: t in [0,1]
10function lerp(a, b, t) {
11 return a + (b - a) * t;
12}
13console.log("lerp(0, 10, 0.25):", lerp(0, 10, 0.25)); // 2.5
14
15// Map value from one range to another
16function mapRange(v, inMin, inMax, outMin, outMax) {
17 const t = (v - inMin) / (inMax - inMin);
18 return lerp(outMin, outMax, t);
19}
20console.log("mapRange(5, 0, 10, 0, 100):", mapRange(5, 0, 10, 0, 100));
21// -> 50
22
23// Normalize angle to [-PI, PI)
24function normalizeAngle(rad) {
25 return Math.atan2(Math.sin(rad), Math.cos(rad));
26}
27console.log("normalizeAngle(3*PI):", normalizeAngle(3 * Math.PI));- यह कोड उन छोटी यूटिलिटी फंक्शन को एकत्रित करता है जो संख्यात्मक कार्यों में जैसे क्लैम्पिंग, इंटरोपोलेशन, रेंज मैपिंग और कोण सामान्यीकरण के लिए प्रयोग होती हैं।
clampकिसी मान को निर्दिष्ट सीमा में सीमित करता है, जबकिlerpऔरmapRangeचिकनी इंटरपोलेशन या सीमा रूपांतरण करते हैं। साथ ही,normalizeAngleहमेशा कोणों को[-π, π)सीमा में सामान्य करता है जिससे घूर्णन की गणना स्थिर रहती है। - ये सहायक ग्राफिक्स, गेम्स और इंटरैक्शन प्रोग्रामिंग में अक्सर उपयोग किए जाते हैं।
normalizeAngleकोणीय अंतर की तुलना और इंटरपोलेशन के लिए महत्वपूर्ण है।
फ्लोटिंग-पॉइंट और राउंडिंग सतर्कताएँ (परिशुद्धता और तुलना)
जावास्क्रिप्ट की संख्याएँ IEEE-754 डबल-प्रिसिजन फ्लोटिंग-पॉइंट (64-बिट) होती हैं, अतः संख्याओं की तुलना या राउंडिंग करते समय सावधानी आवश्यक है। उदाहरण के लिए, 0.1 + 0.2 !== 0.3।
यहाँ राउंडिंग त्रुटियों को संभालने का एक उदाहरण है। छोटी त्रुटियों को सहन करने वाली तुलना या उपयुक्त राउंडिंग फंक्शन का उपयोग करना महत्वपूर्ण है।
1// Floating point precision example and safe equality
2console.log("0.1 + 0.2 === 0.3 :", 0.1 + 0.2 === 0.3); // false
3
4function nearlyEqual(a, b, eps = 1e-12) {
5 return Math.abs(a - b) <= eps;
6}
7console.log("nearlyEqual(0.1+0.2, 0.3):", nearlyEqual(0.1 + 0.2, 0.3));
8// -> true
- मजबूत संख्यात्मक समानता जांच के लिए, पूर्ण त्रुटि (
eps) या सापेक्ष त्रुटि का उपयोग करें।
प्रदर्शन संबंधी सुझाव
Math के फंक्शन मूल रूप से ऑप्टिमाइज़्ड होते हैं और अक्सर स्वयं लिखी गई समान लॉजिक से तेज होते हैं। यदि कोई गणना (जैसे, Math.PI / 180) लूप में बार-बार की जाती है तो उसे पहले से एक वेरिएबल में असाइन करने से अनावश्यक ओवरहेड घटता है।
नीचे लूप के बाहर एक स्थिरांक बनाकर डिग्री को रैडियन में बदलने का उदाहरण है।
1// Cache conversion factor for performance
2const DEG_TO_RAD = Math.PI / 180;
3const RAD_TO_DEG = 180 / Math.PI;
4
5for (let deg = 0; deg < 360; deg += 10) {
6 // Use cached constant instead of computing each time
7 const rad = deg * DEG_TO_RAD;
8 // ... do work with rad
9}- ऑप्टिमाइजेशन करने से पहले असल हॉटस्पॉट को प्रोफाइलर से जाँचना सबसे अच्छा है।
- अक्सर उपयोग होने वाले स्थिरांक को कैश करना प्रभावी होता है।
संगतता और पॉलीफिल
Math स्वयं लंबे समय से है, लेकिन कुछ फंक्शन्स जैसे Math.cbrt, Math.log10, Math.log2, और Math.hypot पुराने पर्यावरण में उपलब्ध नहीं हो सकते। अगर जरूरत हो तो एक सरल पॉलीफिल तैयार करें।
नीचे Math.log2 के लिए एक सरल पॉलीफिल का उदाहरण है।
1// Polyfill for Math.log2 if needed
2if (!Math.log2) {
3 Math.log2 = function(x) {
4 return Math.log(x) / Math.LN2;
5 };
6}
7console.log("Math.log2(8):", Math.log2(8));अधिकांश पर्यावरण में यह पहले से समर्थित है, लेकिन आवश्यकता पड़ने पर संगतता जाँच लें।
अपने प्रोजेक्ट के लक्षित पर्यावरण के अनुसार ब्राउज़र समर्थन की जाँच करें।
व्यावहारिक उदाहरण: एक सरल भौतिकी सिमुलेशन में समय-चरण अद्यतन
अंत में, यहाँ कई Math फंक्शन्स को मिलाकर एक व्यावहारिक उदाहरण दिया गया है। यह स्थिति, वेग, और कोण नियंत्रण को अपडेट करने का एक बहुत ही सरल उदाहरण है।
यह भौतिकी इंजन का अत्यधिक सरलीकृत मॉडल है।
1// Clamp value between min and max
2function clamp(v, min, max) {
3 return Math.max(min, Math.min(max, v));
4}
5
6// Normalize angle to [-PI, PI)
7function normalizeAngle(rad) {
8 return Math.atan2(Math.sin(rad), Math.cos(rad));
9}
10
11// Simple physics step example using Math utilities
12function step(state, dt) {
13 // state: { x, y, vx, vy, angle, angularVelocity }
14 // dt: time delta in seconds
15 // Integrate linear motion
16 state.x += state.vx * dt;
17 state.y += state.vy * dt;
18
19 // Integrate angular motion and normalize angle
20 state.angle = normalizeAngle(state.angle + state.angularVelocity * dt);
21
22 // Keep position within bounds [0, width] x [0, height]
23 state.x = clamp(state.x, 0, state.width);
24 state.y = clamp(state.y, 0, state.height);
25 return state;
26}
27
28const state = { x: 10, y: 10, vx: 2, vy: 0.5, angle: 0, angularVelocity: 0.1, width: 100, height: 100 };
29console.log("before:", state);
30step(state, 0.016); // simulate ~1 frame at 60fps
31console.log("after:", state);- इस प्रकार
Mathसहायतकों को मिलाकर, सिमुलेशन और एनीमेशन की लॉजिक और भी संक्षिप्त बनाई जा सकती है।
सारांश
Mathसभी कॉन्स्टैंट्स और बेसिक फंक्शन्स से लेकर उन्नत फंक्शन्स तक सब कुछ कवर करता है, और यह संख्यात्मक प्रोसेसिंग की नींव है।- हर उद्देश्य के अनुसार फंक्शन का चयन करें जैसे यादृच्छिक संख्या, त्रिकोणमितीय फंक्शन, घातांकीय/लघुगणकीय या राउंडिंग; और व्यावहारिक उपयोग के लिए
clampऔरlerpजैसी छोटी यूटिलिटी बनाएं। - फ्लोटिंग-पॉइंट की परिशुद्धता और लक्षित पर्यावरण में सपोर्ट को ध्यान में रखें, और आवश्यक हो तो एरर टॉलरेंस या पॉलीफिल तैयार करें।
आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।