Examples with Rational android.util.Rational used on opensource projects

Example 61 with Rational

use of android.util.Rational in project android_frameworks_base by AOSPA.

the class RangeTest method testEquals.

@SmallTest
public void testEquals() {
    Range<Float> oneHalf = Range.create(1.0f, 2.0f);
    Range<Float> oneHalf2 = new Range<Float>(1.0f, 2.0f);
    assertEquals(oneHalf, oneHalf2);
    assertHashCodeEquals(oneHalf, oneHalf2);
    Range<Float> twoThirds = new Range<Float>(2.0f, 3.0f);
    Range<Float> twoThirds2 = Range.create(2.0f, 3.0f);
    assertEquals(twoThirds, twoThirds2);
    assertHashCodeEquals(twoThirds, twoThirds2);
    Range<Rational> negativeOneTenthPositiveOneTenth = new Range<Rational>(new Rational(-1, 10), new Rational(1, 10));
    Range<Rational> negativeOneTenthPositiveOneTenth2 = Range.create(new Rational(-1, 10), new Rational(1, 10));
    assertEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
    assertHashCodeEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
}

Example 62 with Rational

use of android.util.Rational in project android_frameworks_base by AOSPA.

the class RationalTest method testCompareTo.

@SmallTest
public void testCompareTo() {
    // unit is equal to itself
    assertCompareEquals(UNIT, new Rational(1, 1));
    // NaN is greater than anything but NaN
    assertCompareEquals(NaN, new Rational(0, 0));
    assertGreaterThan(NaN, UNIT);
    assertGreaterThan(NaN, POSITIVE_INFINITY);
    assertGreaterThan(NaN, NEGATIVE_INFINITY);
    assertGreaterThan(NaN, ZERO);
    // Positive infinity is greater than any other non-NaN
    assertCompareEquals(POSITIVE_INFINITY, new Rational(1, 0));
    assertGreaterThan(POSITIVE_INFINITY, UNIT);
    assertGreaterThan(POSITIVE_INFINITY, NEGATIVE_INFINITY);
    assertGreaterThan(POSITIVE_INFINITY, ZERO);
    // Negative infinity is smaller than any other non-NaN
    assertCompareEquals(NEGATIVE_INFINITY, new Rational(-1, 0));
    assertLessThan(NEGATIVE_INFINITY, UNIT);
    assertLessThan(NEGATIVE_INFINITY, POSITIVE_INFINITY);
    assertLessThan(NEGATIVE_INFINITY, ZERO);
    // A finite number with the same denominator is trivially comparable
    assertGreaterThan(new Rational(3, 100), new Rational(1, 100));
    assertGreaterThan(new Rational(3, 100), ZERO);
    // Compare finite numbers with different divisors
    assertGreaterThan(new Rational(5, 25), new Rational(1, 10));
    assertGreaterThan(new Rational(5, 25), ZERO);
    // Compare finite numbers with different signs
    assertGreaterThan(new Rational(5, 25), new Rational(-1, 10));
    assertLessThan(new Rational(-5, 25), ZERO);
}

Example 63 with Rational

use of android.util.Rational in project android_frameworks_base by AOSPA.

the class RationalTest method testReduction.

@SmallTest
public void testReduction() {
    Rational moreComplicated = new Rational(5 * 78, 7 * 78);
    assertEquals(new Rational(5, 7), moreComplicated);
    assertEquals(5, moreComplicated.getNumerator());
    assertEquals(7, moreComplicated.getDenominator());
    Rational posInf = new Rational(5, 0);
    assertEquals(1, posInf.getNumerator());
    assertEquals(0, posInf.getDenominator());
    assertEquals(POSITIVE_INFINITY, posInf);
    Rational negInf = new Rational(-100, 0);
    assertEquals(-1, negInf.getNumerator());
    assertEquals(0, negInf.getDenominator());
    assertEquals(NEGATIVE_INFINITY, negInf);
    Rational zero = new Rational(0, -100);
    assertEquals(0, zero.getNumerator());
    assertEquals(1, zero.getDenominator());
    assertEquals(ZERO, zero);
    Rational flipSigns = new Rational(1, -1);
    assertEquals(-1, flipSigns.getNumerator());
    assertEquals(1, flipSigns.getDenominator());
    Rational flipAndReduce = new Rational(100, -200);
    assertEquals(-1, flipAndReduce.getNumerator());
    assertEquals(2, flipAndReduce.getDenominator());
}

Example 64 with Rational

use of android.util.Rational in project android_frameworks_base by AOSPA.

the class RationalTest method testValueConversions.

