Java Math class at mga pamamaraan nito

Sa artikulong ito, magbibigay kami ng maikling pangkalahatang-ideya ng klase sa Math sa Java. Pag-usapan natin ang mga pamamaraan ng klase na ito at kung paano gamitin ang mga ito. Ang klase ng Math ay naninirahan sa java.lang package at nagbibigay ng isang set ng mga static na pamamaraan para sa pagsasagawa ng maraming iba't ibang mga kalkulasyon sa matematika. Ang mga sumusunod ay mga halimbawa ng mga kalkulasyon kung saan maaaring maging kapaki-pakinabang ang klase sa Math:

• Pagkalkula ng mga ganap na halaga (mga halaga ng modulo)
• Pagkalkula ng mga halaga ng mga function ng trigonometriko (sines, cosine, atbp.)
• Pagtaas sa iba't ibang antas
• Pagkuha ng mga ugat ng iba't ibang antas
• Random na pagbuo ng numero
• Pag-ikot
• atbp.

Sa ibaba ay susubukan naming tingnan kung paano nakakatulong ang klase ng Java Math na malutas ang mga problemang nakalista sa itaas. Simulan natin ang pagsusuri sa klase gamit ang mga pamamaraan na nagbibigay-daan sa iyong kalkulahin ang isang value modulo. Ang pamamaraan ng abs ay responsable para dito. Overloaded ang pamamaraang ito at ang klase ng Math ay may mga sumusunod na pagkakaiba:

• static na double abs(double a)
• static float abs(float a)
• static int abs(int a)
• static na mahabang abs (mahabang a)

Halimbawa ng paggamit:

public static void main(String[] args) {
        System.out.println(Math.abs(-1));      // 1
        System.out.println(Math.abs(-21.8d));  // 21.8
        System.out.println(Math.abs(4532L));   // 4532
        System.out.println(Math.abs(5.341f));  // 5.341
    }

Pagkalkula ng mga function ng trigonometriko

Binibigyang-daan ka ng klase ng Math na kalkulahin ang iba't ibang trigonometric function - mga sine, cosine, tangent, atbp. Ang kumpletong listahan ng mga pamamaraan ay matatagpuan sa opisyal na website ng dokumentasyon . Nasa ibaba ang isang listahan ng mga pamamaraang ito:

• static na dobleng kasalanan (doble a)
• static na double cos(double a)
• static na double tan(double a)
• static na dobleng asin(doble a)
• static na double acos(double a)
• static na double atan(double a)

Kinakalkula ng mga pamamaraan: sine, cosine, tangent, arcsine, arccosine, arctangent. Kinakalkula ng bawat paraan ang isang halaga para sa anggulo `a`. Ang parameter na ito ay ipinapasa sa bawat pamamaraan at sa bawat kaso ay sinusukat sa radians (at hindi sa mga degree, tulad ng nakasanayan na natin). Mayroong dalawang balita dito, mabuti at masama. Magsimula tayo sa mabuti. Ang klase sa Math ay may mga pamamaraan para sa pag-convert ng mga radian sa mga degree at mga degree sa mga radian:

• static na doble sa Degrees(dobleng angrad)
• static na double toRadians(double angdeg)

Dito, iko-convert ng toDegrees method ang anggulong angrad, na sinusukat sa radians, sa degrees. Ang toRadians na paraan, sa kabaligtaran, ay nagko-convert ng anggulo angdeg, sinusukat sa mga degree, sa mga radian. Ang masamang balita ay nangyayari ito nang may ilang pagkakamali. Narito ang isang halimbawa ng pagkalkula ng mga sine at cosine:

public static void main(String[] args) {
        System.out.println(Math.sin(Math.toRadians(0)));
        System.out.println(Math.sin(Math.toRadians(30)));
        System.out.println(Math.sin(Math.toRadians(90)));

        System.out.println(Math.cos(Math.toRadians(0)));
        System.out.println(Math.cos(Math.toRadians(30)));
        System.out.println(Math.cos(Math.toRadians(90)));
    }

Ang programa ay maglalabas ng:

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Na hindi masyadong tumutugma sa mga talahanayan ng mga sine at cosine, bahagyang dahil sa mga pagkakamali sa pag-convert mula sa mga degree sa radian.

Exponentiation

Upang itaas ang isang numero sa isang kapangyarihan, ang klase ng Math ay nagbibigay ng isang paraan ng pow, na may sumusunod na lagda:

static double pow(double a, double b)

Itinataas ng pamamaraang ito ang parameter na `a` sa kapangyarihan `b`. Mga halimbawa:

public static void main(String[] args) {
        System.out.println(Math.pow(1,2)); // 1.0
        System.out.println(Math.pow(2,2)); // 4.0
        System.out.println(Math.pow(3,2)); // 9.0
        System.out.println(Math.pow(4,2)); // 16.0
        System.out.println(Math.pow(5,2)); // 25.0

        System.out.println(Math.pow(1,3)); // 1.0
        System.out.println(Math.pow(2,3)); // 8.0
        System.out.println(Math.pow(3,3)); // 27.0
        System.out.println(Math.pow(4,3)); // 64.0
        System.out.println(Math.pow(5,3)); // 125.0
    }

Pagkuha ng ugat

Ang klase sa Math ay nagbibigay ng mga pamamaraan para sa pagkuha ng square at cube roots. Ang mga sumusunod na pamamaraan ay responsable para sa pamamaraang ito:

• static na double sqrt(double a)
• static na double cbrt(double a)

