Anleitung zu mathematischen Hilfsprogrammen in Guave

Leitfaden für mathematische Hilfsmittel in Guave

1. Überblick

In diesem Artikel sehen wir einige nützliche mathematische Operationen, die in der Guaven-Bibliothek verfügbar sind.

Es gibt vier Mathematik-Hilfsklassen, die mit Guava verfügbar sind:

IntMath - Operation für int-Werte
LongMath - Operationen mit langen Werten
BigIntegerMath - Operationen anBigIntegers
DoubleMath - Operationen mit doppelten Werten

**2. IntMath Dienstprogramm**

IntMath wird verwendet, um mathematische Operationen an ganzzahligen Werten durchzuführen. Wir werden die Liste der verfügbaren Methoden durchgehen und jedes ihrer Verhaltensweisen erläutern.

2.1. binomial(int n, int k)

Diese Funktion berechnet den Binomialkoeffizienten von n und k. Es stellt sicher, dass das Ergebnis im ganzzahligen Bereich liegt. Andernfalls ergibt sichInteger.MAX_VALUE. Die Antwort kann mit der Formel n / k (n-k) abgeleitet werden:

@Test
public void whenBinomialOnTwoInt_shouldReturnResultIfUnderInt() {
    int result = IntMath.binomial(6, 3);

    assertEquals(20, result);
}

@Test
public void whenBinomialOnTwoInt_shouldReturnIntMaxIfOVerflowInt() {
    int result = IntMath.binomial(Integer.MAX_VALUE, 3);

    assertEquals(Integer.MAX_VALUE, result);
}

2.2. ceilingPowerOfTwo(int x)

Dies berechnet den Wert der kleinsten Zweierpotenz, die größer oder gleich x ist. Das Ergebnis n ist so, dass 2 ^ (n-1)

@Test
public void whenCeilPowOfTwoInt_shouldReturnResult() {
  int result = IntMath.ceilingPowerOfTwo(20);

  assertEquals(32, result);
}

**2.3. checkedAdd(int a, int b) und andere**

Diese Funktion berechnet die Summe der beiden Parameter. Dieser bietet eine zusätzliche Überprüfung, dieArithmeticException auslöst, wenn das Ergebnis überläuft:

@Test
public void whenAddTwoInt_shouldReturnTheSumIfNotOverflow() {
    int result = IntMath.checkedAdd(1, 2);

    assertEquals(3, result);
}

@Test(expected = ArithmeticException.class)
public void whenAddTwoInt_shouldThrowArithmeticExceptionIfOverflow() {
    IntMath.checkedAdd(Integer.MAX_VALUE, 100);
}

Guava hat Methoden für drei andere Operatoren überprüft, die überlaufen können:checkedMultiply,checkedPow, undcheckedSubtract.

2.4. divide(int p, int q, RoundingMode mode)

Dies ist eine einfache Unterteilung, die es uns jedoch ermöglicht, einen Rundungsmodus zu definieren:

@Test
public void whenDivideTwoInt_shouldReturnTheResultForCeilingRounding() {
    int result = IntMath.divide(10, 3, RoundingMode.CEILING);

    assertEquals(4, result);
}

@Test(expected = ArithmeticException.class)
public void whenDivideTwoInt_shouldThrowArithmeticExIfRoundNotDefinedButNeeded() {
    IntMath.divide(10, 3, RoundingMode.UNNECESSARY);
}

2.5. factorial(int n)

Berechnet den Fakultätswert von n. i.e the product of the first n positive integers. Gibt 1 zurück, wenn n = 0 ist, undInteger.MAX_VALUE, wenn das Ergebnis nicht in den int-Bereich passt. Das Ergebnis kann erhalten werden durch n x (n-1) x (n-2) x… .. x 2 x 1:

@Test
public void whenFactorialInt_shouldReturnTheResultIfInIntRange() {
    int result = IntMath.factorial(5);

    assertEquals(120, result);
}

