Bagay na `Math`

Ipinaliliwanag ng artikulong ito ang tungkol sa bagay na Math.

Ipinaliwanag nito nang sunud-sunod, mula sa pangunahing gamit hanggang sa karaniwang praktikal na mga pattern, pati na rin ang mga panganib at mga solusyon.

YouTube Video

Bagay na Math

Ang bagay na Math ng JavaScript ay nagbibigay ng mga built-in na utilities para sa mga kalkulasyong numerikal.

Mga Konstante

Ang mga konstante na itinakda sa Math ay kapaki-pakinabang kapag humaharap sa mga halaga na nangangailangan ng mataas na presisyon.

Ipinapakita ng sumusunod na code ang ilan sa mga karaniwang konstante.

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

• Maaaring gamitin ang mga konstante na ito para sa mga trigonometric na function, pagko-convert ng logarithm, normalisasyon, at iba pa. Halimbawa, kailangan ang Math.PI para i-convert ang mga anggulo sa radians.

Pangunahing pagpapaikot ng numero at absolute values (abs, floor, ceil, round, trunc)

Madalas gamitin ang rounding at paghawak sa mga senyas, kaya mahalagang maintindihan nang tama ang mga pagkakaiba ng Math.floor, Math.ceil, at Math.round. Lalo na kapag humaharap sa negatibong numero, ang resulta ay maaaring iba sa inaasahan, kaya kailangang maunawaan nang maigi kung paano gumagana ang bawat rounding rule at gamitin ito nang tama.

Ipinapakita ng mga sumusunod na halimbawa ang mga pagkakaiba ng mga rounding function.

 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 ay nag-ro-round pababa para sa mga negatibong numero, kaya ang -3.7 ay nagiging -4.
• Math.ceil ay nag-ro-round pataas para sa mga negatibong numero, kaya ang -3.7 ay nagiging -3.
• Ang Math.round ay nagro-round ng .5 pataas para sa positibong numero, at para sa negatibong numero, nagro-round ito papalapit sa zero.
• Ang negatibong mga numero ay maaaring magbigay ng resulta na iba sa inaasahan, kaya mahalagang malaman kung saang direksyon niroround ang mga numero.
• Dapat piliin ang tamang rounding function depende sa layunin o paggamit. Halimbawa, gamitin ang Math.floor para sa kalkulasyon ng index, Math.ceil para sa itaas na limit, at Math.trunc kapag gusto mo lang tanggalin ang decimal na bahagi.

Multiplikasyon, exponentiation, at mga ugat (pow, **, sqrt, cbrt, hypot)

Maaaring gawin ang exponentiation at square roots gamit ang Math.pow o ang ** na operator. Ang Math.hypot ay ligtas na kumukuwenta ng square root ng suma ng mga parisukat (distansya).

Nasa ibaba ang mga halimbawa ng exponentiation at hypot. Pinapaliit ng Math.hypot ang epekto ng overflow at underflow.

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)

• Ang Math.hypot ay kapaki-pakinabang kapag nagko-compute ng gilid ng tatsulok o haba ng multi-dimensional vector.

Exponentials at mga logarithmic function (exp, log, log10, log2)

Madalas gamitin ang exponentials at logarithms sa probabilidad, exponential decay, at scaling.

Narito ang mga pangunahing halimbawa ng exp at logarithms. Siguraduhing gamitin ang angkop na function, depende sa base ng logarithm.

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

• Ang natural logarithms (Math.log) ay karaniwan sa statistics at differential equations. Pinipili din ang mga common logarithm at base-2 logarithm depende sa aplikasyon.

Mga trigonometric na function (sin, cos, tan, asin, acos, atan2)

Mahalaga ang mga trigonometric na function para sa kalkulasyon ng anggulo, pagikot, at pagbabago ng coordinate. Ang Math.atan2(y, x) ay kapaki-pakinabang para sa pagtutuos ng anggulo na may tamang pagkonsidera sa quadrants.

Narito ang mga batayang halimbawa at paraan ng paggamit ng atan2. Ang mga anggulo ay dapat tukuyin sa radians.

 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

• Ang atan2 ay ligtas na tumutukoy ng anggulo ng vector, kaya ito ay mas mainam para sa mga kalkulasyon ng pagikot at direksyon.

Pagbuo ng random na numero (Math.random at praktikal na mga pattern)

Nagbabalik ang Math.random() ng random na numerong pantay ang distribusyon sa saklaw na [0, 1). Maari mo itong i-convert o palawakin ayon sa pangangailangan, halimbawa, para sa integer range o normal distribution.

