streamalism.org

1. Bemutatkozás

Ebben az oktatóanyagban leírjuk a Math osztály, amely hasznos statikus módszereket kínál a numerikus műveletek végrehajtásához, például exponenciális, logaritmus stb.

2. Alapvető matematikai függvények

Az első módszercsoport, amelyre kiterjedünk, az alapvető matematikai függvények, például az abszolút érték, a négyzetgyök, a két érték közötti maximum vagy minimum.

2.1. abs ()

A abs () A method egy adott érték abszolút értékét adja vissza:

Math.abs (-5); // 5-öt ad vissza

Hasonlóképpen, mások közül, akiket ezután láthatunk, abs () paraméterként elfogadja az an int, hosszú, úszó vagy kettős és visszaadja a relatívat.

2.2. hadifogoly()

Kiszámítja és visszaadja az első argumentum értékét a második erejéig:

Math.pow (5,2); // 25-öt ad vissza

Itt részletesebben tárgyaljuk ezt a módszert.

2.3. sqrt ()

Az a lekerekített pozitív négyzetgyökét adja eredményül kettős:

Math.sqrt (25); // 5-öt ad vissza

Ha az érv az NaN vagy kevesebb, mint nulla, az eredmény NaN.

2.4. cbrt ()

Hasonlóképpen, cbrt () az a kocka gyökerét adja vissza kettős:

Math.cbrt (125); // 5-öt ad vissza

2.5. max ()

Amint a módszer neve is mutatja, a két érték közötti maximumot adja vissza:

Math.max (5,10); // 10-et ad vissza

Itt is a módszer elfogadja int, hosszú, úszó vagy kettős.

2.6. perc ()

Ugyanúgy, perc () két érték közötti minimumot adja vissza:

Math.min (5,10); // 5-öt ad vissza

2.7. véletlen()

Álvéletlenszerűen tér vissza kettős nagyobb vagy egyenlő 0,0 és kevesebb, mint 1,0:

kettős véletlenszerű = Math.random ()

Ezt csináld meg, a módszer egyetlen példányt hoz létre java.util.Random () számgenerátor, amikor először hívják.

Ezt követően a metódus összes hívása esetén ugyanazt a példányt használják. Vegye figyelembe, hogy a módszer szinkronizált, így több szál is használható.

Ebben a cikkben további példákat találhatunk egy véletlenszerű generálására.

2.8. signum ()

Akkor hasznos, ha ismerni kell az érték előjelét:

A Math.signum (-5) // -1-et ad vissza

Ez a módszer 1,0-et ad vissza, ha az argumentum nagyobb, mint nulla vagy -1,0, ellenkező esetben. Ha az argumentum nulla pozitív vagy nulla negatív, az eredmény megegyezik az argumentummal.

A bemenet lehet a úszó vagy a kettős.

2.9. copySign ()

Két paramétert fogad el, és az első argumentumot a második argumentum előjelével adja vissza:

Math.copySign (5, -1); // -5-et ad vissza

Érvek is lehetnek úszó vagy kettős.

3. Exponenciális és logaritmikus függvények

Az alapvető matematikai függvények mellett a Math osztály exponenciális és logaritmikus függvények megoldására szolgáló módszereket tartalmaz.

3.1. exp ()

A exp () módszer megkapja a kettős argumentumot, és az emelt Euler-számot adja vissza az argumentum erejéig (ex):

Math.exp (1); // 2,718281828459045 értéket ad vissza

3.2. expm1 ()

Hasonló a fenti módszerhez, expm1 () kiszámítja az Euler számát, amelyet a kapott érv erejéig emel, de hozzáad -1ex -1):

Math.expm1 (1); // visszatér 1.718281828459045

3.3. napló ()

Visszaadja az a természetes logaritmusát kettős érték:

Math.log (Math.E); // 1-et ad vissza

3.4. log10 ()

Visszaadja a logaritmust az argumentum 10. bázisában:

Math.log10 (10); // 1-et ad vissza

3.5. log1p ()

Hasonlóképpen a napló (), de hozzáad 1-et az ln (1 + x) argumentumhoz:

Math.log1p (Math.E); // 1,3132616875182228 értéket ad vissza

4. Trigonometrikus függvények

Amikor geometriai képletekkel kell dolgoznunk, mindig szükségünk van trigonometrikus függvényekre; a Math osztály biztosítja ezeket számunkra.

4.1. bűn()

Kap egy kislemezt, kettős argumentum, amely szöget képvisel (radiánban) és visszaadja a trigonometrikus szinuszt:

Math.sin (Math.PI / 2); // 1-et ad vissza

4.2. kötözősaláta()

Ugyanúgy, kötözősaláta() egy szög trigonometrikus koszinuszát adja vissza (radiánban):

Math.cos (0); // 1-et ad vissza

4.3. Cser()

Egy szög trigonometrikus érintőjét adja vissza (radiánban):

Math.tan (Math.PI / 4); // 1-et ad vissza

4.4. sinh (), cosh (), tanh ()

Visszaadják az a hiperbolikus szinuszát, hiperbolikus koszinuszát és hiperbolikus tangensét kettős érték:

Math.sinh (Math.PI); Math.cosh (Math.PI); Math.tanh (Math.PI);

4.5. mint a()

A kapott argumentum ív szinuszát adja eredményül:

Math.asin (1); // adja vissza a pi / 2 értéket

Az eredmény egy szög a tartományban -pi/ 2-ig pi/2.

