Denis
/
Futurum
mirror of https://github.com/D45Hub/Futurum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Units test (#2) 

Added a unit test for the Units.
Fixed division test mistake
fixed some bugs and unit tests

Co-authored-by: D45Hub <61849425+D45Hub@users.noreply.github.com>
pull/5/head
DSinMeliodas 4 years ago
committed by GitHub
parent
0d28192f94
commit
d74c790844
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 343 additions and 13 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 53
      app/src/main/java/com/futurumgame/base/additionalDatatypes/Units.java
  2. 303
      app/src/test/java/com/futurumgame/base/UnitsTest.java

53
app/src/main/java/com/futurumgame/base/additionalDatatypes/Units.java
View File

@ -19,14 +19,17 @@ public final class Units extends Number implements Comparable<Units> {
private static final Units InternalPositiveInfinity = new Units(DoublePosInfinity, DoublePosInfinity, false);
private static final Units InternalNegativeInfinity = new Units(DoubleNegInfinity, DoublePosInfinity, false);
private static final Units InternalNaN = new Units(DoubleZero, DoubleNaN, false);
private static final Units InternalNaN = new Units(DoubleNaN, DoubleNaN, false);
private static final Units InternalZero = new Units(DoubleZero, DoubleZero, false);
private static final Units InternalOne = new Units(DoubleOne, DoubleZero,false);
private static final Units InternalTen = new Units(DoubleOne, DoubleOne,false);
public static final Units PositiveInfinity = new Units(InternalPositiveInfinity);
public static final Units NegativeInfinity = new Units(InternalNegativeInfinity);
public static final Units NaN = new Units(InternalNaN);
public static final Units Zero = new Units(InternalZero);
public static final Units One = new Units(InternalOne);
public static final Units Ten = new Units(InternalTen);
private double value;
private double scale;
@ -176,42 +179,66 @@ public final class Units extends Number implements Comparable<Units> {
public void nRoot(double root) {
if (Double.isInfinite(root)) {
value = 1;
scale = 0;
value = InternalOne.value;
scale = InternalOne.scale;
return;
}
value = Math.pow(value, 1 / root);
scale /= root;
double scaleDiff = scale - Math.floor(scale);
value = Math.pow(value, 1 / root)*Math.pow(10.0 ,scaleDiff);
scale-=scaleDiff;
normalize();
}
public void log10() {
value = Math.log10(value) * scale;
scale = 0;
if(value != DoubleOne) {
value = Math.log10(value);
}
value*= scale;
scale = DoubleZero;
normalize();
}
public void log(double base) {
value = (Math.log(value) / Math.log(base)) * (scale / Math.log10(base));
scale = 0;
if(value != DoubleOne) {
value = (Math.log(value) / Math.log(base));
}
value*= (scale / Math.log10(base));
scale = DoubleZero;
normalize();
}
public boolean isBiggerThan(Units other) {
if (scale > other.scale) {
if(isNegative() && !other.isNegative()){
return false;
}
if(!isNegative() && other.isNegative()){
return true;
}
boolean valuesAreNegative = isNegative();
if (scale > other.scale) {
return valuesAreNegative ^ true;
}
if (scale < other.scale) {
return false;
return valuesAreNegative || false;
}
return value > other.value;
}
public boolean isSmallerThan(Units other) {
if (scale < other.scale) {
if(isNegative() && !other.isNegative()){
return true;
}
if (scale > other.scale) {
if(!isNegative() && other.isNegative()){
return false;
}
boolean valuesAreNegative = isNegative();
if (scale < other.scale) {
return valuesAreNegative ^ true;
}
if (scale > other.scale) {
return valuesAreNegative || false;
}
return value < other.value;
}
@ -279,7 +306,7 @@ public final class Units extends Number implements Comparable<Units> {
@Override
public double doubleValue() {
return Math.pow(value, scale);
return value*Math.pow(10, scale);
}
@Override

303
app/src/test/java/com/futurumgame/base/UnitsTest.java
View File

@ -0,0 +1,303 @@
package com.futurumgame.base;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import com.futurumgame.base.additionalDatatypes.Units;
public class UnitsTest {
@Test
public void testAddition() {
Units simpleTestUnit = new Units(5, 0.0);
Units simpleTestUnit2 = new Units(13, 0.0);
Units simpleTestUnit3 = new Units(6, 2.0);
Units simpleTestUnit4 = new Units(-5, 0.0);
Units positiveInfiniteUnit = Units.PositiveInfinity.copy();
Units negativeInfiniteUnit = Units.NegativeInfinity.copy();
simpleTestUnit.add(simpleTestUnit2);
assertEquals(new Units(18, 0.0), simpleTestUnit);
simpleTestUnit2.add(simpleTestUnit4);
assertEquals(new Units(8, 0.0), simpleTestUnit2);
simpleTestUnit2.add(simpleTestUnit3);
assertEquals(new Units(6.08, 2.0), simpleTestUnit2);
positiveInfiniteUnit.add(simpleTestUnit);
assertEquals(Units.PositiveInfinity, positiveInfiniteUnit);
negativeInfiniteUnit.add(simpleTestUnit4);
assertEquals(Units.NegativeInfinity, negativeInfiniteUnit);
simpleTestUnit.add(Units.NaN);
assertEquals(Units.NaN, simpleTestUnit);
Units infiniteCancellationUnit = new Units(0, 0);
infiniteCancellationUnit.add(Units.PositiveInfinity);
infiniteCancellationUnit.add(Units.NegativeInfinity);
assertEquals(Units.Zero, infiniteCancellationUnit);
}
@Test
public void testSubtraction() {
Units simpleTestUnit = new Units(5, 0.0);
Units simpleTestUnit2 = new Units(13, 0.0);
Units simpleTestUnit3 = new Units(-5, 0.0);
simpleTestUnit2.subtract(simpleTestUnit);
assertEquals(new Units(8, 0.0), simpleTestUnit2);
simpleTestUnit3.subtract(simpleTestUnit3);
assertEquals(Units.Zero, simpleTestUnit3);
simpleTestUnit3.subtract(new Units(2, 1.0));
assertEquals(new Units(-2, 1.0), simpleTestUnit3);
simpleTestUnit3.subtract(Units.NaN);
assertEquals(Units.NaN, simpleTestUnit3);
simpleTestUnit.subtract(Units.Zero);
assertEquals(new Units(5, 0.0), simpleTestUnit);
simpleTestUnit.subtract(Units.NegativeInfinity);
assertEquals(Units.PositiveInfinity, simpleTestUnit);
}
@Test
public void testMultiplication() {
Units simpleTestUnit = new Units(5, 0.0);
Units simpleTestUnit2 = new Units(13, 0.0);
Units simpleTestUnit3 = new Units(-5, 0.0);
simpleTestUnit.multiply(simpleTestUnit3);
assertEquals(new Units(-25, 0.0), simpleTestUnit);
simpleTestUnit2.multiply(new Units(5, 0.0));
assertEquals(new Units(65, 0.0), simpleTestUnit2);
simpleTestUnit.multiply(Units.Zero);
assertEquals(Units.Zero, simpleTestUnit);
simpleTestUnit2.multiply(Units.NaN);
assertEquals(Units.NaN, simpleTestUnit2);
}
@Test
public void testDivision() {
Units simpleTestUnit = new Units(5, 0.0);
Units simpleTestUnit2 = new Units(20, 0.0);
Units simpleTestUnit3 = new Units(-5, 0.0);
simpleTestUnit2.divide(simpleTestUnit);
assertEquals(new Units(4, 0.0), simpleTestUnit2);
simpleTestUnit.divide(simpleTestUnit3);
assertEquals(new Units(-1, 0.0), simpleTestUnit);
simpleTestUnit.divide(Units.PositiveInfinity);
assertEquals(Units.Zero, simpleTestUnit);
}
@Test
public void testPow() {
Units simpleTestUnit = new Units(5, 0.0);
Units simpleTestUnit2 = new Units(2, 0.0);
Units simpleTestUnit3 = new Units(-5, 0.0);
simpleTestUnit.pow(2);
assertEquals(new Units(25, 0.0), simpleTestUnit);
simpleTestUnit3.pow(3);
assertEquals(new Units(-125, 0.0), simpleTestUnit3);
simpleTestUnit2.pow(Double.POSITIVE_INFINITY);
assertEquals(Units.NaN, simpleTestUnit2);
simpleTestUnit.pow(Double.NEGATIVE_INFINITY);
assertEquals(Units.Zero, simpleTestUnit);
simpleTestUnit2.pow(5);
assertEquals(Units.NaN, simpleTestUnit2);
}
@Test
public void testNthRoot() {
Units simpleTestUnit = new Units(125, 0.0);
Units simpleTestUnit2 = new Units(-125, 0.0);
Units positiveInfinityUnit = Units.PositiveInfinity.copy();
simpleTestUnit.nRoot(3.0);
assertEquals(new Units(5, 0.0), simpleTestUnit);
simpleTestUnit2.nRoot(3.0);
assertEquals(Units.NaN, simpleTestUnit2);
positiveInfinityUnit.nRoot(5.0);
assertEquals(Units.NaN, positiveInfinityUnit);
}
@Test
public void testLog10() {
Units simpleTestUnit = new Units(10, 20.0);
simpleTestUnit.log10();
assertEquals(new Units(2.1, 1.0), simpleTestUnit);
}
@Test
public void testComparisons() {
Units simpleTestUnit = new Units(15, 0.0);
Units simpleTestUnit2 = new Units(-23, 0.0);
Units simpleTestUnit3 = new Units(55, 0.0);
Units simpleTestUnit4 = new Units(10, 2.0);
Units simpleTestUnit5 = new Units(-10, 2.0);
Units simpleTestUnit6 = new Units(-25, 0.0);
Units positiveInfiniteUnit = Units.PositiveInfinity.copy();
Units negativeInfiniteUnit = Units.NegativeInfinity.copy();
Units nanUnit = Units.NaN.copy();
Units zeroUnit = Units.Zero.copy();
assertEquals(true, simpleTestUnit.isBiggerThan(simpleTestUnit2));
assertEquals(false, simpleTestUnit2.isBiggerThan(simpleTestUnit));
assertEquals(true, simpleTestUnit2.isBiggerThan(simpleTestUnit6));
assertEquals(false, simpleTestUnit.isBiggerThan(simpleTestUnit3));
assertEquals(true, simpleTestUnit3.isBiggerThan(simpleTestUnit));
assertEquals(true, simpleTestUnit4.isBiggerThan(simpleTestUnit));
assertEquals(true, simpleTestUnit6.isBiggerThan(simpleTestUnit5));
assertEquals(true, simpleTestUnit4.isBiggerThan(simpleTestUnit6));
assertEquals(false, simpleTestUnit5.isBiggerThan(simpleTestUnit));
assertEquals(true, positiveInfiniteUnit.isBiggerThan(simpleTestUnit2));
assertEquals(true, positiveInfiniteUnit.isBiggerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit4.isBiggerThan(positiveInfiniteUnit));
assertEquals(false, simpleTestUnit6.isBiggerThan(positiveInfiniteUnit));
assertEquals(false, negativeInfiniteUnit.isBiggerThan(simpleTestUnit2));
assertEquals(false, negativeInfiniteUnit.isBiggerThan(simpleTestUnit));
assertEquals(true, simpleTestUnit4.isBiggerThan(negativeInfiniteUnit));
assertEquals(true, simpleTestUnit6.isBiggerThan(negativeInfiniteUnit));
assertEquals(false, nanUnit.isBiggerThan(simpleTestUnit));
assertEquals(true, nanUnit.isBiggerThan(simpleTestUnit2));
assertEquals(true, zeroUnit.isBiggerThan(simpleTestUnit2));
assertEquals(false, zeroUnit.isBiggerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit.isSmallerThan(simpleTestUnit2));
assertEquals(true, simpleTestUnit2.isSmallerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit2.isSmallerThan(simpleTestUnit6));
assertEquals(true, simpleTestUnit.isSmallerThan(simpleTestUnit3));
assertEquals(false, simpleTestUnit3.isSmallerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit4.isSmallerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit6.isSmallerThan(simpleTestUnit5));
assertEquals(false, simpleTestUnit4.isSmallerThan(simpleTestUnit6));
assertEquals(true, simpleTestUnit5.isSmallerThan(simpleTestUnit));
assertEquals(false, positiveInfiniteUnit.isSmallerThan(simpleTestUnit2));
assertEquals(false, positiveInfiniteUnit.isSmallerThan(simpleTestUnit));
assertEquals(true, simpleTestUnit4.isSmallerThan(positiveInfiniteUnit));
assertEquals(true, simpleTestUnit6.isSmallerThan(positiveInfiniteUnit));
assertEquals(true, negativeInfiniteUnit.isSmallerThan(simpleTestUnit2));
assertEquals(true, negativeInfiniteUnit.isSmallerThan(simpleTestUnit));
assertEquals(false, simpleTestUnit4.isSmallerThan(negativeInfiniteUnit));
assertEquals(false, simpleTestUnit6.isSmallerThan(negativeInfiniteUnit));
assertEquals(false, nanUnit.isSmallerThan(simpleTestUnit));
assertEquals(false, nanUnit.isSmallerThan(simpleTestUnit2));
assertEquals(false, zeroUnit.isSmallerThan(simpleTestUnit2));
assertEquals(true, zeroUnit.isSmallerThan(simpleTestUnit));
}
@Test
public void testSpecialValues() {
Units simpleTestUnit = new Units(15, 0.0);
Units simpleTestUnit2 = new Units(-23, 0.0);
Units positiveInfiniteUnit = Units.PositiveInfinity.copy();
Units negativeInfiniteUnit = Units.NegativeInfinity.copy();
Units nanUnit = Units.NaN.copy();
Units zeroUnit = Units.Zero.copy();
assertEquals(false, simpleTestUnit.isInfinity());
assertEquals(false, simpleTestUnit.isPosInfinity());
assertEquals(false, simpleTestUnit.isNegInfinity());
assertEquals(false, simpleTestUnit2.isInfinity());
assertEquals(false, simpleTestUnit2.isPosInfinity());
assertEquals(false, simpleTestUnit2.isNegInfinity());
assertEquals(true, positiveInfiniteUnit.isInfinity());
assertEquals(true, positiveInfiniteUnit.isPosInfinity());
assertEquals(false, positiveInfiniteUnit.isNegInfinity());
assertEquals(true, negativeInfiniteUnit.isInfinity());
assertEquals(false, negativeInfiniteUnit.isPosInfinity());
assertEquals(true, negativeInfiniteUnit.isNegInfinity());
assertEquals(false, nanUnit.isInfinity());
assertEquals(false, nanUnit.isPosInfinity());
assertEquals(false, nanUnit.isNegInfinity());
assertEquals(true, nanUnit.isNaN());
assertEquals(false, zeroUnit.isInfinity());
assertEquals(false, zeroUnit.isPosInfinity());
assertEquals(false, zeroUnit.isNegInfinity());
assertEquals(true, zeroUnit.isZero());
}
@Test
public void testAbsValues() {
Units simpleTestUnit = new Units(15, 0.0);
Units simpleTestUnit2 = new Units(-23, 0.0);
Units positiveInfiniteUnit = Units.PositiveInfinity.copy();
Units negativeInfiniteUnit = Units.NegativeInfinity.copy();
assertEquals(true, simpleTestUnit.isPositive());
assertEquals(false, simpleTestUnit.isNegative());
assertEquals(false, simpleTestUnit2.isPositive());
assertEquals(true, simpleTestUnit2.isNegative());
assertEquals(true, positiveInfiniteUnit.isPositive());
assertEquals(false, positiveInfiniteUnit.isNegative());
assertEquals(false, negativeInfiniteUnit.isPositive());
assertEquals(true, negativeInfiniteUnit.isNegative());
}
@Test
public void testCopy() {
Units simpleTestUnit = new Units(15, 0.0);
Units simpleTestUnit2 = new Units(-23, 0.0);
Units positiveInfiniteUnit = Units.PositiveInfinity.copy();
Units negativeInfiniteUnit = Units.NegativeInfinity.copy();
assertEquals(new Units(15, 0.0), simpleTestUnit.copy());
assertEquals(new Units(-23, 0.0), simpleTestUnit2.copy());
assertEquals(Units.PositiveInfinity, positiveInfiniteUnit.copy());
assertEquals(Units.NegativeInfinity, negativeInfiniteUnit.copy());
}
@Test
public void testValueEvaluation() {
Units simpleTestUnit = new Units(15, 1.0);
Units simpleTestUnit2 = new Units(-23, 0.0);
assertEquals(150, simpleTestUnit.intValue());
assertEquals(-23, simpleTestUnit2.intValue());
}
}
Write Preview
Loading…
Cancel
Save