@Test
public void whenFactorialInt_shouldReturnIntMaxIfNotInIntRange() {
    int result = IntMath.factorial(Integer.MAX_VALUE);

    assertEquals(Integer.MAX_VALUE, result);
}

2.6. floorPowerOfTwo(int x)

Gibt die größte Zweierpotenz zurück, deren Ergebnis kleiner oder gleich x ist. Das Ergebnis n ist so, dass 2 ^ n

@Test
public void whenFloorPowerOfInt_shouldReturnValue() {
    int result = IntMath.floorPowerOfTwo(30);

    assertEquals(16, result);
}

2.7. gcd(int a, int b)

Diese Funktion gibt uns den größten gemeinsamen Teiler von a und b:

@Test
public void whenGcdOfTwoInt_shouldReturnValue() {
    int result = IntMath.gcd(30, 40);
    assertEquals(10, result);
}

2.8. isPowerOfTwo(int x)

Gibt zurück, ob x eine Zweierpotenz ist oder nicht. Gibt true zurück, wenn der Wert eine Zweierpotenz ist, andernfalls false:

@Test
public void givenIntOfPowerTwo_whenIsPowOfTwo_shouldReturnTrue() {
    boolean result = IntMath.isPowerOfTwo(16);

    assertTrue(result);
}

@Test
public void givenIntNotOfPowerTwo_whenIsPowOfTwo_shouldReturnFalse() {
    boolean result = IntMath.isPowerOfTwo(20);

    assertFalse(result);
}

2.9. isPrime(int n)

Diese Funktion teilt uns mit, ob die übergebene Nummer eine Primzahl ist oder nicht:

@Test
public void givenNonPrimeInt_whenIsPrime_shouldReturnFalse() {
    boolean result = IntMath.isPrime(20);

    assertFalse(result);
}

2.10. log10(int x, RoundingMode mode)

Diese API berechnet den Logarithmus zur Basis 10 der angegebenen Zahl. Das Ergebnis wird mit dem angegebenen Rundungsmodus gerundet:

@Test
public void whenLog10Int_shouldReturnTheResultForCeilingRounding() {
    int result = IntMath.log10(30, RoundingMode.CEILING);

    assertEquals(2, result);
}

@Test(expected = ArithmeticException.class)
public void whenLog10Int_shouldThrowArithmeticExIfRoundNotDefinedButNeeded() {
    IntMath.log10(30, RoundingMode.UNNECESSARY);
}

2.11. log2(int x, RoundingMode mode)

Gibt den Logarithmus zur Basis 2 der angegebenen Zahl zurück. Das Ergebnis wird mit dem angegebenen Rundungsmodus gerundet:

@Test
public void whenLog2Int_shouldReturnTheResultForCeilingRounding() {
    int result = IntMath.log2(30, RoundingMode.CEILING);

    assertEquals(5, result);
}

@Test(expected = ArithmeticException.class)
public void whenLog2Int_shouldThrowArithmeticExIfRoundNotDefinedButNeeded() {
    IntMath.log2(30, RoundingMode.UNNECESSARY);
}

2.12. mean(int x, int y)

Mit dieser Funktion können wir den Mittelwert zweier Werte berechnen:

@Test
public void whenMeanTwoInt_shouldReturnTheResult() {
    int result = IntMath.mean(30, 20);

    assertEquals(25, result);
}

2.13. mod(int x, int m)

Gibt den Rest der Ganzzahldivision einer Zahl durch die andere zurück:

@Test
public void whenModTwoInt_shouldReturnTheResult() {
    int result = IntMath.mod(30, 4);
    assertEquals(2, result);
}

2.14. pow(int b, int k)

Gibt den Wert von b zur Potenz von k zurück:

@Test
public void whenPowTwoInt_shouldReturnTheResult() {
    int result = IntMath.pow(6, 4);

    assertEquals(1296, result);
}

**2.15. saturatedAdd(int a, int b) und andere**