4.6. acos ()

A kapott argumentum ív koszinuszát adja eredményül:

Math.acos (0); // adja vissza a pi / 2 értéket

Az eredmény egy 0 és 0 közötti szög pi.

4.7. atan ()

A kapott argumentum ív tangensét adja eredményül:

Math.atan (1); // adja vissza a pi / 4 értéket

Az eredmény egy szög a tartományban -pi/ 2-ig pi/2.

4.8. atan2 ()

Végül, atan2 () megkapja a koordináta koordinátát y és az abszcissza koordinátája x, és visszaadja a szöget ϑ a téglalap alakú koordináták átalakításától (x, y) polárkoordinátákra (r, ϑ):

Math.atan2 (1,1); // adja vissza a pi / 4 értéket

4.9. fokozatokhoz ()

Ez a módszer akkor hasznos, ha a radiánokat fokra kell konvertálnunk:

Math.toDegrees (Math.PI); // 180-at ad vissza

4.10. toRadians ()

Másrészről toRadians () hasznos az ellenkező átalakításhoz:

Math.toRadians (180); // visszaadja pi

Ne feledje, hogy az ebben a szakaszban látott módszerek többsége radiánban fogadja el az érvelést, így amikor fokszöget zárunk be, ezt a módszert kell használni, mielőtt trigonometrikus módszert alkalmaznánk.

További példákért tekintse meg itt.

5. Kerekítés és egyéb funkciók

Végül nézzük meg a kerekítési módszereket.

5.1. mennyezet ()

mennyezet () hasznos, ha egy egész számot a legkisebbre kell kerekítenünk kettős az argumentumnál nagyobb vagy azzal egyenlő érték:

Math.ceil (Math.PI); // 4-et ad vissza

Ebben a cikkben ezzel a módszerrel számot kerekítünk a legközelebbi százra.

5.2. padló()

Egy számot a legnagyobbra kerekíteni kettős ez kisebb vagy egyenlő azzal az érvvel, amelyet használnunk kell padló():

Math.floor (Math.PI); // 3-at ad vissza

5.3. getExponent ()

Az argumentum elfogulatlan kitevőjét adja eredményül.

Az érv lehet a kettős vagy a úszó:

Math.getExponent (333,3); // a 8 Math.getExponent (222.2f) értéket adja vissza; // 7-et ad vissza

5.4. IEEEreminder ()

Kiszámítja az első (osztalék) és a második (osztó) argumentum felosztását, és a maradékot adja vissza az IEEE 754 szabvány szerint:

Math.IEEEremainder (5,2); // 1-et ad vissza

5.5. nextAfter ()

Ez a módszer akkor hasznos, ha ismernünk kell az a szomszédját kettős vagy a úszó érték:

Math.nextAfter (1,95f, 1); // visszatér 1,9499999 Math.nextAfter (1,95f, 2); // az 1.9500002 értéket adja vissza

Két érvet fogad el, az első az az érték, amelynek tudni szeretné a szomszédos számot, a második pedig az irány.

5.6. következö()

Hasonlóképpen az előző módszer, de ez csak a pozitív végtelen irányába adja vissza a szomszédos értéket:

Math.nextUp (1,95f); // az 1.9500002 értéket adja vissza

5.7. rint ()

Visszaadja a kettős ez az argumentum legközelebbi egész értéke:

Math.rint (1,95f); // a 2.0-t adja vissza

5.8. kerek()

A fenti módszerrel megegyezően, de ez egy int érték, ha az argumentum a úszó és a hosszú érték, ha az argumentum a kettős:

int eredmény = Math.kör (1,95f); // 2 hosszú eredményt ad2 = Math.round (1.95) // 2-t ad vissza

5.9. scalb ()

A Scalb a „skála bináris” rövidítése. Ez a függvény egy váltást, egy konverziót és egy kettős szorzást hajt végre:

Math.scalb (3, 4); // 3 * 2 ^ 4 értéket ad vissza

5.10. ulp ()

A ulp () metódus adja vissza a számtól a legközelebbi szomszédokhoz való távolságot:

Math.ulp (1); // visszatér 1,1920929E-7 Math.ulp (2); // visszaadja a 2,3841858E-7 Math.ulp (4) értéket; // a 4.7683716E-7 eredményt adja Math.ulp (8); // visszaadja a 9.536743E-7 értéket

5.11. hipot ()

Visszaadja argumentuma négyzetösszegének négyzetgyökét:

Math.hypot (4, 3); // 5-öt ad vissza

A módszer a négyzetgyöket közbenső túlcsordulás vagy alulcsordulás nélkül számítja ki.

Ebben a cikkben ezt a módszert használjuk a két pont közötti távolság kiszámításához.

6. Java 8 matematikai függvények

A Math osztály át lett vizsgálva a Java 8-ban, hogy új módszereket tartalmazzon a leggyakoribb számtani műveletek végrehajtására.

Ezeket a módszereket egy másik cikkben tárgyaltuk.

7. Állandó mezők

A módszerek mellett Math osztály két állandó mezőt deklarál:

public static final double E nyilvános statikus végső kettős PI

Amelyek a természetes logaritmusok alapjához közelebb eső értéket és a piill.

8. Következtetés

Ebben a cikkben leírtuk azokat az API-kat, amelyeket a Java matematikai műveletekhez biztosít.

Szokás szerint az itt bemutatott összes kódrészlet elérhető a GitHubon.