JavaScript matematika
Matematika alapismeretek |
Matematikai hibák |
|---|
JavaScript matematika alapismeretek
A JavaScript rendelkezik beépített matematikai objektummal, neve: Math
A Math objektum számos olyan matematikai programmal rendelkezik, mely megkönnyíti a matematikai számítások eredményének kiértékelését.
A Math objektumban található programokközött vannak matematikai állandókat és függvényeket tartalmazó képletek.
Megjegyzés:
A Math nem valódi objektum, azaz nem hozhatunk létre belőle saját példányt.
Más szóval: programunk elküldi a Math-ot, menjen el a JavaScript matematikai képlettárába és az általunk meghatározott képletet hozza el, majd ezzel számolja ki a matematikai képletünk eredményét.
Gyakran használt matematikai műveletek jelei
| + | Összeadás |
| - | Kivonás |
| * | Szorzás |
| / | Osztás |
| % | Maradékképzés |
| ++ | Növelés |
| -- | Csökkentés |
| >> | Bitszintű művelet. Lásd az oldal alján. |
| >>> | Bitszintű művelet. Lásd az oldal alján. |
A növelés és csökkenés műveleteket, legfőképp ciklusoknál alkalmazzuk, ahol a programlefutás után automatikusan növelhetjük, vagy csökkenthetjük a változó eredeti értékét.
JavaScript a plusz "+" jelet, összefűzésre és összeadásra is, alkalmazza.
Közvetlen a Scriptben beírt adatoknál:
- Idézőlek közé beírt adatot szövegként kezeli még akkor is, ha számot írunk be.
Példa: var a = "2"; var b = "3"; var c = a + b; eredménye ez lesz: 23 - Számok esetén idézőjelet nem alkalmazunk.
Példa: var a = 2; var b = 3; var c = a + b; eredménye ez lesz: 5
Ha, Html oldalról olvastatunk be adatot, akkor alapértelmezésként, összefűzést alkalmaz.
Mikor legyen összefűzés és mikor legyen összeadás, nekünk kell meghatározni.
Összefűzéshez nincs teendőnk.
Matematikai összeadásnál, a következő függvények valamelyikére van szükségünk:
- parseInt() egész számmá konvertálja a string értéket.
- parseFloat() 14 tizedesig, azaz, lebegőpontos számmá konvertálja a string értéket.
Példa, Html oldalról történő adatok beolvasására:
var a = 2; var b = 3; var c = a + b; eredménye ez lesz: 23
var a = 2; var b = 3; var c = parseInt(a) + parseInt(b); eredménye ez lesz: 5
MATEMATIKAI
ÁLLANDÓK ÉS LOGARITMUSOK.
A pi weboldali jele: nagy PI = Π --- kis pi = π
log = logaritmus. ----- lg = 10 alapú logaritmus. ----- ln = természetes (e alapú ) logaritmus.
Adott szám, 10 alapú logaritmusának meghatározása:x = 274613 = 2.746 * 105 lg 274613 = lg 2.746 + 5 = 0.4387 + 5 = 5.4387 |
|
10 adott kitevőjű hatványának meghatározása:x = 0.5638-3 100,5638-3 = 100,5638 * 10-3 = 3.671 * 10-3 = 0.003671 |
|
| Kör kerület, és átmérő hányadosa: PI π = 3.14159 26536 | lg Π = 049714 98727 |
| Természetes alapú logaritmus alapja. e = 2.71828 18285 | M = lg e = 0.43429 44819 |
| 1 : Π = 0.31830 98862 | -lg Π = 0.50285 01273-1 |
| 1 : e = 0.36787 95147 | 1/M = ln 10 = 2.30258 50930 |
| lg M = 0.6378-1 | lg 1/M = 0.3622 |
| n | n | lg n | 1/n | 1/n | lg 1/n = -lg n |
|---|---|---|---|---|---|
| 2 * π | 6.28319 | 0.7982 | 1 : 2*Π | 0.15916 | 0.2018-1 |
| 4 * Π | 12.56637 | 1.0992 | 1 : 4*Π | 0.07958 | 0.9008-2 |
| Π : 2 | 1.57080 | 0.1961 | 2 : Π | 0.63662 | 0.8039-1 |
| Π : 3 | 1.04720 | 0.0200 | 3 : Π | 0.95493 | 0.9800-1 |
| 4 * Π : 3 | 4.18879 | 0.6221 | 3 : 4*Π | 0.23873 | 0.3779-1 |
| Π2 | 9.86960 | 0.9943 | 1 : Π2 | 0.10132 | 0.0057-1 |
| √Π | 1.77245 | 0.2486 | 1 : √Π | 0.10132 | 0.0057-1 |
| √2*Π | 2.50663 | 0.3991 | 1 : √2*Π | 0.39894 | 0.6009-1 |
| √Π:2 | 0.88623 | 0.9475-1 | 2 : √Π = c | 1.12838 | 0.0525 |
| Π3 | 31.00628 | 1.4914 | 1 : Π3 | 0.03225 | 0,5086-2 |
| 3√4*Π : 3 | 1.61199 | 0.2074 | 3√3 : 4*Π | 0.62035 | 0.7926-1 |
| Π : 360o | 0.008726 | 0.9409-3 | 360o : Π | 114.59o | 2.0591 |
| Π : 180o | 0.017453 | 0.2419-2 | 180o : Π | 57.29578o | 1.7581 |
| Π : 10800' | 0.00029089 | 0.4637-4 | 10800' : Π | 3437.747' | 3.5363 |
| Π : 648000'' | 0,0000048481 | 0.6856-6 | 648000'' : Π | 206264.8'' | 5.3144 |
| e2 | 7.3896 | 0.8686 | 1 : e2 | 0.13534 | 0.1314-1 |
| √e | 1.64872 | 0.2171 | 1 : √e | 0.60653 | 0.7829-1 |
| g | 9.81 m/s2 | 0.9917 | 1 : g | 0.1019 | 0.0083-1 |
| Π : √g | 1.003 | 0.0013 | √g:Π | 0.9970 | 0.9987-1 |
JavaScript matematikai konstansok.
| Math.E | A természetes alapú logaritmus alapja ( 2.718 ) | Math.E = |
| Math.LN2 | A kettő természetes alapú logaritmus alapja ( 0.693 ) | Math.LN2 = |
| Math.LN10 | A tíz természetes alapú logaritmusa ( 2.302 ) | Math.LN10 = |
| Math.LOG2E | Az E kettes alapú logaritmusa ( 1.442 ) | Math.LOG2E = |
| Math.LOG10E | Az E természetes alapú logaritmusa ( 0.434 ) | Math.LOG10E = |
| Math.PI | Kör kerület, és átmérő hányadosa ( 3.14159 ) | Math.PI = |
| Math.SQRT1_2 | Az egyketted négyzetgyöke ( 0.707 ) | Math.SQRT1_2 = |
| Math.SQRT2 | A kettő négyzetgyöke( 1.4142 ) | Math.SQRT2 = |
JavaScript matematikai függvények.
Algebrai függvények. | ||
|---|---|---|
| Math.acos(szám) Egy szám arkusz koszinuszát adja meg radiánba. |
Math.acos(0.64) Math.acos(0) Math.acos(-1) Math.acos(1) Math.acos(2) |
|
|
Math.asin(szám) egy szám arkusz szinusát adja meg. |
Math.asin(0.64) Math.asin(0) Math.asin(-1) Math.asin(1) Math.asin(2) |
|
|
Math.atan(szám) egy szám arkusz tangensét adja meg |
Math.atan(0.50) Math.atan(-0.50) Math.atan(5) Math.atan(10) Math.atan(-5) Math.atan(-10) |
|
|
Math.cos(szám) egy szög koszinusát számolja ki. |
Math.cos(3) Math.cos(-3) Math.cos(0) Math.cos(Math.PI) Math.cos(2*Math.PI) |
|
|
Math.sin(szám) egy szög szinuszát számolja ki. |
Math.sin(3) Math.sin(-3) Math.sin(0) Math.sin(Math.PI) Math.sin(Math.PI/2) |
|
|
Math.tan(szám) egy szög tangensét számolja ki. |
Math.tan(Math.PI/4) Math.tan(0.50) Math.tan(-0.50) Math.tan(5) Math.tan(10) Math.tan(-5) Math.tan(-10) |
|
Statisztikai és logaritmikus függvények. | ||
|
Math.exp(szám) természetes alapú logaritmus alapját, ( e = 2.71828 1828 459045) emeli fel a kívánt hatványra. |
Math.exp(1) Math.exp(-1) Math.exp(2) Math.exp(5) Math.exp(10) |
|
|
Math.log(szám) egy szám természetes alapú logaritmusát adja vissza. |
Math.log(2.718281828459045) Math.log(0.36787944117144233) Math.log(7.38905609893065) Math.log(2) Math.log(1) Math.log(0) Math.log(-1) |
|
|
Math.max(a, b) két szám közül, a nagyobbat választja ki |
Math.max(5,7) Math.max(-3,5) Math.max(-3,-5) Math.max(7.25,7.30) |
|
|
Math.min(a, b) két szám közül, a kisebbet választja ki. |
Math.min(5,7) Math.min(-3,5) Math.min(-3,-5) Math.min(7.25,7.30) |
|
Kerekítési és egyszerű matematikai függvények. | ||
|
Math.abs(szám) egy szám abszolút értékét adja meg. |
Math.abs(6.7) Math.abs(-6.7) Math.abs(-3) Math.abs(3) |
|
|
Math.ceil(szám) felfelé kerekíti a számot a legközelebbi egészhez. |
Math.ceil(0.657) Math.ceil(10.427) Math.ceil(5) Math.ceil(5.1) Math.ceil(-5.1) Math.ceil(-5.9) |
|
|
Math.floor(szám) lefelé kerekíti a számot a legközelebbi egészhez. |
Math.floor(0.657) Math.floor(10.427) Math.floor(5) Math.floor(5.1) Math.floor(-5.1) Math.floor(-5.9) |
|
|
Math.pow(a, b) megadott hatványra emel egy számot. |
22 = Math.pow(2,2) 23 = Math.pow(2,3) 24 = Math.pow(2,4) 42 = Math.pow(4,2) 62 = Math.pow(6,2) -62 = Math.pow(-6,2) -6-2 = Math.pow(-6,-2) -65.5 = Math.pow(-6,5.5) |
|
|
Math.round(szám) a legközelebbi egészhez kerekíti a számot. |
Math.round(0.60) Math.round(0.5001) Math.round(0.5) Math.round(0.4999) Math.round(1.5) Math.round(1.4999) Math.round(-4.4999) Math.round(-4.5) |
|
|
Math.sqrt(szám) a szám négyzetgyökét számolja ki. |
√0 = Math.sqrt(0) √1 = Math.sqrt(1) √4 = Math.sqrt(4) √9 = Math.sqrt(9) √0,64 = Math.sqrt(0.64) √-1 = Math.sqrt(-1) √-4 = Math.sqrt(-4) √-9 = Math.sqrt(-9) |
|
Véletlenszámok függvénye. Teszteléshez frissítsük az oldalt. | ||
|---|---|---|
|
Math.random() 0 és 1 között, egy véletlenszámot ad vissza. |
Math.random() Math.random() Math.random(10,100) |
|
Véletlenszám 1 és 10 között. |
var num=10;
var veletlenszam = Math.floor(Math.random() * num) + 1;
$("#tippszam").append(veletlenszam);
|
Eredmény: |
Véletlenszám 0 és 100 között. |
var num=100;
var veletlenszam = Math.floor(Math.random() * num);
$("#tippszam").append(veletlenszam);
|
Eredmény: |
Matematikai feladatmegoldó operátorok
Összeadás (+)
Az összeadás kétoperandusú művelet. Számokat ad össze,
z=3+4; // z egyenlő 7-tel
és karakterfüzéreket láncol össze.
z="3"+"4"; //z egyenlő 34-gyel
udv="Hel"+"lo";> // az udv megegyezik a "Hello"-val
Egészszámokkal mindig jól dolgozik, de tizedes értékek esetén, nem mindig kapunk pontos eredményt:
z=0.2+0.1; // z egyenlő 0.3-al.
Eredmény ez lesz: 0.30000000000000004
Kivonás (-)
Ha kétoperandusú műveletként használjuk, akkor a kivonás (-) művelettel két számot vonhatunk ki egymásból.
x=4-3; // x egyenlő 1-gyel
x=3-4; // x egyenlő -1-gyel
Ha egyoperandusú műveletként használjuk, akkor ez az operátor a pozitív számot negatívvá konvertálja, illetve fordítva.
x=6;
y=-x; // y egyenlő -6-tal
z=-y; // z jelen esetben megegyezik 6-tal
Ha az operátort nem szám típusú értékekkel használjuk, akkor megpróbálja kiszámolni a különbséget olyan módon, hogy szám típusú értékké alakítja azokat.
Szorzás (*)
A szorzás (*) kétoperandusú művelet, amelynek segítségével két számot szorozhatunk össze.
z=2*3; // z egyenlő 6-tal
Egészszámokkal mindig jól dolgozik, de tizedes értékek esetén, nem mindig kapunk pontos eredményt.
Ha az operátort nem szám típusú értékekkel használjuk, akkor megpróbálja kiszámolni a szorzatot olyan módon, hogy szám típusú értékké alakítja azokat.
Osztás (/)
Az osztás (/) olyan kétoperandusú művelet, amely az első operandust elosztja a másodikkal.
z=6/3; // z egyenlő 2-vel
z=3/2; // z egyenlő 1.5-del
A nullával való osztás speciális értéket eredményez.
z=3/0; // z POSITIVE_INFINITY-vel vagy NEGATIVE_INFINITY-vel egyenlő
z=0/0; // z NAN-nal egyenlő
Ha ez operátort nem szám típusú értékekkel használjuk, akkor megpróbálja kiszámolni a hányadost olyan módon, hogy szám típusú értékké alakítja azokat.
Maradékos osztás (%)
A maradékos osztást (%) szokás modulo-műveletnek is nevezni. A két operandus osztása során keletkezett maradékot adja vissza.
z=7%2; // z egyenlő 1-gyel
z=6%2; // z egyenlő 0-val
Ha az operátort nem szám típusú értékekkel használjuk, akkor megpróbálja kiszámolni a maradékot olyan módon, hogy szám típusú értékké alakítja azokat.
Az érték növelő (++), csökkentő (--) operátor a hozzá kapcsolódó értékhez hozzáad egyet, vagy kivon belőle egyet.
Ha az operátor elöl áll, akkor először történik meg az érték növelése.
Ha viszont hátul áll az operátor, akkor előbb az értékadás (b = a) valósul meg, és utána mellesleg nő az "a" változó értéke 1-gyel.
Hasonlóképpen az értékcsökkentő operátornál.
Példa:
Az operátor kék színnel van kiemelve.
a = ++a;
b = a++;
Számérték 1-el, azaz eggyel történő növelése. (++)
- Inkrementálás
Egy számértékkel történő növelés (++) egyoperandusú művelet, amelynek segítségével egy számot lehet inkrementálni, azaz hozzá adni egyet.
A művelet lehet pre-inkrement és poszt-inkrement.
A pre-inkrement azelőtt végrehajtódik, mielőtt az utasítás további műveletei végrehajtódnának.
x=5;
y=++x; // mind az x, mind az y egyenlő 6-tal
A poszt-inkrement azután hajtódik végre, miután az utasítás összes többi művelete végrehajtódott.
x=5;
y=x++; // az x 6-tal, az y 5-tel egyenlő
Ha az operátort nem szám típusú értékekkel használjuk, akkor az inkrementálást megpróbálja kiszámolni olyan módon, hogy szám típusú értékké alakítja az operandusokat.
Számérték 1-el, azaz eggyel történő csökkentése. (--)
- Dekrementálás
Egy számértékkel történő csökkentés (--) egyoperandusú művelet, amelynek segítségével egy számot lehet dekrementálni, azaz értékéből egyet kivonni.
A művelet lehet pre-dekrement és post-dekrement.
A pre-dekrement azelőtt végrehajtódik, mielőtt az utasítás további műveletei végrehajtódnának.
x=5;
y=--x; // mind az x, mind az y egyenlő 4-tal
A post-dekrement azután hajtódik végre, miután az utasítás összes többi művelete végrehajtódott.
x=5;
y=x--; // az x 4-gyel, az y 5-tel egyenlő
Ha az operátort nem szám típusú értékekkel használjuk, akkor az dekrementálást megpróbálja kiszámolni olyan módon, hogy szám típusú értékké alakítja az operandusokat.
A bitszintű jobbra eltolás
A bitszintű jobbra eltolás két változata között a különbség az, hogy amíg a ">>" esetén az előjelbit értékét használja az új értékhelyek feltöltésére a bal oldalon, addig a ">>>" operátor esetén mindig 0 értékekkel tölti fel az üres helyeket.
a = b >> 2;
b = a >>> 2;
A műveletek során a második kifejezésben megadhatjuk, hogy hány értékhellyel tolódjon el a bináris adatsor.
x = += y;
x = x + y;
Bitszintű műveletek
A bitszintű műveletről egy rövid ismertetőt láthatunk.
A bitszintű művelet, nem egyenlő a gyakorlatban alkalmazott matematikai összeadással kivonással szorzással osztással.
Eredmény csak egészszám, törtek nélkül.
A biteltolást (bit shift) is szokás bitműveletnek tekinteni, mivel nem számértékeken, hanem bitek sorozatán dolgozik.
A biteltolás során a bináris számjegyek balra vagy jobbra tolódnak el.
A bit lehetséges értékei a 0 és az 1.
Főként programozók és informatikusok kedvelik, bináris fájlok értelmezésében van segítségükre.
~ | Bitszintű negálás Bitenkénti 1-s komplemens más néven bitenkénti negáló vagy tagadó művelet. A bitszintű negálás vagy komplemensképzés egyváltozós művelet. Ami minden biten logikai negációt hajt végre, az adott bináris érték egyes komplemensét képezve. Ahol az eredeti bit 0 volt, ott 1 lesz, ahol 1 volt, ott pedig 0. Például: NOT 0111 (decimális 7) = 1000 (decimális 8) Egyszerű, de látványos példa egy szürkeárnyalatos kép invertálása, ahol minden képpontot előjel nélküli számként tárolnak. |
var a = ~ 2; var a = ~ 3; var a = ~ 4; var a = ~ -2; var a = ~ -3; var a = ~ -4; |
|
<< | Bitszintű balra eltolás. Például: x = n << 2; kétszer balra osztja x, az n balra tolás eredményét, ami megegyezik az n négyes szorzásával. Biteltoló balra a bemeneti egész szám bitjeit anyiszor lépteti balra ami a második bemenet |
var a = -100 << 2; var a = -10 << 2; var a = -1 << 2; var a = 0 << 2; var a = 1 << 2; var a = 10 << 2; var a = 100 << 2; var a = 2 << 2; var a = 20 << 2; var a = 200 << 2; var a = 1 << 3; var a = 10 << 3; var a = 100 << 3; var a = 1 << 4; var a = 10 << 4; var a = 100 << 4; |
|
>> | Bitszintű jobbra eltolás Például: x = n >> 2; megegyezik az n négyes osztásával. Biteltoló jobbra a bemeneti egész szám bitjeit anyiszor lépteti jobbra ami a második bemenet |
var a = 0 >> 2; var a = 1 >> 2; var a = 10 >> 2; var a = 100 >> 2; var a = 2 >> 2; var a = 20 >> 2; var a = 200 >> 2; var a = 1 >> 3; var a = 10 >> 3; var a = 100 >> 3; var a = 1 >> 4; var a = 10 >> 4; var a = 100 >> 4; |
|
>>> | Helyérték nélküli jobbra eltolás | var a = 0 >>> 2; var a = 1 >>> 2; var a = 10 >>> 2; var a = 100 >>> 2; var a = 2 >>> 2; var a = 20 >>> 2; var a = 200 >>> 2; var a = 1 >>> 3; var a = 10 >>> 3; var a = 100 >>> 3; var a = 1 >>> 4; var a = 10 >>> 4; var a = 100 >>> 4; |
|
& | Bitszintű és Bitenkénti "És" más néven bit törlő művelet. A logikai "ÉS" műkodése alapján kapta a bittörlő nevet A bitszintű szorzás, "ÉS" művelet vagy "AND" két azonos hosszúságú bináris szám megfelelő bitpárjait sorban összeszorozva konjunkciót végez. Ha a két szám azonos helyi értékén lévő mindkét bit 1 értékű, az eredményül kapott bináris számban is 1-es lesz azon a helyi értéken (1 × 1 = 1); egyébként az eredmény 0 (1 × 0 = 0). Például: 0101 (decimális 5) AND 0011 (decimális 3) = 0001 (decimális 1) ( Nem összekeverendő a feltételes vizsgálatnál alkalmazott logikai "és"-el: a és b = a && b ) | var a = 0101 & 0011; var a = 5 & 3; var a = 0xff & 0x05; var a = 0x05 & 0xff; var a = 0x05 & 0x05; var a = 0xff & 0xff; var a = 0x02 & 0x05; var a = 0x05 & 0x02; |
|
^ | Bitszintű kizáró vagy Bitenkénti kizáró VAGY művelet fő felhasznállási területe a titkosítás A bitszintű kizáró vagy, illetve XOR két azonos hosszúságú bináris szám megfelelő bitpárjaival sorban kizáró vagy műveletet végez. Ha a két szám azonos helyiértékén lévő bitek értéke megegyezik (mindkettő 1 vagy mindkettő 0), az eredmény 0, ha különbözőek (az első 1 és a második 0, vagy fordítva), akkor az eredmény 1. Például: 0101 (decimális 5) XOR 0011 (decimális 3) = 0110 (decimális 6) |
var a = 0101 ^ 0011; var a = 5 ^ 3; var a = 0x1A ^ 0x1A; var a = 0x1A ^ 0x2A; var a = 0x2A ^ 0x1A; var a = 0x11 ^ 0x11; var a = 0x11 ^ 0x22; var a = 0x22 ^ 0x11; |
|
| | Bitszintű vagy Bitenkénti VAGY más néven 1-be állító. A logikai VAGY alapján kapta az 1-be állító nevet: A bitszintű VAGY, illetve OR művelet két azonos hosszúságú bináris szám megfelelő bitpárjaival sorban logikai "vagy" műveletet, azaz diszjunkciót végez. Ha a két szám azonos helyi értékén lévő bármelyik bit 1 értékű, az eredményül kapott bináris számban is 1-es lesz azon a helyi értéken, ha mindkét bit 0, akkor az eredmény is 0. Például: 0101 (decimális 5) OR 0011 (decimális 3) = 0111 (decimális 7) ( Nem összekeverendő a feltételes vizsgálatnál alkalmazott logikai "vagy"-al: a vagy b = a || b ) |
var a = 0101 | 0011; var a = 5 | 3; var a = 0x01 | 0x02; var a = 0x02 | 0x01; var a = 0x02 | 0x01; var a = 0x02 | 0x06; var a = 0x02 | 0x08; var a = 0x02 | 0x10; |