Eine Summenfunktion mit dem Vorteil, dass Über- oder Unterläufe gesteuert werden, indem der WertInteger.MAX_VALUE bzw.Integer.MIN_VALUE zurückgegeben wird, wenn er auftritt:

@Test:
public void whenSaturatedAddTwoInt_shouldReturnTheResult() {
    int result = IntMath.saturatedAdd(6, 4);

    assertEquals(10, result);
}

@Test
public void whenSaturatedAddTwoInt_shouldReturnIntMaxIfOverflow() {
    int result = IntMath.saturatedAdd(Integer.MAX_VALUE, 1000);

    assertEquals(Integer.MAX_VALUE, result);
}

Es gibt drei weitere gesättigte APIs:saturatedMultiply,saturatedPow undsaturatedSubtract.

2.16. sqrt(int x, RoundingMode mode)

Gibt die Quadratwurzel der angegebenen Zahl zurück. Das Ergebnis wird mit dem angegebenen Rundungsmodus gerundet:

@Test
public void whenSqrtInt_shouldReturnTheResultForCeilingRounding() {
    int result = IntMath.sqrt(30, RoundingMode.CEILING);

    assertEquals(6, result);
}

@Test(expected = ArithmeticException.class)
public void whenSqrtInt_shouldThrowArithmeticExIfRoundNotDefinedButNeded() {
    IntMath.sqrt(30, RoundingMode.UNNECESSARY);
}

**3. LongMath Dienstprogramm**

LongMath hat Dienstprogramme fürLong-Werte. Die meisten Operationen ähneln dem DienstprogrammIntMath, mit wenigen hier beschriebenen Ausnahmen.

**3.1. mod(long x, int m) undmod(long x, long m)**

Gibt das x mod m zurück. Der Rest der ganzzahligen Division von x durch m:

@Test
public void whenModLongAndInt_shouldModThemAndReturnTheResult() {
    int result = LongMath.mod(30L, 4);

    assertEquals(2, result);
}

@Test
public void whenModTwoLongValues_shouldModThemAndReturnTheResult() {
    long result = LongMath.mod(30L, 4L);

    assertEquals(2L, result);
}

**4. BigIntegerMath Dienstprogramm**

BigIntegerMath wird verwendet, um mathematische Operationen für TypBigInteger durchzuführen.

Dieses Dienstprogramm verfügt über einige ähnliche Methoden wieIntMath.

5. DoubleMath-Dienstprogramm

Das DienstprogrammDoubleMathwird verwendet, um eine Operation für doppelte Werte auszuführen.

Ähnlich wie beim DienstprogrammBigIntegerist die Anzahl der verfügbaren Operationen begrenzt und weist Ähnlichkeit mit dem DienstprogrammIntMathauf. Wir werden einige außergewöhnliche Funktionen auflisten, die nur für diese Dienstprogrammklasse verfügbar sind.

5.1. isMathematicalInteger(double x)

Gibt zurück, ob x eine mathematische Ganzzahl ist. Es wird geprüft, ob die Zahl ohne Datenverlust als Ganzzahl dargestellt werden kann:

@Test
public void givenInt_whenMathematicalDouble_shouldReturnTrue() {
    boolean result = DoubleMath.isMathematicalInteger(5);

    assertTrue(result);
}

@Test
public void givenDouble_whenMathematicalInt_shouldReturnFalse() {
    boolean result = DoubleMath.isMathematicalInteger(5.2);

    assertFalse(result);
}

5.2. log2(double x)

Berechnet den Logarithmus zur Basis 2 von x:

@Test
public void whenLog2Double_shouldReturnResult() {
    double result = DoubleMath.log2(4);

    assertEquals(2, result, 0);
}

6. Fazit

In diesem kurzen Tutorial haben wir einige nützliche Funktionen des Guava-Mathematik-Dienstprogramms untersucht.

Wie immer kann der Quellcodeover on GitHub gefunden werden.

TOC