Kinukuha ng sqrt method ang square root, at ang cbrt method ay kumukuha ng cube root. Mga halimbawa:

public static void main(String[] args) {
        System.out.println(Math.sqrt(4));   // 2.0
        System.out.println(Math.sqrt(9));   // 3.0
        System.out.println(Math.sqrt(16));  // 4.0

        System.out.println(Math.cbrt(8));   // 2.0
        System.out.println(Math.cbrt(27));  // 3.0
        System.out.println(Math.cbrt(125)); // 5.0
    }

Random na pagbuo ng numero

Upang makabuo ng mga random na numero, ang klase ng Math ay nagbibigay ng random na pamamaraan. Ang paraang ito ay bumubuo ng random na positibong tunay (doble) na numero sa hanay mula 0.0 hanggang 1.0. Ang lagda ng pamamaraan ay ganito ang hitsura:

public static double random()

Tingnan natin ang mga halimbawa:

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        System.out.println(Math.random());
    }
}

Pagkatapos isagawa ang pangunahing pamamaraan, ang mga sumusunod ay ipinakita sa console:

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Sa kaunting pagmamanipula, maaari mong gamitin ang random na paraan ng klase ng Math upang makakuha ng integer na mga random na numero na nasa isang tiyak na hanay. Narito ang isang halimbawa ng isang function na tumatagal ng dalawang argument na min at max at nagbabalik ng random na integer na nasa hanay mula sa min (inclusive) hanggang max (inclusive):

static int randomInARange(int min, int max) {
    return  (int) (Math.random() * ((max - min) + 1)) + min;
}

Sumulat tayo ng isang Pangunahing pamamaraan kung saan susuriin natin ang pamamaraang randomInARange:

public class MathExample {


    public static void main(String[] args) {
        // Карта, в которой мы будем хранить количество выпадений Howого-то числа
        Map<Integer, Integer> map = new TreeMap<>();

        // За 10000 операций
        for (int i = 0; i < 10000; i++) {

            // Сгенерируем рандомное число от -10 включительно до 10 включительно
            final Integer randomNumber = randomInARange(-10, 10);


            if (!map.containsKey(randomNumber)) {
                // Если карта еще не содержит "выпавшего случайного числа"
                // Положим его в карту с кол-вом выпадений = 1
                map.put(randomNumber, 1);
            } else {
                // Иначе, увеличим количество выпадений данного числа на 1
                map.put(randomNumber, map.get(randomNumber) + 1);
            }
        }

        // Выведем на экран содержимое карты в формате ключ=[meaning]
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            System.out.println(String.format("%d=[%d]", entry.getKey(), entry.getValue()));
        }
    }

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }
}

Pagkatapos patakbuhin ang pangunahing pamamaraan, ang output ay maaaring magmukhang ganito:

-10=[482]
-9=[495]
-8=[472]
-7=[514]
-6=[457]
-5=[465]
-4=[486]
-3=[500]
-2=[490]
-1=[466]
0=[458]
1=[488]
2=[461]
3=[470]
4=[464]
5=[463]
6=[484]
7=[479]
8=[459]
9=[503]
10=[444]

Process finished with exit code 0

Pag-ikot

Para sa mga rounding na numero sa Java, ang isa sa mga tool ay ang mga pamamaraan ng klase ng Math. Mas tiyak, ang mga pamamaraan ng bilog, kisame at sahig:

• static na mahabang bilog (doble a)
• static int round(float a)
• static na double floor (doble a)
• static na double ceil(double a)

Ang paraan ng pag-ikot - pag-ikot gaya ng dati sa karaniwang tao. Kung ang fractional na bahagi ng numero ay mas malaki sa o katumbas ng 0.5, ang numero ay ibi-round up, kung hindi, ibi-round pababa. Ang paraan ng sahig ay palaging, anuman ang mga halaga ng fractional na bahagi, ang numero pababa (patungo sa negatibong infinity). Ang pamamaraan ng kisame, sa kabaligtaran, anuman ang mga halaga ng fractional na bahagi, ay nagbi-round ng mga numero (patungo sa positibong infinity). Tingnan natin ang mga halimbawa:

public static void main(String[] args) {
    System.out.println(Math.round(1.3)); // 1
    System.out.println(Math.round(1.4)); // 1
    System.out.println(Math.round(1.5)); // 2
    System.out.println(Math.round(1.6)); // 2

    System.out.println(Math.floor(1.3)); // 1.0
    System.out.println(Math.floor(1.4)); // 1.0
    System.out.println(Math.floor(1.5)); // 1.0
    System.out.println(Math.floor(1.6)); // 1.0

    System.out.println(Math.ceil(1.3)); // 2.0
    System.out.println(Math.ceil(1.4)); // 2.0
    System.out.println(Math.ceil(1.5)); // 2.0
    System.out.println(Math.ceil(1.6)); // 2.0
}

Konklusyon

Sa artikulong ito, tiningnan natin ang klase sa Math. Tiningnan namin kung paano mo magagamit ang klase na ito:

• Kalkulahin ang mga halaga ng modulo;
• Kalkulahin ang mga halaga ng trigonometriko function;
• Itaas ang mga numero sa mga kapangyarihan;
• I-extract ang square at cube roots;
• Bumuo ng mga random na numero;
• Mga bilog na numero.

Mayroong maraming iba pang mga kawili-wiling pamamaraan sa klase na ito. Na matatagpuan sa opisyal na website ng dokumentasyon . Buweno, para sa unang kakilala, ang mga pamamaraan na nakalista sa itaas ay sapat na.