From 0c0f87da838e3406ac88394c45ced037c0180f87 Mon Sep 17 00:00:00 2001
From: iTitus <iTitus@users.noreply.github.com>
Date: Tue, 10 Nov 2020 22:16:56 +0100
Subject: [PATCH 1/3] fully switch to BigRational

---
 .../math/function/PowerSeriesCalculator.java  |   2 +-
 .../math/number/BigDecimalConstants.java      |  12 ++
 .../ititus/math/number/BigRational.java       | 162 ++++++++++++++++--
 .../ititus/math/number/BigRationalMath.java   |  19 ++
 .../ititus/si/quantity/AbstractQuantity.java  |  14 --
 .../github/ititus/si/quantity/Constants.java  |  21 +--
 .../github/ititus/si/quantity/Quantity.java   |  90 ++++++++--
 .../ititus/si/quantity/QuantityImpl.java      |  39 ++---
 .../quantity/type/ElectricPermittivity.java   |   3 +-
 .../ititus/si/quantity/type/Frequency.java    |   8 +-
 .../github/ititus/si/quantity/type/Pace.java  |   8 +-
 .../github/ititus/si/quantity/type/Speed.java |   8 +-
 .../github/ititus/si/quantity/type/Time.java  |   8 +-
 .../si/quantity/value/BigRationalValue.java   | 127 ++++++++++++++
 .../si/quantity/value/QuantityValue.java      |  70 ++++++++
 .../github/ititus/si/unit/AlternateUnit.java  |   5 +-
 .../io/github/ititus/si/unit/BaseUnit.java    |   5 +-
 .../github/ititus/si/unit/CompoundUnit.java   |   5 +-
 .../github/ititus/si/unit/ConvertedUnit.java  |   5 +-
 .../io/github/ititus/si/unit/PrefixUnit.java  |  10 +-
 .../java/io/github/ititus/si/unit/Unit.java   |  93 +++++++++-
 .../java/io/github/ititus/si/unit/Units.java  |  10 +-
 .../si/unit/converter/CompoundConverter.java  |   4 +-
 .../si/unit/converter/IdentityConverter.java  |   4 +-
 .../converter/MultiplicationConverter.java    |  22 +--
 .../si/unit/converter/UnitConverter.java      |   6 +-
 .../github/ititus/assertions/Assertions.java  |  10 --
 .../ititus/assertions/CustomAssertions.java   |  15 ++
 .../assertions/QuantityValueAssert.java       |  94 ++++++++++
 .../ititus/assertions/QuantityValues.java     |  36 ++++
 .../math/number/BigRationalExpTests.java      |   2 +-
 .../math/number/BigRationalLnTests.java       |   2 +-
 .../math/number/BigRationalSinTests.java      |   2 +-
 .../ititus/si/quantity/type/ForceTest.java    |   7 +-
 .../ititus/si/quantity/type/LengthTest.java   |  10 +-
 .../ititus/si/quantity/type/MassTest.java     |   8 +-
 36 files changed, 799 insertions(+), 147 deletions(-)
 create mode 100644 src/main/java/io/github/ititus/math/number/BigDecimalConstants.java
 delete mode 100644 src/main/java/io/github/ititus/si/quantity/AbstractQuantity.java
 create mode 100644 src/main/java/io/github/ititus/si/quantity/value/BigRationalValue.java
 create mode 100644 src/main/java/io/github/ititus/si/quantity/value/QuantityValue.java
 delete mode 100644 src/test/java/io/github/ititus/assertions/Assertions.java
 create mode 100644 src/test/java/io/github/ititus/assertions/CustomAssertions.java
 create mode 100644 src/test/java/io/github/ititus/assertions/QuantityValueAssert.java
 create mode 100644 src/test/java/io/github/ititus/assertions/QuantityValues.java

diff --git a/src/main/java/io/github/ititus/math/function/PowerSeriesCalculator.java b/src/main/java/io/github/ititus/math/function/PowerSeriesCalculator.java
index 7c16c4c..1cfb5b6 100644
--- a/src/main/java/io/github/ititus/math/function/PowerSeriesCalculator.java
+++ b/src/main/java/io/github/ititus/math/function/PowerSeriesCalculator.java
@@ -135,7 +135,7 @@ protected BigRational getCoefficient(BigInteger n) {
                 return BigRationalConstants.ZERO;
             }
 
-            return BigRational.of(BigInteger.ONE, n);
+            return BigRational.ofInv(n);
         }
     }
 
