use of android.util.Rational in project android_frameworks_base by ResurrectionRemix.
the class RationalTest method testConstructor.
@SmallTest
public void testConstructor() {
// Simple case
Rational r = new Rational(1, 2);
assertEquals(1, r.getNumerator());
assertEquals(2, r.getDenominator());
// Denominator negative
r = new Rational(-1, 2);
assertEquals(-1, r.getNumerator());
assertEquals(2, r.getDenominator());
// Numerator negative
r = new Rational(1, -2);
assertEquals(-1, r.getNumerator());
assertEquals(2, r.getDenominator());
// Both negative
r = new Rational(-1, -2);
assertEquals(1, r.getNumerator());
assertEquals(2, r.getDenominator());
// Infinity.
r = new Rational(1, 0);
assertEquals(1, r.getNumerator());
assertEquals(0, r.getDenominator());
// Negative infinity.
r = new Rational(-1, 0);
assertEquals(-1, r.getNumerator());
assertEquals(0, r.getDenominator());
// NaN.
r = new Rational(0, 0);
assertEquals(0, r.getNumerator());
assertEquals(0, r.getDenominator());
}
use of android.util.Rational in project android_frameworks_base by ResurrectionRemix.
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);
}
use of android.util.Rational in project android_frameworks_base by ResurrectionRemix.
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));
}
use of android.util.Rational in project android_frameworks_base by ResurrectionRemix.
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);
}
use of android.util.Rational in project android_frameworks_base by ResurrectionRemix.
the class StaticMetadata method getAeCompensationRangeChecked.
/**
* Get value of key android.control.aeCompensationRange and do the sanity check.
*
* @return default value if the value is null or malformed.
*/
public Range<Integer> getAeCompensationRangeChecked() {
Key<Range<Integer>> key = CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE;
Range<Integer> compensationRange = getValueFromKeyNonNull(key);
Rational compensationStep = getAeCompensationStepChecked();
float compensationStepF = compensationStep.floatValue();
final Range<Integer> DEFAULT_RANGE = Range.create((int) (CONTROL_AE_COMPENSATION_RANGE_DEFAULT_MIN / compensationStepF), (int) (CONTROL_AE_COMPENSATION_RANGE_DEFAULT_MAX / compensationStepF));
final Range<Integer> ZERO_RANGE = Range.create(0, 0);
if (compensationRange == null) {
return ZERO_RANGE;
}
// Legacy devices don't have a minimum range requirement
if (isHardwareLevelLimitedOrBetter() && !compensationRange.equals(ZERO_RANGE)) {
checkTrueForKey(key, " range value must be at least " + DEFAULT_RANGE + ", actual " + compensationRange + ", compensation step " + compensationStep, compensationRange.getLower() <= DEFAULT_RANGE.getLower() && compensationRange.getUpper() >= DEFAULT_RANGE.getUpper());
}
return compensationRange;
}
Aggregations