@SmallTest
public void testValueConversions() {
    // Unit, simple case
    assertValueEquals(UNIT, 1.0f);
    assertValueEquals(UNIT, 1.0);
    assertValueEquals(UNIT, 1L);
    assertValueEquals(UNIT, 1);
    assertValueEquals(UNIT, (short) 1);
    // Zero, simple case
    assertValueEquals(ZERO, 0.0f);
    assertValueEquals(ZERO, 0.0);
    assertValueEquals(ZERO, 0L);
    assertValueEquals(ZERO, 0);
    assertValueEquals(ZERO, (short) 0);
    // NaN is 0 for integers, not-a-number for floating point
    assertValueEquals(NaN, Float.NaN);
    assertValueEquals(NaN, Double.NaN);
    assertValueEquals(NaN, 0L);
    assertValueEquals(NaN, 0);
    assertValueEquals(NaN, (short) 0);
    // Positive infinity, saturates upwards for integers
    assertValueEquals(POSITIVE_INFINITY, Float.POSITIVE_INFINITY);
    assertValueEquals(POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    assertValueEquals(POSITIVE_INFINITY, Long.MAX_VALUE);
    assertValueEquals(POSITIVE_INFINITY, Integer.MAX_VALUE);
    assertValueEquals(POSITIVE_INFINITY, (short) -1);
    // Negative infinity, saturates downwards for integers
    assertValueEquals(NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY);
    assertValueEquals(NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
    assertValueEquals(NEGATIVE_INFINITY, Long.MIN_VALUE);
    assertValueEquals(NEGATIVE_INFINITY, Integer.MIN_VALUE);
    assertValueEquals(NEGATIVE_INFINITY, (short) 0);
    // Normal finite values, round down for integers
    final Rational oneQuarter = new Rational(1, 4);
    assertValueEquals(oneQuarter, 1.0f / 4.0f);
    assertValueEquals(oneQuarter, 1.0 / 4.0);
    assertValueEquals(oneQuarter, 0L);
    assertValueEquals(oneQuarter, 0);
    assertValueEquals(oneQuarter, (short) 0);
    final Rational nineFifths = new Rational(9, 5);
    assertValueEquals(nineFifths, 9.0f / 5.0f);
    assertValueEquals(nineFifths, 9.0 / 5.0);
    assertValueEquals(nineFifths, 1L);
    assertValueEquals(nineFifths, 1);
    assertValueEquals(nineFifths, (short) 1);
    final Rational negativeHundred = new Rational(-1000, 10);
    assertValueEquals(negativeHundred, -100.f / 1.f);
    assertValueEquals(negativeHundred, -100.0 / 1.0);
    assertValueEquals(negativeHundred, -100L);
    assertValueEquals(negativeHundred, -100);
    assertValueEquals(negativeHundred, (short) -100);
    // Short truncates if the result is too large
    assertValueEquals(new Rational(Integer.MAX_VALUE, 1), (short) Integer.MAX_VALUE);
    assertValueEquals(new Rational(0x00FFFFFF, 1), (short) 0x00FFFFFF);
    assertValueEquals(new Rational(0x00FF00FF, 1), (short) 0x00FF00FF);
}

Example 65 with Rational

use of android.util.Rational in project android_frameworks_base by AOSPA.

the class RationalTest method testEquals.

@SmallTest
public void testEquals() {
    Rational r = new Rational(1, 2);
    assertEquals(1, r.getNumerator());
    assertEquals(2, r.getDenominator());
    assertEquals(r, r);
    assertFalse(r.equals(null));
    assertFalse(r.equals(new Object()));
    Rational twoThirds = new Rational(2, 3);
    assertFalse(r.equals(twoThirds));
    assertFalse(twoThirds.equals(r));
    Rational fourSixths = new Rational(4, 6);
    assertEquals(twoThirds, fourSixths);
    assertEquals(fourSixths, twoThirds);
    Rational moreComplicated = new Rational(5 * 6 * 7 * 8 * 9, 1 * 2 * 3 * 4 * 5);
    Rational moreComplicated2 = new Rational(5 * 6 * 7 * 8 * 9 * 78, 1 * 2 * 3 * 4 * 5 * 78);
    assertEquals(moreComplicated, moreComplicated2);
    assertEquals(moreComplicated2, moreComplicated);
    // Ensure negatives are fine
    twoThirds = new Rational(-2, 3);
    fourSixths = new Rational(-4, 6);
    assertEquals(twoThirds, fourSixths);
    assertEquals(fourSixths, twoThirds);
    moreComplicated = new Rational(-5 * 6 * 7 * 8 * 9, 1 * 2 * 3 * 4 * 5);
    moreComplicated2 = new Rational(-5 * 6 * 7 * 8 * 9 * 78, 1 * 2 * 3 * 4 * 5 * 78);
    assertEquals(moreComplicated, moreComplicated2);
    assertEquals(moreComplicated2, moreComplicated);
    // Zero is always equal to itself
    Rational zero2 = new Rational(0, 100);
    assertEquals(ZERO, zero2);
    assertEquals(zero2, ZERO);
    // NaN is always equal to itself
    Rational nan = NaN;
    Rational nan2 = new Rational(0, 0);
    assertTrue(nan.equals(nan));
    assertTrue(nan.equals(nan2));
    assertTrue(nan2.equals(nan));
    assertFalse(nan.equals(r));
    assertFalse(r.equals(nan));
    // Infinities of the same sign are equal.
    Rational posInf = POSITIVE_INFINITY;
    Rational posInf2 = new Rational(2, 0);
    Rational negInf = NEGATIVE_INFINITY;
    Rational negInf2 = new Rational(-2, 0);
    assertEquals(posInf, posInf);
    assertEquals(negInf, negInf);
    assertEquals(posInf, posInf2);
    assertEquals(negInf, negInf2);
    // Infinities aren't equal to anything else.
    assertFalse(posInf.equals(negInf));
    assertFalse(negInf.equals(posInf));
    assertFalse(negInf.equals(r));
    assertFalse(posInf.equals(r));
    assertFalse(r.equals(negInf));
    assertFalse(r.equals(posInf));
    assertFalse(posInf.equals(nan));
    assertFalse(negInf.equals(nan));
    assertFalse(nan.equals(posInf));
    assertFalse(nan.equals(negInf));
}