Narito ang ilang mga halimbawa ng mga utility function para sa random na bilang. Kung kailangan mo ng random numbers na ligtas sa cryptography, gamitin ang 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]));

• Maginhawa ang Math.random para sa karaniwang paggamit, ngunit sa laro o kriptograpiya, kailangan ng dagdag na panukala para sa muling paglalathala o seguridad.

Praktikal na mga helper (clamp, lerp, mapRange, angle normalization)

Makatutulong ang pagsulat ng maliliit na utility function para sa madalas gamitin na mga gawain sa matematika.

Narito ang mga halimbawa ng implementasyon ng karaniwang ginagamit na mga utilities.

 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));

• Ang code na ito ay naglalaman ng mga maliliit na utility function na karaniwan sa mga operasyong numerikal gaya ng clamping, interpolation, pagmamapa ng range, at normalisasyon ng anggulo. Ang clamp ay naglilimita ng halaga sa isang tinukoy na saklaw, samantalang ang lerp at mapRange ay para sa makinis na interpolation o conversion sa ibang saklaw. Dagdag pa, ang normalizeAngle ay laging nagno-normalize ng mga anggulo sa saklaw na [-π, π) upang gawing matatag ang pagkalkula ng pagikot.
• Madalas gamitin ang mga helper na ito sa graphics, laro, at pagpo-program ng interaksyon. Importante ang normalizeAngle sa paghahambing ng pagkakaiba ng anggulo at para sa interpolation.

Mga paalala sa floating-point at pag-round ng bilang (presisyon at paghahambing)

Ang mga numero ng JavaScript ay IEEE-754 double-precision floating-point (64-bit), kaya’t dapat maging maingat kapag naghahambing o nagro-round ng bilang. Halimbawa, 0.1 + 0.2 !== 0.3.

Narito ang halimbawa ng paghawak ng rounding errors. Mahalaga ang paggamit ng paghahambing na tumatanggap ng maliit na error, o ng tamang rounding function.

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

• Para sa mas matibay na numerical equality check, gamitin ang absolute error (eps) o relative error.

Mga tip sa performance

Ang mga function ng Math ay native na na-optimize at madalas mas mabilis kaysa sa mano-manong isinusulat na katulad na lohika. Kung paulit-ulit ang parehong kalkulasyon (hal. Math.PI / 180) sa loob ng loop, mabuting itakda ito sa variable nang maaga upang mabawasan ang hindi kailangang overhead.

Narito ang halimbawa ng pag-convert ng degrees papuntang radians sa pamamagitan ng paggawa ng constante sa labas ng loop.

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}

• Pinakamainam na tukuyin muna ang tunay na bottleneck gamit ang profiler bago mag-optimize.
• Mas mahusay na i-cache ang mga konstanteng madalas gamitin.

Pagkakatugma at polyfills

Matagal nang mayroon ang Math, pero may ilang function tulad ng Math.cbrt, Math.log10, Math.log2, at Math.hypot na maaaring hindi suportado sa mas lumang environment. Maghanda ng simpleng polyfill kung kinakailangan.

Narito ang halimbawa ng simpleng polyfill para sa 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));

Marami nang environment ang sumusuporta dito, pero siguraduhing may compatibility kung kinakailangan.

Suriin ang browser support ayon sa target environment ng iyong proyekto.

Praktikal na halimbawa: Pag-update per time-step sa simpleng physics simulation

Sa huli, narito ang praktikal na halimbawa na pinagsasama ang ilang Math function. Ito ay napakapayak na halimbawa para sa pag-update ng posisyon, bilis, at pagkontrol ng anggulo.

Ito ay napakasimple na modelo ng isang physics engine.

 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);

• Sa pamamagitan ng paggagamit ng mga helper function ng Math tulad nito, mapapaikli ang simulation at animation logic.

Buod

• Sinasaklaw ng Math ang lahat mula sa mga konstante at pangunahing function hanggang sa mga advanced, bilang pundasyon ng numerical processing.
• Piliin ang mga function ayon sa gamit — tulad ng random number, trigonometric function, exponential/logarithm, o rounding — at gumawa rin ng maliliit na utility gaya ng clamp at lerp para sa praktikal na paggamit.
• Bigyang pansin ang presisyon ng floating-point at compatibility ng iyong target environment, at maghanda ng error tolerance o polyfill kung kinakailangan.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video