diff --git a/src/main/java/io/github/ititus/math/number/BigDecimalConstants.java b/src/main/java/io/github/ititus/math/number/BigDecimalConstants.java
new file mode 100644
index 0000000..4641504
--- /dev/null
+++ b/src/main/java/io/github/ititus/math/number/BigDecimalConstants.java
@@ -0,0 +1,12 @@
+package io.github.ititus.math.number;
+
+import java.math.BigDecimal;
+
+public final class BigDecimalConstants {
+
+    public static final BigDecimal TWO = new BigDecimal(2);
+    public static final BigDecimal ONE_OVER_TWO = new BigDecimal("0.5");
+
+    private BigDecimalConstants() {
+    }
+}
diff --git a/src/main/java/io/github/ititus/math/number/BigRational.java b/src/main/java/io/github/ititus/math/number/BigRational.java
index 5476f2a..e0fd8d7 100644
--- a/src/main/java/io/github/ititus/math/number/BigRational.java
+++ b/src/main/java/io/github/ititus/math/number/BigRational.java
@@ -86,12 +86,140 @@ public static BigRational of(BigDecimal d) {
         int scale = d.scale();
         BigInteger scalar = BigInteger.TEN.pow(Math.abs(scale));
 
-        if (scale <= 0) {
-            of(unscaled.multiply(scalar));
+        if (scale < 0) {
+            return of(unscaled.multiply(scalar));
         }
         return of(unscaled, scalar);
     }
 
+    public static BigRational ofInv(int n) {
+        return of(n).inverse();
+    }
+
+    public static BigRational ofInv(long n) {
+        return of(n).inverse();
+    }
+
+    public static BigRational ofInv(BigInteger n) {
+        return of(n).inverse();
+    }
+
+    public static BigRational ofInv(float f) {
+        return of(f).inverse();
+    }
+
+    public static BigRational ofInv(double d) {
+        return of(d).inverse();
+    }
+
+    public static BigRational ofInv(BigDecimal d) {
+        return of(d).inverse();
+    }
+
+    public static BigRational ofExp(int scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(int scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(int scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(long scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(long scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(long scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigInteger scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigInteger scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigInteger scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(float scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(float scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(float scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(double scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(double scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(double scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigDecimal scale, int exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigDecimal scale, long exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational ofExp(BigDecimal scale, BigInteger exponent) {
+        return of(scale).multiply(BigRationalConstants.TEN.pow(exponent));
+    }
+
+    public static BigRational of(int numerator, int denominator) {
+        return of(BigIntegerMath.of(numerator), BigIntegerMath.of(denominator));
+    }
+
+    public static BigRational of(int numerator, long denominator) {
+        return of(BigIntegerMath.of(numerator), BigIntegerMath.of(denominator));
+    }
+
+    public static BigRational of(int numerator, BigInteger denominator) {
+        return of(BigIntegerMath.of(numerator), denominator);
+    }
+
+    public static BigRational of(long numerator, int denominator) {
+        return of(BigIntegerMath.of(numerator), BigIntegerMath.of(denominator));
+    }
+
+    public static BigRational of(long numerator, long denominator) {
+        return of(BigIntegerMath.of(numerator), BigIntegerMath.of(denominator));
+    }
+
+    public static BigRational of(long numerator, BigInteger denominator) {
+        return of(BigIntegerMath.of(numerator), denominator);
+    }
+
+    public static BigRational of(BigInteger numerator, int denominator) {
+        return of(numerator, BigIntegerMath.of(denominator));
+    }
+
+    public static BigRational of(BigInteger numerator, long denominator) {
+        return of(numerator, BigIntegerMath.of(denominator));
+    }
+
     @SuppressWarnings("Duplicates")
     public static BigRational of(BigInteger numerator, BigInteger denominator) {
         if (denominator.equals(BigInteger.ZERO)) {
@@ -117,22 +245,6 @@ public static BigRational of(BigInteger numerator, BigInteger denominator) {
 
         if (r.equals(MINUS_ONE)) {
             return MINUS_ONE;
-        } else if (r.equals(TWO)) {
-            return TWO;
-        } else if (r.equals(THREE)) {
-            return THREE;
-        } else if (r.equals(FOUR)) {
-            return FOUR;
-        } else if (r.equals(TEN)) {
-            return TEN;
-        } else if (r.equals(ONE_OVER_TWO)) {
-            return ONE_OVER_TWO;
-        } else if (r.equals(ONE_OVER_THREE)) {
-            return ONE_OVER_THREE;
-        } else if (r.equals(THREE_OVER_FOUR)) {
-            return THREE_OVER_FOUR;
-        } else if (r.equals(FIVE_OVER_FOUR)) {
-            return FIVE_OVER_FOUR;
         }
 
         return r;
@@ -295,6 +407,20 @@ public BigRational pow(BigInteger exponent) {
         return BigRationalMath.pow(this, exponent);
     }
 
+    public BigRational pow(BigDecimal exponent) {
+        if (exponent.signum() == 0) {
+            return ONE;
+        } else if (isZero()) {
+            return ZERO;
+        } else if (exponent.equals(BigDecimal.ONE)) {
+            return this;
+        } else if (exponent.equals(BigDecimalConstants.TWO)) {
+            return squared();
+        }
+
+        return BigRationalMath.pow(this, exponent);
+    }
+
     public BigRational pow(BigRational exponent) {
         if (exponent.isZero()) {
             return ONE;
diff --git a/src/main/java/io/github/ititus/math/number/BigRationalMath.java b/src/main/java/io/github/ititus/math/number/BigRationalMath.java
index 448c954..31f9d6f 100644
--- a/src/main/java/io/github/ititus/math/number/BigRationalMath.java
+++ b/src/main/java/io/github/ititus/math/number/BigRationalMath.java
@@ -4,6 +4,7 @@
 import io.github.ititus.math.time.DurationFormatter;
 import io.github.ititus.math.time.StopWatch;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.time.Duration;
 
@@ -40,6 +41,24 @@ public static BigRational pow(BigRational base, BigInteger exponent) {
         return r;
     }
 
+    public static BigRational pow(BigRational base, BigDecimal exponent) {
+        if (base.isOne() || exponent.signum() == 0) {
+            return ONE;
+        } else if (base.isZero()) {
+            return ZERO;
+        } else if (exponent.equals(BigDecimal.ONE)) {
+            return base;
+        } else if (exponent.signum() < 0) {
+            return pow(base, exponent.negate()).inverse();
+        }
+
+        if (exponent.equals(BigDecimalConstants.ONE_OVER_TWO)) {
+            return base.sqrt();
+        }
+
+        return exp(BigRational.of(exponent).multiply(ln(base)));
+    }
+
     public static BigRational pow(BigRational base, BigRational exponent) {
         if (base.isOne() || exponent.isZero()) {
             return ONE;
diff --git a/src/main/java/io/github/ititus/si/quantity/AbstractQuantity.java b/src/main/java/io/github/ititus/si/quantity/AbstractQuantity.java
deleted file mode 100644
index 4a54213..0000000
--- a/src/main/java/io/github/ititus/si/quantity/AbstractQuantity.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package io.github.ititus.si.quantity;
-
-import io.github.ititus.si.quantity.type.QuantityType;
-
-public abstract class AbstractQuantity<Q extends QuantityType<Q>> implements Quantity<Q> {
-
-    @Override
-    public String toString() {
-        return "Quantity{" +
-                "value=" + getValue() +
-                ", unit=" + getUnit() +
-                '}';
-    }
-}
diff --git a/src/main/java/io/github/ititus/si/quantity/Constants.java b/src/main/java/io/github/ititus/si/quantity/Constants.java
index ae06de9..c137251 100644
--- a/src/main/java/io/github/ititus/si/quantity/Constants.java
+++ b/src/main/java/io/github/ititus/si/quantity/Constants.java
@@ -2,6 +2,7 @@
 
 import io.github.ititus.si.quantity.type.*;
 
+import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.unit.Units.*;
 
 public final class Constants {
@@ -9,22 +10,22 @@ public final class Constants {
     /* Defined (exact) constants */
 
     // Length
-    public static final Quantity<Speed> SPEED_OF_LIGHT = METRES_PER_SECOND.get(299_792_458.0);
+    public static final Quantity<Speed> SPEED_OF_LIGHT = METRES_PER_SECOND.get(299_792_458);
 
     // Mass
-    public static final Quantity<?> PLANCK_CONSTANT = JOULE.multiply(SECOND).get(6.626_070_15e-34);
+    public static final Quantity<?> PLANCK_CONSTANT = JOULE.multiply(SECOND).get(ofExp(662_607_015, -42));
 
     // Time
-    public static final Quantity<Frequency> HYPERFINE_TRANSITION_FREQUENCY_OF_CAESIUM = HERTZ.get(9_192_631_770.0);
+    public static final Quantity<Frequency> HYPERFINE_TRANSITION_FREQUENCY_OF_CAESIUM = HERTZ.get(9_192_631_770L);
 
     // Electric Current
-    public static final Quantity<ElectricCharge> ELEMENTARY_CHARGE = COULOMB.get(1.602_176_634e-19);
+    public static final Quantity<ElectricCharge> ELEMENTARY_CHARGE = COULOMB.get(ofExp(1_602_176_634, -28));
 
     // Thermodynamic Temperature
-    public static final Quantity<?> BOLTZMANN_CONSTANT = JOULE.divide(KELVIN).get(1.380_649_76e-23);
+    public static final Quantity<?> BOLTZMANN_CONSTANT = JOULE.divide(KELVIN).get(ofExp(1_380_649_76, -31));
 
     // Amount of Substance
-    public static final Quantity<?> AVOGADRO_CONSTANT = MOLE.inverse().get(6.022_140_76e23);
+    public static final Quantity<?> AVOGADRO_CONSTANT = MOLE.inverse().get(ofExp(6_022_140_76, 15));
 
     // Luminous Intensity
     public static final Quantity<LuminousEfficacy> LUMINOUS_EFFICACY_OF_540_THZ_RADIATION = LUMEN_PER_WATT.get(683);
@@ -33,15 +34,15 @@ public final class Constants {
     /* Measured constants */
 
     public static final Quantity<?> GRAVITATIONAL_CONSTANT =
-            METRE.pow(3).divide(KILOGRAM.multiply(SECOND.pow(2))).get(6.674_30e-11);
+            METRE.pow(3).divide(KILOGRAM.multiply(SECOND.pow(2))).get(ofExp(667_430, -16));
 
     public static final Quantity<ElectricPermittivity> VACUUM_ELECTRIC_PERMITTIVITY =
-            FARAD_PER_METRE.get(8.854_187_812_8e-12);
+            FARAD_PER_METRE.get(ofExp(88_541_878_128L, -22));
 
     public static final Quantity<MagneticPermeability> VACUUM_MAGNETIC_PERMEABILITY =
-            HENRY_PER_METRE.get(1.256_637_062_12e-6);
+            HENRY_PER_METRE.get(ofExp(125_663_706_212L, -17));
 
-    public static final Quantity<Mass> ELECTRON_MASS = KILOGRAM.get(9.109_383_701_5e-31);
+    public static final Quantity<Mass> ELECTRON_MASS = KILOGRAM.get(ofExp(91_093_837_015L, -41));
 
     private Constants() {
     }
diff --git a/src/main/java/io/github/ititus/si/quantity/Quantity.java b/src/main/java/io/github/ititus/si/quantity/Quantity.java
index 34fc951..6f5afd4 100644
--- a/src/main/java/io/github/ititus/si/quantity/Quantity.java
+++ b/src/main/java/io/github/ititus/si/quantity/Quantity.java
@@ -1,15 +1,20 @@
 package io.github.ititus.si.quantity;
 
+import io.github.ititus.math.number.BigRational;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.Unit;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
 public interface Quantity<Q extends QuantityType<Q>> {
 
-    static <T extends QuantityType<T>> Quantity<T> of(double value, Unit<T> unit) {
+    static <T extends QuantityType<T>> Quantity<T> of(QuantityValue value, Unit<T> unit) {
         return new QuantityImpl<>(value, unit);
     }
 
-    double getValue();
+    QuantityValue getValue();
 
     Unit<Q> getUnit();
 
@@ -30,35 +35,98 @@ default <T extends QuantityType<T>> Quantity<T> as(Unit<T> unit) {
     }
 
     default Quantity<Q> add(Quantity<Q> qty) {
-        return getUnit().get(getValue() + qty.convertTo(getUnit()).getValue());
+        return getUnit().get(getValue().add(qty.convertTo(getUnit()).getValue()));
     }
 
     default Quantity<Q> negate() {
-        return getUnit().get(-getValue());
+        return getUnit().get(getValue().negate());
     }
 
     default Quantity<Q> subtract(Quantity<Q> qty) {
         return add(qty.negate());
     }
 
+    default Quantity<Q> multiply(int n) {
+        return multiply(QuantityValue.of(n));
+    }
+
+    default Quantity<Q> multiply(long n) {
+        return multiply(QuantityValue.of(n));
+    }
+
+    default Quantity<Q> multiply(BigInteger n) {
+        return multiply(QuantityValue.of(n));
+    }
+
+    default Quantity<Q> multiply(float f) {
+        return multiply(QuantityValue.of(f));
+    }
+
     default Quantity<Q> multiply(double d) {
-        return getUnit().get(getValue() * d);
+        return multiply(QuantityValue.of(d));
+    }
+
+    default Quantity<Q> multiply(BigDecimal d) {
+        return multiply(QuantityValue.of(d));
+    }
+
+    default Quantity<Q> multiply(BigRational r) {
+        return multiply(QuantityValue.of(r));
+    }
+
+    default Quantity<Q> multiply(QuantityValue value) {
+        return getUnit().get(getValue().multiply(value));
+    }
+
+    default Quantity<?> multiply(Quantity<?> qty) {
+        return getUnit().multiply(qty.getUnit()).get(getValue().multiply(qty.getValue()));
     }
 
-    Quantity<?> multiply(Quantity<?> qty);
+    default Quantity<?> inverse() {
+        return getUnit().inverse().get(getValue().inverse());
+    }
 
-    Quantity<?> inverse();
+    default Quantity<Q> divide(int n) {
+        return divide(BigRational.of(n));
+    }
+
+    default Quantity<Q> divide(long n) {
+        return divide(BigRational.of(n));
+    }
+
+    default Quantity<Q> divide(BigInteger n) {
+        return divide(QuantityValue.of(n));
+    }
+
+    default Quantity<Q> divide(float f) {
+        return divide(QuantityValue.of(f));
+    }
 
     default Quantity<Q> divide(double d) {
-        return getUnit().get(getValue() / d);
+        return divide(QuantityValue.of(d));
+    }
+
+    default Quantity<Q> divide(BigDecimal d) {
+        return divide(QuantityValue.of(d));
+    }
+
+    default Quantity<Q> divide(BigRational r) {
+        return divide(QuantityValue.of(r));
+    }
+
+    default Quantity<Q> divide(QuantityValue value) {
+        return getUnit().get(getValue().divide(value));
     }
 
     default Quantity<?> divide(Quantity<?> qty) {
         return multiply(qty.inverse());
     }
 
-    Quantity<?> pow(int n);
-
-    Quantity<?> root(int n);
+    default Quantity<?> pow(int n) {
+        return getUnit().pow(n).get(getValue().pow(n));
+    }
 
+    default Quantity<?> root(int n) {
+        return getUnit().root(n).get(getValue().root(n));
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/QuantityImpl.java b/src/main/java/io/github/ititus/si/quantity/QuantityImpl.java
index 5dfc32b..ab85122 100644
--- a/src/main/java/io/github/ititus/si/quantity/QuantityImpl.java
+++ b/src/main/java/io/github/ititus/si/quantity/QuantityImpl.java
@@ -1,22 +1,23 @@
 package io.github.ititus.si.quantity;
 
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.Unit;
 
 import java.util.Objects;
 
-final class QuantityImpl<Q extends QuantityType<Q>> extends AbstractQuantity<Q> {
+final class QuantityImpl<Q extends QuantityType<Q>> implements Quantity<Q> {
 
-    private final double value;
+    private final QuantityValue value;
     private final Unit<Q> unit;
 
-    QuantityImpl(double value, Unit<Q> unit) {
+    QuantityImpl(QuantityValue value, Unit<Q> unit) {
         this.value = value;
         this.unit = unit;
     }
 
     @Override
-    public double getValue() {
+    public QuantityValue getValue() {
         return value;
     }
 
@@ -39,26 +40,6 @@ public <T extends QuantityType<T>> Quantity<T> as(T type) {
         return new QuantityImpl<>(value, unit.as(type));
     }
 
-    @Override
-    public Quantity<?> multiply(Quantity<?> qty) {
-        return new QuantityImpl<>(value * qty.getValue(), unit.multiply(qty.getUnit()));
-    }
-
-    @Override
-    public Quantity<?> inverse() {
-        return new QuantityImpl<>(1 / value, unit.inverse());
-    }
-
-    @Override
-    public Quantity<?> pow(int n) {
-        return new QuantityImpl<>(Math.pow(value, n), unit.pow(n));
-    }
-
-    @Override
-    public Quantity<?> root(int n) {
-        return new QuantityImpl<>(Math.pow(value, 1.0 / n), unit.root(n));
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) {
@@ -68,11 +49,19 @@ public boolean equals(Object o) {
             return false;
         }
         QuantityImpl<?> quantity = (QuantityImpl<?>) o;
-        return Double.compare(quantity.value, value) == 0 && unit.equals(quantity.unit);
+        return value.equals(quantity.value) && unit.equals(quantity.unit);
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(value, unit);
     }
+
+    @Override
+    public String toString() {
+        return "Quantity{" +
+                "value=" + value +
+                ", unit=" + unit +
+                '}';
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/type/ElectricPermittivity.java b/src/main/java/io/github/ititus/si/quantity/type/ElectricPermittivity.java
index 1ebf490..6771fa0 100644
--- a/src/main/java/io/github/ititus/si/quantity/type/ElectricPermittivity.java
+++ b/src/main/java/io/github/ititus/si/quantity/type/ElectricPermittivity.java
@@ -8,6 +8,7 @@ public final class ElectricPermittivity extends AbstractQuantityType<ElectricPer
     public static final ElectricPermittivity ELECTRIC_PERMITTIVITY = new ElectricPermittivity();
 
     private ElectricPermittivity() {
-        super(TIME.pow(4).multiply(ELECTRIC_CURRENT.pow(2)).divide(LENGTH.pow(3).multiply(MASS)), () -> FARAD_PER_METRE);
+        super(TIME.pow(4).multiply(ELECTRIC_CURRENT.pow(2)).divide(LENGTH.pow(3).multiply(MASS)),
+                () -> FARAD_PER_METRE);
     }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/type/Frequency.java b/src/main/java/io/github/ititus/si/quantity/type/Frequency.java
index 0dce0d4..7c7cfe0 100644
--- a/src/main/java/io/github/ititus/si/quantity/type/Frequency.java
+++ b/src/main/java/io/github/ititus/si/quantity/type/Frequency.java
@@ -9,11 +9,11 @@ public final class Frequency extends AbstractQuantityType<Frequency> {
 
     public static final Frequency FREQUENCY = new Frequency();
 
-    public static Quantity<Frequency> asFrequency(Quantity<Time> qty) {
-        return qty.inverse().as(FREQUENCY);
-    }
-
     private Frequency() {
         super(TIME.inverse(), () -> HERTZ);
     }
+
+    public static Quantity<Frequency> asFrequency(Quantity<Time> qty) {
+        return qty.inverse().as(FREQUENCY);
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/type/Pace.java b/src/main/java/io/github/ititus/si/quantity/type/Pace.java
index a636421..525b264 100644
--- a/src/main/java/io/github/ititus/si/quantity/type/Pace.java
+++ b/src/main/java/io/github/ititus/si/quantity/type/Pace.java
@@ -10,11 +10,11 @@ public final class Pace extends AbstractQuantityType<Pace> {
 
     public static final Pace PACE = new Pace();
 
-    public static Quantity<Pace> asPace(Quantity<Speed> qty) {
-        return qty.inverse().as(PACE);
-    }
-
     private Pace() {
         super(TIME.divide(LENGTH), () -> SECONDS_PER_METRE);
     }
+
+    public static Quantity<Pace> asPace(Quantity<Speed> qty) {
+        return qty.inverse().as(PACE);
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/type/Speed.java b/src/main/java/io/github/ititus/si/quantity/type/Speed.java
index c9a368a..d66673a 100644
--- a/src/main/java/io/github/ititus/si/quantity/type/Speed.java
+++ b/src/main/java/io/github/ititus/si/quantity/type/Speed.java
@@ -10,11 +10,11 @@ public final class Speed extends AbstractQuantityType<Speed> {
 
     public static final Speed SPEED = new Speed();
 
-    public static Quantity<Speed> asSpeed(Quantity<Pace> qty) {
-        return qty.inverse().as(SPEED);
-    }
-
     private Speed() {
         super(LENGTH.divide(TIME), () -> METRES_PER_SECOND);
     }
+
+    public static Quantity<Speed> asSpeed(Quantity<Pace> qty) {
+        return qty.inverse().as(SPEED);
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/type/Time.java b/src/main/java/io/github/ititus/si/quantity/type/Time.java
index 40d8744..c0cd343 100644
--- a/src/main/java/io/github/ititus/si/quantity/type/Time.java
+++ b/src/main/java/io/github/ititus/si/quantity/type/Time.java
@@ -9,11 +9,11 @@ public final class Time extends AbstractQuantityType<Time> {
 
     public static final Time TIME = new Time();
 
-    public static Quantity<Time> asFrequency(Quantity<Frequency> qty) {
-        return qty.inverse().as(TIME);
-    }
-
     private Time() {
         super(BaseDimension.TIME, () -> SECOND);
     }
+
+    public static Quantity<Time> asFrequency(Quantity<Frequency> qty) {
+        return qty.inverse().as(TIME);
+    }
 }
diff --git a/src/main/java/io/github/ititus/si/quantity/value/BigRationalValue.java b/src/main/java/io/github/ititus/si/quantity/value/BigRationalValue.java
new file mode 100644
index 0000000..1b073b0
--- /dev/null
+++ b/src/main/java/io/github/ititus/si/quantity/value/BigRationalValue.java
@@ -0,0 +1,127 @@
+package io.github.ititus.si.quantity.value;
+
+import io.github.ititus.math.number.BigRational;
+import io.github.ititus.math.number.BigRationalConstants;
+
+import java.util.Objects;
+
+final class BigRationalValue extends QuantityValue {
+
+    static final BigRationalValue ZERO = new BigRationalValue(BigRationalConstants.ZERO);
+    static final BigRationalValue ONE = new BigRationalValue(BigRationalConstants.ONE);
+
+    private final BigRational value;
+
+    private BigRationalValue(BigRational value) {
+        this.value = value;
+    }
+
+    static QuantityValue ofBigRational(BigRational value) {
+        if (value.isZero()) {
+            return ZERO;
+        } else if (value.isOne()) {
+            return ONE;
+        }
+
+        return new BigRationalValue(value);
+    }
+
+    @Override
+    public BigRational bigRationalValue() {
+        return value;
+    }
+
+    @Override
+    public boolean isZero() {
+        return value.isZero();
+    }
+
+    @Override
+    public boolean isOne() {
+        return value.isOne();
+    }
+
+    @Override
+    public QuantityValue abs() {
+        return ofBigRational(value.abs());
+    }
+
+    @Override
+    public QuantityValue add(QuantityValue value) {
+        return ofBigRational(this.value.add(value.bigRationalValue()));
+    }
+
+    @Override
+    public QuantityValue negate() {
+        return ofBigRational(value.negate());
+    }
+
+    @Override
+    public QuantityValue multiply(QuantityValue value) {
+        return ofBigRational(this.value.multiply(value.bigRationalValue()));
+    }
+
+    @Override
+    public QuantityValue inverse() {
+        return ofBigRational(value.inverse());
+    }
+
+    @Override
+    public QuantityValue pow(int n) {
+        return ofBigRational(value.pow(n));
+    }
+
+    @Override
+    public QuantityValue root(int n) {
+        return ofBigRational(value.pow(BigRational.ofInv(n)));
+    }
+
+    @Override
+    public int compareTo(QuantityValue value) {
+        return this.value.compareTo(value.bigRationalValue());
+    }
+
+    @Override
+    public int intValue() {
+        return value.intValue();
+    }
+
+    @Override
+    public long longValue() {
+        return value.longValue();
+    }
+
+    @Override
+    public float floatValue() {
+        return value.floatValue();
+    }
+
+    @Override
+    public double doubleValue() {
+        return value.doubleValue();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BigRationalValue)) {
+            return false;
+        }
+        BigRationalValue that = (BigRationalValue) o;
+        return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+
+    @Override
+    public String toString() {
+        return "BigRationalValue{" +
+                "value=" + value +
+                '}';
+    }
+}
diff --git a/src/main/java/io/github/ititus/si/quantity/value/QuantityValue.java b/src/main/java/io/github/ititus/si/quantity/value/QuantityValue.java
new file mode 100644
index 0000000..db12f5b
--- /dev/null
+++ b/src/main/java/io/github/ititus/si/quantity/value/QuantityValue.java
@@ -0,0 +1,70 @@
+package io.github.ititus.si.quantity.value;
+
+import io.github.ititus.math.number.BigRational;
+import io.github.ititus.math.number.BigRationalConstants;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+public abstract class QuantityValue extends Number implements Comparable<QuantityValue> {
+
+    public static final QuantityValue ZERO = of(BigRationalConstants.ZERO);
+    public static final QuantityValue ONE = of(BigRationalConstants.ONE);
+
+    public static QuantityValue of(int value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(long value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(BigInteger value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(float value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(double value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(BigDecimal value) {
+        return of(BigRational.of(value));
+    }
+
+    public static QuantityValue of(BigRational value) {
+        return BigRationalValue.ofBigRational(value);
+    }
+
+    public abstract BigRational bigRationalValue();
+
+    public abstract boolean isZero();
+
+    public abstract boolean isOne();
+
+    public abstract QuantityValue abs();
+
+    public abstract QuantityValue add(QuantityValue value);
+
+    public abstract QuantityValue negate();
+
+    public QuantityValue subtract(QuantityValue value) {
+        return add(value.negate());
+    }
+
+    public abstract QuantityValue multiply(QuantityValue value);
+
+    public abstract QuantityValue inverse();
+
+    public QuantityValue divide(QuantityValue value) {
+        return multiply(value.inverse());
+    }
+
+    public abstract QuantityValue pow(int n);
+
+    public abstract QuantityValue root(int n);
+
+}
diff --git a/src/main/java/io/github/ititus/si/unit/AlternateUnit.java b/src/main/java/io/github/ititus/si/unit/AlternateUnit.java
index 7277678..86277d2 100644
--- a/src/main/java/io/github/ititus/si/unit/AlternateUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/AlternateUnit.java
@@ -2,6 +2,7 @@
 
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
 import java.util.Objects;
@@ -44,8 +45,8 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
     }
 
     @Override
-    public Unit<Q> multiply(double d) {
-        return baseUnit.multiply(d);
+    public Unit<Q> multiply(QuantityValue v) {
+        return baseUnit.multiply(v);
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/BaseUnit.java b/src/main/java/io/github/ititus/si/unit/BaseUnit.java
index 557c240..68ddd37 100644
--- a/src/main/java/io/github/ititus/si/unit/BaseUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/BaseUnit.java
@@ -2,6 +2,7 @@
 
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
 import java.util.Objects;
@@ -44,8 +45,8 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
     }
 
     @Override
-    public Unit<Q> multiply(double d) {
-        return ConvertedUnit.of(this, UnitConverter.factor(d));
+    public Unit<Q> multiply(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.factor(v));
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/CompoundUnit.java b/src/main/java/io/github/ititus/si/unit/CompoundUnit.java
index fbdc15b..537bd49 100644
--- a/src/main/java/io/github/ititus/si/unit/CompoundUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/CompoundUnit.java
@@ -3,6 +3,7 @@
 import io.github.ititus.si.dimension.Dimension;
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
 import java.util.Collections;
@@ -162,8 +163,8 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
     }
 
     @Override
-    public Unit<Q> multiply(double d) {
-        return ConvertedUnit.of(this, UnitConverter.factor(d));
+    public Unit<Q> multiply(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.factor(v));
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java b/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java
index d2cb297..ad0d282 100644
--- a/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java
@@ -2,6 +2,7 @@
 
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
 import java.util.Objects;
@@ -56,8 +57,8 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
     }
 
     @Override
-    public Unit<Q> multiply(double d) {
-        return of(baseUnit, converter.concat(UnitConverter.factor(d)));
+    public Unit<Q> multiply(QuantityValue v) {
+        return of(baseUnit, converter.concat(UnitConverter.factor(v)));
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/PrefixUnit.java b/src/main/java/io/github/ititus/si/unit/PrefixUnit.java
index a888000..0971b2b 100644
--- a/src/main/java/io/github/ititus/si/unit/PrefixUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/PrefixUnit.java
@@ -1,7 +1,9 @@
 package io.github.ititus.si.unit;
 
+import io.github.ititus.math.number.BigRational;
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
 import java.util.Objects;
@@ -30,7 +32,9 @@ public <T extends QuantityType<T>> UnitConverter getConverterTo(Unit<T> unit) {
             return UnitConverter.IDENTITY;
         }
 
-        UnitConverter c = UnitConverter.factor(Math.pow(prefix.getBase(), prefix.getExponent()));
+        UnitConverter c = UnitConverter.factor(QuantityValue.of(
+                BigRational.of(prefix.getBase()).pow(prefix.getExponent())
+        ));
 
         if (baseUnit.equals(unit)) {
             return c;
@@ -55,8 +59,8 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
     }
 
     @Override
-    public Unit<Q> multiply(double d) {
-        return ConvertedUnit.of(this, UnitConverter.factor(d));
+    public Unit<Q> multiply(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.factor(v));
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/Unit.java b/src/main/java/io/github/ititus/si/unit/Unit.java
index 96c6f16..84c3866 100644
--- a/src/main/java/io/github/ititus/si/unit/Unit.java
+++ b/src/main/java/io/github/ititus/si/unit/Unit.java
@@ -1,11 +1,16 @@
 package io.github.ititus.si.unit;
 
+import io.github.ititus.math.number.BigRational;
 import io.github.ititus.si.dimension.Dimension;
 import io.github.ititus.si.prefix.Prefix;
 import io.github.ititus.si.quantity.Quantity;
 import io.github.ititus.si.quantity.type.QuantityType;
+import io.github.ititus.si.quantity.value.QuantityValue;
 import io.github.ititus.si.unit.converter.UnitConverter;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
 public interface Unit<Q extends QuantityType<Q>> {
 
     String getSymbol();
@@ -16,7 +21,35 @@ public interface Unit<Q extends QuantityType<Q>> {
 
     <T extends QuantityType<T>> UnitConverter getConverterTo(Unit<T> unit);
 
+    default Quantity<Q> get(int value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(long value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(BigInteger value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(float value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
     default Quantity<Q> get(double value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(BigDecimal value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(BigRational value) {
+        return Quantity.of(QuantityValue.of(value), this);
+    }
+
+    default Quantity<Q> get(QuantityValue value) {
         return Quantity.of(value, this);
     }
 
@@ -26,14 +59,70 @@ default <T extends QuantityType<T>> boolean isCommensurableWith(T type) {
 
     <T extends QuantityType<T>> Unit<T> as(T type);
 
-    Unit<Q> multiply(double d);
+    default Unit<Q> multiply(int n) {
+        return multiply(BigRational.of(n));
+    }
+
+    default Unit<Q> multiply(long n) {
+        return multiply(QuantityValue.of(n));
+    }
+
+    default Unit<Q> multiply(BigInteger n) {
+        return multiply(QuantityValue.of(n));
+    }
+
+    default Unit<Q> multiply(float f) {
+        return multiply(QuantityValue.of(f));
+    }
+
+    default Unit<Q> multiply(double d) {
+        return multiply(QuantityValue.of(d));
+    }
+
+    default Unit<Q> multiply(BigDecimal d) {
+        return multiply(QuantityValue.of(d));
+    }
+
+    default Unit<Q> multiply(BigRational r) {
+        return multiply(QuantityValue.of(r));
+    }
+
+    Unit<Q> multiply(QuantityValue v);
 
     Unit<?> multiply(Unit<?> unit);
 
     Unit<?> inverse();
 
+    default Unit<Q> divide(int n) {
+        return divide(QuantityValue.of(n));
+    }
+
+    default Unit<Q> divide(long n) {
+        return divide(QuantityValue.of(n));
+    }
+
+    default Unit<Q> divide(BigInteger n) {
+        return divide(QuantityValue.of(n));
+    }
+
+    default Unit<Q> divide(float f) {
+        return divide(QuantityValue.of(f));
+    }
+
     default Unit<Q> divide(double d) {
-        return multiply(1 / d);
+        return divide(QuantityValue.of(d));
+    }
+
+    default Unit<Q> divide(BigDecimal d) {
+        return divide(QuantityValue.of(d));
+    }
+
+    default Unit<Q> divide(BigRational r) {
+        return divide(QuantityValue.of(r));
+    }
+
+    default Unit<Q> divide(QuantityValue r) {
+        return multiply(r.inverse());
     }
 
     default Unit<?> divide(Unit<?> unit) {
diff --git a/src/main/java/io/github/ititus/si/unit/Units.java b/src/main/java/io/github/ititus/si/unit/Units.java
index 48a160c..34ba10f 100644
--- a/src/main/java/io/github/ititus/si/unit/Units.java
+++ b/src/main/java/io/github/ititus/si/unit/Units.java
@@ -2,6 +2,8 @@
 
 import io.github.ititus.si.quantity.type.*;
 
+import static io.github.ititus.math.number.BigRational.ofExp;
+import static io.github.ititus.si.prefix.MetricPrefix.DECI;
 import static io.github.ititus.si.prefix.MetricPrefix.KILO;
 import static io.github.ititus.si.quantity.type.Acceleration.ACCELERATION;
 import static io.github.ititus.si.quantity.type.Angle.ANGLE;
@@ -66,7 +68,8 @@ public final class Units {
 
     // Length
     public static final Unit<Length> KILOMETRE = METRE.prefix(KILO);
-    public static final Unit<Length> MILE = METRE.multiply(1_609.344).alternate("mi");
+    public static final Unit<Length> DECIMETRE = METRE.prefix(DECI);
+    public static final Unit<Length> MILE = METRE.multiply(ofExp(1_609_344, -3)).alternate("mi");
     public static final Unit<Length> NAUTICAL_MILE = METRE.multiply(1_852).alternate("nmi");
 
     // Mass
@@ -117,7 +120,7 @@ public final class Units {
 
     // Energy & Power
     public static final Unit<Energy> JOULE = NEWTON.multiply(METRE).alternate("J").as(ENERGY);
-    public static final Unit<Energy> ELECTRON_VOLT = JOULE.multiply(1.602_176_634e-19);
+    public static final Unit<Energy> ELECTRON_VOLT = JOULE.multiply(ofExp(1.602_176_634, -19));
     public static final Unit<Power> WATT = JOULE.divide(SECOND).alternate("W").as(POWER);
     public static final Unit<Power> KILOWATT = WATT.prefix(KILO);
     public static final Unit<Energy> KILOWATT_HOUR = KILOWATT.multiply(HOUR).as(ENERGY);
@@ -127,7 +130,8 @@ public final class Units {
 
     // Volume
     public static final Unit<Volume> CUBIC_METRE = METRE.pow(3).as(VOLUME);
-    public static final Unit<Volume> LITRE = CUBIC_METRE.multiply(0.001).alternate("l");
+    public static final Unit<Volume> CUBIC_DECIMETRE = DECIMETRE.pow(3).as(VOLUME);
+    public static final Unit<Volume> LITRE = CUBIC_DECIMETRE.alternate("l");
 
     // Density
     public static final Unit<Density> KILOGRAM_PER_CUBIC_METRE = KILOGRAM.divide(CUBIC_METRE).as(DENSITY);
diff --git a/src/main/java/io/github/ititus/si/unit/converter/CompoundConverter.java b/src/main/java/io/github/ititus/si/unit/converter/CompoundConverter.java
index fddf3a7..2323874 100644
--- a/src/main/java/io/github/ititus/si/unit/converter/CompoundConverter.java
+++ b/src/main/java/io/github/ititus/si/unit/converter/CompoundConverter.java
@@ -1,5 +1,7 @@
 package io.github.ititus.si.unit.converter;
 
+import io.github.ititus.si.quantity.value.QuantityValue;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -67,7 +69,7 @@ private static List<UnitConverter> simplify(List<UnitConverter> converters) {
     }
 
     @Override
-    public double convert(double value) {
+    public QuantityValue convert(QuantityValue value) {
         for (UnitConverter converter : converters) {
             value = converter.convert(value);
         }
diff --git a/src/main/java/io/github/ititus/si/unit/converter/IdentityConverter.java b/src/main/java/io/github/ititus/si/unit/converter/IdentityConverter.java
index 834633d..db9f1b9 100644
--- a/src/main/java/io/github/ititus/si/unit/converter/IdentityConverter.java
+++ b/src/main/java/io/github/ititus/si/unit/converter/IdentityConverter.java
@@ -1,5 +1,7 @@
 package io.github.ititus.si.unit.converter;
 
+import io.github.ititus.si.quantity.value.QuantityValue;
+
 final class IdentityConverter implements UnitConverter {
 
     static final IdentityConverter IDENTITY = new IdentityConverter();
@@ -8,7 +10,7 @@ private IdentityConverter() {
     }
 
     @Override
-    public double convert(double value) {
+    public QuantityValue convert(QuantityValue value) {
         return value;
     }
 
diff --git a/src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java b/src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java
index 8308acf..bb0f6ef 100644
--- a/src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java
+++ b/src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java
@@ -1,20 +1,22 @@
 package io.github.ititus.si.unit.converter;
 
+import io.github.ititus.si.quantity.value.QuantityValue;
+
 import java.util.List;
 import java.util.Objects;
 
 final class MultiplicationConverter implements UnitConverter {
 
-    private final double factor;
+    private final QuantityValue factor;
 
-    private MultiplicationConverter(double factor) {
+    private MultiplicationConverter(QuantityValue factor) {
         this.factor = factor;
     }
 
-    static UnitConverter of(double factor) {
-        if (factor == 0) {
+    static UnitConverter of(QuantityValue factor) {
+        if (factor.isZero()) {
             throw new IllegalArgumentException("0 not allowed");
-        } else if (factor == 1) {
+        } else if (factor.isOne()) {
             return IDENTITY;
         }
 
@@ -22,13 +24,13 @@ static UnitConverter of(double factor) {
     }
 
     @Override
-    public double convert(double value) {
-        return factor * value;
+    public QuantityValue convert(QuantityValue value) {
+        return value.multiply(factor);
     }
 
     @Override
     public UnitConverter inverse() {
-        return new MultiplicationConverter(1 / factor);
+        return of(factor.inverse());
     }
 
     @Override
@@ -36,7 +38,7 @@ public UnitConverter concat(UnitConverter converter) {
         if (converter.isIdentity()) {
             return this;
         } else if (converter instanceof MultiplicationConverter) {
-            return of(factor * ((MultiplicationConverter) converter).factor);
+            return of(factor.multiply(((MultiplicationConverter) converter).factor));
         }
 
         return UnitConverter.compound(List.of(this, converter));
@@ -56,7 +58,7 @@ public boolean equals(Object o) {
             return false;
         }
         MultiplicationConverter that = (MultiplicationConverter) o;
-        return Double.compare(that.factor, factor) == 0;
+        return factor.equals(that.factor);
     }
 
     @Override
diff --git a/src/main/java/io/github/ititus/si/unit/converter/UnitConverter.java b/src/main/java/io/github/ititus/si/unit/converter/UnitConverter.java
index 95a6fc9..39896a9 100644
--- a/src/main/java/io/github/ititus/si/unit/converter/UnitConverter.java
+++ b/src/main/java/io/github/ititus/si/unit/converter/UnitConverter.java
@@ -1,12 +1,14 @@
 package io.github.ititus.si.unit.converter;
 
+import io.github.ititus.si.quantity.value.QuantityValue;
+
 import java.util.List;
 
 public interface UnitConverter {
 
     IdentityConverter IDENTITY = IdentityConverter.IDENTITY;
 
-    static UnitConverter factor(double factor) {
+    static UnitConverter factor(QuantityValue factor) {
         return MultiplicationConverter.of(factor);
     }
 
@@ -14,7 +16,7 @@ static UnitConverter compound(List<UnitConverter> converters) {
         return CompoundConverter.of(converters);
     }
 
-    double convert(double value);
+    QuantityValue convert(QuantityValue value);
 
     UnitConverter inverse();
 
diff --git a/src/test/java/io/github/ititus/assertions/Assertions.java b/src/test/java/io/github/ititus/assertions/Assertions.java
deleted file mode 100644
index 0b6c3e3..0000000
--- a/src/test/java/io/github/ititus/assertions/Assertions.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package io.github.ititus.assertions;
-
-import io.github.ititus.math.number.BigRational;
-
-public class Assertions {
-
-    public static BigRationalAssert assertThat(BigRational actual) {
-        return new BigRationalAssert(actual);
-    }
-}
diff --git a/src/test/java/io/github/ititus/assertions/CustomAssertions.java b/src/test/java/io/github/ititus/assertions/CustomAssertions.java
new file mode 100644
index 0000000..b3b3542
--- /dev/null
+++ b/src/test/java/io/github/ititus/assertions/CustomAssertions.java
@@ -0,0 +1,15 @@
+package io.github.ititus.assertions;
+
+import io.github.ititus.math.number.BigRational;
+import io.github.ititus.si.quantity.value.QuantityValue;
+
+public class CustomAssertions {
+
+    public static BigRationalAssert assertThat(BigRational actual) {
+        return new BigRationalAssert(actual);
+    }
+
+    public static QuantityValueAssert assertThat(QuantityValue actual) {
+        return new QuantityValueAssert(actual);
+    }
+}
diff --git a/src/test/java/io/github/ititus/assertions/QuantityValueAssert.java b/src/test/java/io/github/ititus/assertions/QuantityValueAssert.java
new file mode 100644
index 0000000..a99742a
--- /dev/null
+++ b/src/test/java/io/github/ititus/assertions/QuantityValueAssert.java
@@ -0,0 +1,94 @@
+package io.github.ititus.assertions;
+
+import io.github.ititus.si.quantity.value.QuantityValue;
+import org.assertj.core.api.AbstractComparableAssert;
+import org.assertj.core.api.NumberAssert;
+import org.assertj.core.data.Offset;
+import org.assertj.core.data.Percentage;
+
+public class QuantityValueAssert extends AbstractComparableAssert<QuantityValueAssert, QuantityValue> implements NumberAssert<QuantityValueAssert, QuantityValue> {
+
+    private final QuantityValues bigRationals = QuantityValues.instance();
+
+    public QuantityValueAssert(QuantityValue actual) {
+        super(actual, QuantityValueAssert.class);
+    }
+
+    @Override
+    public QuantityValueAssert isZero() {
+        bigRationals.assertIsZero(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNotZero() {
+        bigRationals.assertIsNotZero(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isOne() {
+        bigRationals.assertIsOne(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isPositive() {
+        bigRationals.assertIsPositive(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNegative() {
+        bigRationals.assertIsNegative(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNotNegative() {
+        bigRationals.assertIsNotNegative(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNotPositive() {
+        bigRationals.assertIsNotPositive(info, actual);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isBetween(QuantityValue start, QuantityValue end) {
+        bigRationals.assertIsBetween(info, actual, start, end);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isStrictlyBetween(QuantityValue start, QuantityValue end) {
+        bigRationals.assertIsStrictlyBetween(info, actual, start, end);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isCloseTo(QuantityValue expected, Offset<QuantityValue> offset) {
+        bigRationals.assertIsCloseTo(info, actual, expected, offset);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNotCloseTo(QuantityValue expected, Offset<QuantityValue> offset) {
+        bigRationals.assertIsNotCloseTo(info, actual, expected, offset);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isCloseTo(QuantityValue expected, Percentage percentage) {
+        bigRationals.assertIsCloseToPercentage(info, actual, expected, percentage);
+        return this;
+    }
+
+    @Override
+    public QuantityValueAssert isNotCloseTo(QuantityValue expected, Percentage percentage) {
+        bigRationals.assertIsNotCloseToPercentage(info, actual, expected, percentage);
+        return this;
+    }
+}
diff --git a/src/test/java/io/github/ititus/assertions/QuantityValues.java b/src/test/java/io/github/ititus/assertions/QuantityValues.java
new file mode 100644
index 0000000..3228a70
--- /dev/null
+++ b/src/test/java/io/github/ititus/assertions/QuantityValues.java
@@ -0,0 +1,36 @@
+package io.github.ititus.assertions;
+
+import io.github.ititus.si.quantity.value.QuantityValue;
+import org.assertj.core.internal.Numbers;
+
+public class QuantityValues extends Numbers<QuantityValue> {
+
+    private static final QuantityValues INSTANCE = new QuantityValues();
+
+    private QuantityValues() {
+    }
+
+    public static QuantityValues instance() {
+        return INSTANCE;
+    }
+
+    @Override
+    protected QuantityValue zero() {
+        return QuantityValue.ZERO;
+    }
+
+    @Override
+    protected QuantityValue one() {
+        return QuantityValue.ONE;
+    }
+
+    @Override
+    protected QuantityValue absDiff(QuantityValue actual, QuantityValue other) {
+        return actual.subtract(other).abs();
+    }
+
+    @Override
+    protected boolean isGreaterThan(QuantityValue value, QuantityValue other) {
+        return value.compareTo(other) > 0;
+    }
+}
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
index 1bcfc35..73a36b0 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.Assertions.assertThat;
+import static io.github.ititus.assertions.CustomAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.exp;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
index 5802c3d..43dc520 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.Assertions.assertThat;
+import static io.github.ititus.assertions.CustomAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.ln;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
index f2dc544..f9a05f4 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.Assertions.assertThat;
+import static io.github.ititus.assertions.CustomAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.sin;
diff --git a/src/test/java/io/github/ititus/si/quantity/type/ForceTest.java b/src/test/java/io/github/ititus/si/quantity/type/ForceTest.java
index b2b6ecd..12cc960 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/ForceTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/ForceTest.java
@@ -8,6 +8,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class ForceTest {
+
     @Test
     public void compoundTest() {
         Quantity<Mass> twoKilos = KILOGRAM.get(2);
@@ -26,7 +27,7 @@ public void compoundWithStandardTest() {
 
         Quantity<Force> expectedForce = NEWTON.get(10);
 
-        Quantity<Force> force = twoKilos.multiply(acceleration).as(FORCE).convertToStandard();
+        Quantity<Force> force = twoKilos.multiply(acceleration).asStandard(FORCE);
         assertThat(force).isEqualTo(expectedForce);
     }
 
@@ -47,7 +48,7 @@ public void compoundFromMomentum() {
         Quantity<Time> timeDelta = SECOND.get(2);
         Quantity<Force> expectedForce = NEWTON.get(7.5);
 
-        Quantity<Force> force = momentumDelta.divide(timeDelta).as(FORCE).convertToStandard();
+        Quantity<Force> force = momentumDelta.divide(timeDelta).asStandard(FORCE);
         assertThat(force).isEqualTo(expectedForce);
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
index c897ea5..820ee09 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
@@ -1,22 +1,26 @@
 package io.github.ititus.si.quantity.type;
 
+import io.github.ititus.assertions.CustomAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
+import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.prefix.MetricPrefix.CENTI;
 import static io.github.ititus.si.prefix.MetricPrefix.MILLI;
+import static io.github.ititus.si.quantity.value.QuantityValue.of;
 import static io.github.ititus.si.unit.Units.METRE;
 import static io.github.ititus.si.unit.Units.MILE;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Percentage.withPercentage;
 
 public class LengthTest {
+
     @Test
     public void metreToCentiMetre() {
         Quantity<Length> metres = METRE.get(1.35);
         Quantity<Length> centiMetres = metres.convertTo(METRE.prefix(CENTI));
 
-        assertThat(centiMetres.getValue()).isEqualTo(135);
+        CustomAssertions.assertThat(centiMetres.getValue()).isCloseTo(of(135), withPercentage(1.0));
         assertThat(centiMetres.getUnit().getSymbol()).isEqualTo("cm");
     }
 
@@ -25,7 +29,7 @@ public void milliMetreToMiles() {
         Quantity<Length> milliMetre = METRE.prefix(MILLI).get(23);
         Quantity<Length> miles = milliMetre.convertTo(MILE);
 
-        assertThat(miles.getValue()).isCloseTo(1.429E-5, withPercentage(1));
+        CustomAssertions.assertThat(miles.getValue()).isCloseTo(of(ofExp(1429, -8)), withPercentage(1.0));
         assertThat(miles.getUnit().getSymbol()).isEqualTo("mi");
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
index 7fdd7b7..41fb39a 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
@@ -1,21 +1,25 @@
 package io.github.ititus.si.quantity.type;
 
+import io.github.ititus.assertions.CustomAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
+import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.prefix.MetricPrefix.NANO;
+import static io.github.ititus.si.quantity.value.QuantityValue.of;
 import static io.github.ititus.si.unit.Units.GRAM;
 import static io.github.ititus.si.unit.Units.KILOGRAM;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Percentage.withPercentage;
 
 public class MassTest {
+
     @Test
     public void kilogramToNanoGrams() {
         Quantity<Mass> kiloGrams = KILOGRAM.get(1.35);
         Quantity<Mass> nanoGrams = kiloGrams.convertTo(GRAM.prefix(NANO));
 
-        assertThat(nanoGrams.getValue()).isCloseTo(1.35E12, withPercentage(1));
+        CustomAssertions.assertThat(nanoGrams.getValue()).isCloseTo(of(ofExp(135, 10)), withPercentage(1));
         assertThat(nanoGrams.getUnit().getSymbol()).isEqualTo("ng");
     }
-}
\ No newline at end of file
+}

From f3c7e4eb5fe91d4a47e23f7d3a801bad3414fc63 Mon Sep 17 00:00:00 2001
From: iTitus <iTitus@users.noreply.github.com>
Date: Tue, 10 Nov 2020 22:28:23 +0100
Subject: [PATCH 2/3] rename test helper

---
 .../assertions/{CustomAssertions.java => MyAssertions.java} | 6 +++++-
 .../io/github/ititus/math/number/BigRationalExpTests.java   | 2 +-
 .../io/github/ititus/math/number/BigRationalLnTests.java    | 2 +-
 .../io/github/ititus/math/number/BigRationalSinTests.java   | 2 +-
 .../java/io/github/ititus/si/quantity/type/LengthTest.java  | 6 +++---
 .../java/io/github/ititus/si/quantity/type/MassTest.java    | 4 ++--
 6 files changed, 13 insertions(+), 9 deletions(-)
 rename src/test/java/io/github/ititus/assertions/{CustomAssertions.java => MyAssertions.java} (71%)

diff --git a/src/test/java/io/github/ititus/assertions/CustomAssertions.java b/src/test/java/io/github/ititus/assertions/MyAssertions.java
similarity index 71%
rename from src/test/java/io/github/ititus/assertions/CustomAssertions.java
rename to src/test/java/io/github/ititus/assertions/MyAssertions.java
index b3b3542..07527c8 100644
--- a/src/test/java/io/github/ititus/assertions/CustomAssertions.java
+++ b/src/test/java/io/github/ititus/assertions/MyAssertions.java
@@ -2,8 +2,9 @@
 
 import io.github.ititus.math.number.BigRational;
 import io.github.ititus.si.quantity.value.QuantityValue;
+import org.assertj.core.api.InstanceOfAssertFactories;
 
-public class CustomAssertions {
+public class MyAssertions implements InstanceOfAssertFactories {
 
     public static BigRationalAssert assertThat(BigRational actual) {
         return new BigRationalAssert(actual);
@@ -12,4 +13,7 @@ public static BigRationalAssert assertThat(BigRational actual) {
     public static QuantityValueAssert assertThat(QuantityValue actual) {
         return new QuantityValueAssert(actual);
     }
+
+    protected MyAssertions() {
+    }
 }
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
index 73a36b0..3e50258 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.CustomAssertions.assertThat;
+import static io.github.ititus.assertions.MyAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.exp;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
index 43dc520..c763954 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.CustomAssertions.assertThat;
+import static io.github.ititus.assertions.MyAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.ln;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
index f9a05f4..20266ff 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.CustomAssertions.assertThat;
+import static io.github.ititus.assertions.MyAssertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.sin;
diff --git a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
index 820ee09..897b5a3 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
@@ -1,6 +1,6 @@
 package io.github.ititus.si.quantity.type;
 
-import io.github.ititus.assertions.CustomAssertions;
+import io.github.ititus.assertions.MyAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
@@ -20,7 +20,7 @@ public void metreToCentiMetre() {
         Quantity<Length> metres = METRE.get(1.35);
         Quantity<Length> centiMetres = metres.convertTo(METRE.prefix(CENTI));
 
-        CustomAssertions.assertThat(centiMetres.getValue()).isCloseTo(of(135), withPercentage(1.0));
+        MyAssertions.assertThat(centiMetres.getValue()).isCloseTo(of(135), withPercentage(1.0));
         assertThat(centiMetres.getUnit().getSymbol()).isEqualTo("cm");
     }
 
@@ -29,7 +29,7 @@ public void milliMetreToMiles() {
         Quantity<Length> milliMetre = METRE.prefix(MILLI).get(23);
         Quantity<Length> miles = milliMetre.convertTo(MILE);
 
-        CustomAssertions.assertThat(miles.getValue()).isCloseTo(of(ofExp(1429, -8)), withPercentage(1.0));
+        MyAssertions.assertThat(miles.getValue()).isCloseTo(of(ofExp(1429, -8)), withPercentage(1.0));
         assertThat(miles.getUnit().getSymbol()).isEqualTo("mi");
     }
 }
diff --git a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
index 41fb39a..224b3ca 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
@@ -1,6 +1,6 @@
 package io.github.ititus.si.quantity.type;
 
-import io.github.ititus.assertions.CustomAssertions;
+import io.github.ititus.assertions.MyAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
@@ -19,7 +19,7 @@ public void kilogramToNanoGrams() {
         Quantity<Mass> kiloGrams = KILOGRAM.get(1.35);
         Quantity<Mass> nanoGrams = kiloGrams.convertTo(GRAM.prefix(NANO));
 
-        CustomAssertions.assertThat(nanoGrams.getValue()).isCloseTo(of(ofExp(135, 10)), withPercentage(1));
+        MyAssertions.assertThat(nanoGrams.getValue()).isCloseTo(of(ofExp(135, 10)), withPercentage(1));
         assertThat(nanoGrams.getUnit().getSymbol()).isEqualTo("ng");
     }
 }

From df40500e250bea0c370957aa72cfcf2c71cf8775 Mon Sep 17 00:00:00 2001
From: iTitus <iTitus@users.noreply.github.com>
Date: Tue, 10 Nov 2020 22:29:44 +0100
Subject: [PATCH 3/3] nvm

---
 .../assertions/{MyAssertions.java => Assertions.java}       | 4 ++--
 .../io/github/ititus/math/number/BigRationalExpTests.java   | 2 +-
 .../io/github/ititus/math/number/BigRationalLnTests.java    | 2 +-
 .../io/github/ititus/math/number/BigRationalSinTests.java   | 2 +-
 .../java/io/github/ititus/si/quantity/type/LengthTest.java  | 6 +++---
 .../java/io/github/ititus/si/quantity/type/MassTest.java    | 4 ++--
 6 files changed, 10 insertions(+), 10 deletions(-)
 rename src/test/java/io/github/ititus/assertions/{MyAssertions.java => Assertions.java} (82%)

diff --git a/src/test/java/io/github/ititus/assertions/MyAssertions.java b/src/test/java/io/github/ititus/assertions/Assertions.java
similarity index 82%
rename from src/test/java/io/github/ititus/assertions/MyAssertions.java
rename to src/test/java/io/github/ititus/assertions/Assertions.java
index 07527c8..b936346 100644
--- a/src/test/java/io/github/ititus/assertions/MyAssertions.java
+++ b/src/test/java/io/github/ititus/assertions/Assertions.java
@@ -4,7 +4,7 @@
 import io.github.ititus.si.quantity.value.QuantityValue;
 import org.assertj.core.api.InstanceOfAssertFactories;
 
-public class MyAssertions implements InstanceOfAssertFactories {
+public class Assertions implements InstanceOfAssertFactories {
 
     public static BigRationalAssert assertThat(BigRational actual) {
         return new BigRationalAssert(actual);
@@ -14,6 +14,6 @@ public static QuantityValueAssert assertThat(QuantityValue actual) {
         return new QuantityValueAssert(actual);
     }
 
-    protected MyAssertions() {
+    protected Assertions() {
     }
 }
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
index 3e50258..1bcfc35 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalExpTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.MyAssertions.assertThat;
+import static io.github.ititus.assertions.Assertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.exp;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
index c763954..5802c3d 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalLnTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.MyAssertions.assertThat;
+import static io.github.ititus.assertions.Assertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.ln;
diff --git a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
index 20266ff..f2dc544 100644
--- a/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
+++ b/src/test/java/io/github/ititus/math/number/BigRationalSinTests.java
@@ -3,7 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static io.github.ititus.assertions.MyAssertions.assertThat;
+import static io.github.ititus.assertions.Assertions.assertThat;
 import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRationalConstants.*;
 import static io.github.ititus.math.number.BigRationalMath.sin;
diff --git a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
index 897b5a3..7497f0a 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/LengthTest.java
@@ -1,9 +1,9 @@
 package io.github.ititus.si.quantity.type;
 
-import io.github.ititus.assertions.MyAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
+import static io.github.ititus.assertions.Assertions.assertThat;
 import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.prefix.MetricPrefix.CENTI;
 import static io.github.ititus.si.prefix.MetricPrefix.MILLI;
@@ -20,7 +20,7 @@ public void metreToCentiMetre() {
         Quantity<Length> metres = METRE.get(1.35);
         Quantity<Length> centiMetres = metres.convertTo(METRE.prefix(CENTI));
 
-        MyAssertions.assertThat(centiMetres.getValue()).isCloseTo(of(135), withPercentage(1.0));
+        assertThat(centiMetres.getValue()).isCloseTo(of(135), withPercentage(1.0));
         assertThat(centiMetres.getUnit().getSymbol()).isEqualTo("cm");
     }
 
@@ -29,7 +29,7 @@ public void milliMetreToMiles() {
         Quantity<Length> milliMetre = METRE.prefix(MILLI).get(23);
         Quantity<Length> miles = milliMetre.convertTo(MILE);
 
-        MyAssertions.assertThat(miles.getValue()).isCloseTo(of(ofExp(1429, -8)), withPercentage(1.0));
+        assertThat(miles.getValue()).isCloseTo(of(ofExp(1429, -8)), withPercentage(1.0));
         assertThat(miles.getUnit().getSymbol()).isEqualTo("mi");
     }
 }
diff --git a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
index 224b3ca..e2e8cd6 100644
--- a/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
+++ b/src/test/java/io/github/ititus/si/quantity/type/MassTest.java
@@ -1,9 +1,9 @@
 package io.github.ititus.si.quantity.type;
 
-import io.github.ititus.assertions.MyAssertions;
 import io.github.ititus.si.quantity.Quantity;
 import org.junit.jupiter.api.Test;
 
+import static io.github.ititus.assertions.Assertions.assertThat;
 import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.prefix.MetricPrefix.NANO;
 import static io.github.ititus.si.quantity.value.QuantityValue.of;
@@ -19,7 +19,7 @@ public void kilogramToNanoGrams() {
         Quantity<Mass> kiloGrams = KILOGRAM.get(1.35);
         Quantity<Mass> nanoGrams = kiloGrams.convertTo(GRAM.prefix(NANO));
 
-        MyAssertions.assertThat(nanoGrams.getValue()).isCloseTo(of(ofExp(135, 10)), withPercentage(1));
+        assertThat(nanoGrams.getValue()).isCloseTo(of(ofExp(135, 10)), withPercentage(1));
         assertThat(nanoGrams.getUnit().getSymbol()).isEqualTo("ng");
     }
 }