Weblap Hová jutunk?

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:

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
nnlg n1/n1/nlg 1/n =
-lg n
2 * π6.283190.7982 1 : 2*Π0.159160.2018-1
4 * Π12.566371.0992 1 : 4*Π0.07958 0.9008-2
Π : 21.57080 0.1961 2 : Π0.63662 0.8039-1
Π : 31.047200.0200 3 : Π0.95493 0.9800-1
4 * Π : 34.188790.62213 : 4*Π0.238730.3779-1
Π29.869600.99431 : Π20.101320.0057-1
Π1.772450.24861 : √Π0.101320.0057-1
2*Π2.506630.39911 : √2*Π0.398940.6009-1
Π:20.88623 0.9475-12 : √Π = c1.128380.0525
Π331.006281.4914 1 : Π30.032250,5086-2
34*Π : 31.611990.207433 : 4*Π0.620350.7926-1
Π : 360o0.0087260.9409-3 360o : Π114.59o2.0591
Π : 180o0.0174530.2419-2 180o : Π57.29578o1.7581
Π : 10800'0.000290890.4637-4 10800' : Π3437.747'3.5363
Π : 648000''0,00000484810.6856-6 648000'' : Π206264.8''5.3144
e27.38960.8686 1 : e20.135340.1314-1
e1.648720.21711 : √e0.606530.7829-1
g9.81 m/s20.9917 1 : g0.10190.0083-1
Π : √g1.0030.0013 g:Π0.99700.9987-1



JavaScript matematikai konstansok.

Math.EA természetes alapú logaritmus alapja ( 2.718 ) Math.E =
Math.LN2A kettő természetes alapú logaritmus alapja ( 0.693 ) Math.LN2 =
Math.LN10A tíz természetes alapú logaritmusa ( 2.302 ) Math.LN10 =
Math.LOG2EAz E kettes alapú logaritmusa ( 1.442 ) Math.LOG2E =
Math.LOG10EAz E természetes alapú logaritmusa ( 0.434 ) Math.LOG10E =
Math.PIKör kerület, és átmérő hányadosa ( 3.14159 ) Math.PI =
Math.SQRT1_2Az egyketted négyzetgyöke ( 0.707 ) Math.SQRT1_2 =
Math.SQRT2A 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;




Vissza a lap elejére