From bbce8cfdf971b28cd9072524499c634bb8edd6a2 Mon Sep 17 00:00:00 2001
From: iTitus <iTitus@users.noreply.github.com>
Date: Mon, 18 Oct 2021 20:39:00 +0200
Subject: [PATCH] implement shifting of units

---
 .../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  |   7 +-
 .../io/github/ititus/si/unit/PrefixUnit.java  |   5 +
 .../java/io/github/ititus/si/unit/Unit.java   |  30 +++++
 .../java/io/github/ititus/si/unit/Units.java  | 106 +++++++-----------
 .../si/unit/converter/CompoundConverter.java  |   4 +-
 .../si/unit/converter/LinearConverter.java    |  88 +++++++++++++++
 .../converter/MultiplicationConverter.java    |  68 -----------
 .../si/unit/converter/UnitConverter.java      |  12 +-
 .../ititus/si/quantity/type/ForceTest.java    |  10 +-
 .../ititus/si/quantity/type/LengthTest.java   |   6 +-
 .../ititus/si/quantity/type/MassTest.java     |   4 +-
 .../si/quantity/type/TemperatureTest.java     |  29 +++++
 15 files changed, 233 insertions(+), 151 deletions(-)
 create mode 100644 src/main/java/io/github/ititus/si/unit/converter/LinearConverter.java
 delete mode 100644 src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java
 create mode 100644 src/test/java/io/github/ititus/si/quantity/type/TemperatureTest.java

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 86277d2..6a2db8d 100644
--- a/src/main/java/io/github/ititus/si/unit/AlternateUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/AlternateUnit.java
@@ -44,6 +44,11 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
         return new AlternateUnit<>(baseUnit.as(type), alternateSymbol);
     }
 
+    @Override
+    public Unit<Q> shift(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.shift(v));
+    }
+
     @Override
     public Unit<Q> multiply(QuantityValue v) {
         return baseUnit.multiply(v);
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 68ddd37..fc09db3 100644
--- a/src/main/java/io/github/ititus/si/unit/BaseUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/BaseUnit.java
@@ -44,6 +44,11 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
         return new BaseUnit<>(type, symbol);
     }
 
+    @Override
+    public Unit<Q> shift(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.shift(v));
+    }
+
     @Override
     public Unit<Q> multiply(QuantityValue v) {
         return ConvertedUnit.of(this, UnitConverter.factor(v));
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 537bd49..a121231 100644
--- a/src/main/java/io/github/ititus/si/unit/CompoundUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/CompoundUnit.java
@@ -162,6 +162,11 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
         return new CompoundUnit<>(type, getDimension(), units);
     }
 
+    @Override
+    public Unit<Q> shift(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.shift(v));
+    }
+
     @Override
     public Unit<Q> multiply(QuantityValue v) {
         return ConvertedUnit.of(this, UnitConverter.factor(v));
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 ad0d282..01e723e 100644
--- a/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/ConvertedUnit.java
@@ -28,7 +28,7 @@ public static <Q extends QuantityType<Q>> Unit<Q> of(Unit<Q> baseUnit, UnitConve
 
     @Override
     public String getSymbol() {
-        throw new UnsupportedOperationException("converted units have not symbol");
+        throw new UnsupportedOperationException("converted units have no symbol");
     }
 
     @Override
@@ -56,6 +56,11 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
         return new ConvertedUnit<>(baseUnit.as(type), converter);
     }
 
+    @Override
+    public Unit<Q> shift(QuantityValue v) {
+        return of(baseUnit, converter.concat(UnitConverter.shift(v)));
+    }
+
     @Override
     public Unit<Q> multiply(QuantityValue v) {
         return of(baseUnit, converter.concat(UnitConverter.factor(v)));
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 0971b2b..a7358b9 100644
--- a/src/main/java/io/github/ititus/si/unit/PrefixUnit.java
+++ b/src/main/java/io/github/ititus/si/unit/PrefixUnit.java
@@ -58,6 +58,11 @@ public <T extends QuantityType<T>> Unit<T> as(T type) {
         return new PrefixUnit<>(baseUnit.as(type), prefix);
     }
 
+    @Override
+    public Unit<Q> shift(QuantityValue v) {
+        return ConvertedUnit.of(this, UnitConverter.shift(v));
+    }
+
     @Override
     public Unit<Q> multiply(QuantityValue v) {
         return ConvertedUnit.of(this, UnitConverter.factor(v));
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 84c3866..21f74e0 100644
--- a/src/main/java/io/github/ititus/si/unit/Unit.java
+++ b/src/main/java/io/github/ititus/si/unit/Unit.java
@@ -59,6 +59,36 @@ default <T extends QuantityType<T>> boolean isCommensurableWith(T type) {
 
     <T extends QuantityType<T>> Unit<T> as(T type);
 
+    default Unit<Q> shift(int n) {
+        return shift(BigRational.of(n));
+    }
+
+    default Unit<Q> shift(long n) {
+        return shift(QuantityValue.of(n));
+    }
+
+    default Unit<Q> shift(BigInteger n) {
+        return shift(QuantityValue.of(n));
+    }
+
+    default Unit<Q> shift(float f) {
+        return shift(QuantityValue.of(f));
+    }
+
+    default Unit<Q> shift(double d) {
+        return shift(QuantityValue.of(d));
+    }
+
+    default Unit<Q> shift(BigDecimal d) {
+        return shift(QuantityValue.of(d));
+    }
+
+    default Unit<Q> shift(BigRational r) {
+        return shift(QuantityValue.of(r));
+    }
+
+    Unit<Q> shift(QuantityValue v);
+
     default Unit<Q> multiply(int n) {
         return multiply(BigRational.of(n));
     }
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 eb0fd85..2c39b70 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,7 @@
 
 import io.github.ititus.si.quantity.type.*;
 
+import static io.github.ititus.math.number.BigRational.of;
 import static io.github.ititus.math.number.BigRational.ofExp;
 import static io.github.ititus.si.prefix.MetricPrefix.*;
 import static io.github.ititus.si.quantity.type.Acceleration.ACCELERATION;
@@ -68,21 +69,21 @@ public final class Units {
     // Length
     public static final Unit<Length> KILOMETRE = METRE.prefix(KILO);
     public static final Unit<Length> DECIMETRE = METRE.prefix(DECI);
+    public static final Unit<Volume> CUBIC_DECIMETRE = DECIMETRE.pow(3).as(VOLUME);
+    public static final Unit<Volume> LITRE = CUBIC_DECIMETRE.alternate("l");
     public static final Unit<Length> MILLIMETRE = METRE.prefix(MILLI);
     public static final Unit<Length> INCH = MILLIMETRE.multiply(ofExp(254, -1)).alternate("in");
     public static final Unit<Length> FOOT = INCH.multiply(12).alternate("ft");
     public static final Unit<Length> YARD = FOOT.multiply(3).alternate("yd");
     public static final Unit<Length> MILE = YARD.multiply(1760).alternate("mi");
+    public static final Unit<Length> FATHOM = YARD.multiply(2).alternate("ftm");
     public static final Unit<Length> PICA = INCH.divide(6).alternate("pica");
     public static final Unit<Length> POINT = PICA.divide(12).alternate("pt");
-    public static final Unit<Length> FATHOM = YARD.multiply(2).alternate("ftm");
     public static final Unit<Length> NAUTICAL_MILE = METRE.multiply(1_852).alternate("nmi");
     public static final Unit<Length> CABLE = NAUTICAL_MILE.divide(10).alternate("cb");
-
     // Mass
     public static final Unit<Mass> KILOGRAM = GRAM.prefix(KILO);
     public static final Unit<Mass> TONNE = KILOGRAM.multiply(1_000).alternate("t");
-    public static final Unit<Mass> CARAT = GRAM.divide(5).alternate("ct");
     public static final Unit<Mass> POUND = KILOGRAM.multiply(ofExp(45_359_237, -8)).alternate("lb");
     public static final Unit<Mass> OUNCE = POUND.divide(16).alternate("oz");
     public static final Unit<Mass> DRAM = OUNCE.divide(16).alternate("dr");
@@ -90,128 +91,97 @@ public final class Units {
     public static final Unit<Mass> PENNYWEIGHT = GRAIN.multiply(24).alternate("dwt");
     public static final Unit<Mass> TROY_OUNCE = PENNYWEIGHT.multiply(20).alternate("oz t");
     public static final Unit<Mass> TROY_POUND = TROY_OUNCE.multiply(12).alternate("lb t");
-
+    // Momentum
+    public static final Unit<Momentum> KILOGRAM_METRES_PER_SECOND =
+            KILOGRAM.multiply(METRE.divide(SECOND)).as(MOMENTUM);
+    public static final Unit<Mass> CARAT = GRAM.divide(5).alternate("ct");
     // Time
     public static final Unit<Time> MINUTE = SECOND.multiply(60).alternate("min");
     public static final Unit<Time> HOUR = MINUTE.multiply(60).alternate("h");
     public static final Unit<Time> DAY = HOUR.multiply(24).alternate("d");
-    public static final Unit<Time> NANOSECOND = SECOND.prefix(NANO);
-    public static final Unit<Time> MICROSECOND = SECOND.prefix(MICRO);
-    public static final Unit<Time> MILLISECOND = SECOND.prefix(MILLI);
 
     // Electric Current
-
-    // Thermodynamic Temperature
+    public static final Unit<Speed> KILOMETRES_PER_HOUR = KILOMETRE.divide(HOUR).as(SPEED);
+    public static final Unit<Speed> MILES_PER_HOUR = MILE.divide(HOUR).alternate("mph").as(SPEED);
+    public static final Unit<Speed> KNOT = NAUTICAL_MILE.divide(HOUR).alternate("kn").as(SPEED);
 
     // Amount of Substance
 
     // Luminous Intensity
-
+    public static final Unit<Pace> MINUTES_PER_KILOMETRE = MINUTE.divide(KILOMETRE).as(PACE);
+    public static final Unit<Time> NANOSECOND = SECOND.prefix(NANO);
+    public static final Unit<Time> MICROSECOND = SECOND.prefix(MICRO);
+    public static final Unit<Time> MILLISECOND = SECOND.prefix(MILLI);
+    // Thermodynamic Temperature
+    public static final Unit<ThermodynamicTemperature> CELSIUS = KELVIN.shift(ofExp(27315, -2)).alternate("°C");
+    public static final Unit<ThermodynamicTemperature> RANKINE = KELVIN.multiply(of(9, 5)).alternate("°R");
+    public static final Unit<ThermodynamicTemperature> FAHRENHEIT = RANKINE.shift(ofExp(45967, -2)).alternate("°F");
     // (Plane) Angle
     public static final Unit<Angle> RADIAN = ONE.alternate("rad").as(ANGLE);
-
     // Solid Angle
     public static final Unit<SolidAngle> STERADIAN = ONE.alternate("sr").as(SOLID_ANGLE);
-
+    // Luminous Flux
+    public static final Unit<LuminousFlux> LUMEN = CANDELA.multiply(STERADIAN).alternate("lm").as(LUMINOUS_FLUX);
     // Frequency
     public static final Unit<Frequency> HERTZ = SECOND.inverse().alternate("Hz").as(FREQUENCY);
-
     // Speed
     public static final Unit<Speed> METRES_PER_SECOND = METRE.divide(SECOND).as(SPEED);
-    public static final Unit<Speed> KILOMETRES_PER_HOUR = KILOMETRE.divide(HOUR).as(SPEED);
-    public static final Unit<Speed> MILES_PER_HOUR = MILE.divide(HOUR).alternate("mph").as(SPEED);
-    public static final Unit<Speed> KNOT = NAUTICAL_MILE.divide(HOUR).alternate("kn").as(SPEED);
-
     // Pace
     public static final Unit<Pace> SECONDS_PER_METRE = SECOND.divide(METRE).as(PACE);
-    public static final Unit<Pace> MINUTES_PER_KILOMETRE = MINUTE.divide(KILOMETRE).as(PACE);
-
     // Acceleration
     public static final Unit<Acceleration> METRES_PER_SECOND_SQUARED = METRE.divide(SECOND.pow(2)).as(ACCELERATION);
-
-    // Momentum
-    public static final Unit<Momentum> KILOGRAM_METRES_PER_SECOND =
-            KILOGRAM.multiply(METRE.divide(SECOND)).as(MOMENTUM);
-
     // Force
     public static final Unit<Force> NEWTON = KILOGRAM.multiply(METRES_PER_SECOND_SQUARED).alternate("N").as(FORCE);
-
     // Energy & Power
     public static final Unit<Energy> JOULE = NEWTON.multiply(METRE).alternate("J").as(ENERGY);
     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);
-
+    // Luminous Efficacy
+    public static final Unit<LuminousEfficacy> LUMEN_PER_WATT = LUMEN.divide(WATT).as(LUMINOUS_EFFICACY);
+    // Radiation Dose Absorbed
+    public static final Unit<RadiationDoseAbsorbed> GRAY =
+            JOULE.divide(KILOGRAM).alternate("Gy").as(RADIATION_DOSE_ABSORBED);
+    // Equivalent Radiation Dose
+    public static final Unit<EquivalentRadiationDose> SIEVERT =
+            JOULE.divide(KILOGRAM).alternate("Sv").as(EQUIVALENT_RADIATION_DOSE);
     // Area
     public static final Unit<Area> SQUARE_METRE = METRE.pow(2).as(AREA);
-
+    // Pressure
+    public static final Unit<Pressure> PASCAL = NEWTON.divide(SQUARE_METRE).alternate("Pa").as(PRESSURE);
+    // Electric Current Density
+    public static final Unit<ElectricCurrentDensity> AMPERE_PER_SQUARE_METRE =
+            AMPERE.divide(SQUARE_METRE).as(ELECTRIC_CURRENT_DENSITY);
+    // Illuminance
+    public static final Unit<Illuminance> LUX = LUMEN.divide(SQUARE_METRE).alternate("lx").as(ILLUMINANCE);
     // Volume
     public static final Unit<Volume> CUBIC_METRE = METRE.pow(3).as(VOLUME);
-    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);
-
-    // Pressure
-    public static final Unit<Pressure> PASCAL = NEWTON.divide(SQUARE_METRE).alternate("Pa").as(PRESSURE);
-
     // Electric Charge
     public static final Unit<ElectricCharge> COULOMB = AMPERE.multiply(SECOND).alternate("C").as(ELECTRIC_CHARGE);
-
     // Electric Potential
     public static final Unit<ElectricPotential> VOLT = JOULE.divide(COULOMB).alternate("V").as(ELECTRIC_POTENTIAL);
-
     // Electric Capacitance
     public static final Unit<ElectricCapacitance> FARAD = COULOMB.divide(VOLT).alternate("F").as(ELECTRIC_CAPACITANCE);
-
+    // Electric Permittivity
+    public static final Unit<ElectricPermittivity> FARAD_PER_METRE = FARAD.divide(METRE).as(ELECTRIC_PERMITTIVITY);
     // Electric Resistance
     public static final Unit<ElectricResistance> OHM = VOLT.divide(AMPERE).alternate("\u03A9").as(ELECTRIC_RESISTANCE);
-
     // Electric Conductance
     public static final Unit<ElectricConductance> SIEMENS = OHM.inverse().alternate("S").as(ELECTRIC_CONDUCTANCE);
-
     // Magnetic Flux
     public static final Unit<MagneticFlux> WEBER = VOLT.multiply(SECOND).alternate("Wb").as(MAGNETIC_FLUX);
-
     // Magnetic Flux Density
     public static final Unit<MagneticFluxDensity> TESLA =
             WEBER.divide(SQUARE_METRE).alternate("T").as(MAGNETIC_FLUX_DENSITY);
-
     // Electric Inductance
     public static final Unit<ElectricInductance> HENRY = WEBER.divide(AMPERE).alternate("H").as(ELECTRIC_INDUCTANCE);
-
-    // Electric Current Density
-    public static final Unit<ElectricCurrentDensity> AMPERE_PER_SQUARE_METRE =
-            AMPERE.divide(SQUARE_METRE).as(ELECTRIC_CURRENT_DENSITY);
-
-    // Electric Permittivity
-    public static final Unit<ElectricPermittivity> FARAD_PER_METRE = FARAD.divide(METRE).as(ELECTRIC_PERMITTIVITY);
-
     // Magnetic Permeability
     public static final Unit<MagneticPermeability> HENRY_PER_METRE = HENRY.divide(METRE).as(MAGNETIC_PERMEABILITY);
-
     // Radioactivity
     public static final Unit<Radioactivity> BECQUEREL = SECOND.inverse().alternate("Bq").as(RADIOACTIVITY);
-
-    // Radiation Dose Absorbed
-    public static final Unit<RadiationDoseAbsorbed> GRAY =
-            JOULE.divide(KILOGRAM).alternate("Gy").as(RADIATION_DOSE_ABSORBED);
-
-    // Equivalent Radiation Dose
-    public static final Unit<EquivalentRadiationDose> SIEVERT =
-            JOULE.divide(KILOGRAM).alternate("Sv").as(EQUIVALENT_RADIATION_DOSE);
-
-    // Luminous Flux
-    public static final Unit<LuminousFlux> LUMEN = CANDELA.multiply(STERADIAN).alternate("lm").as(LUMINOUS_FLUX);
-
-    // Luminous Efficacy
-    public static final Unit<LuminousEfficacy> LUMEN_PER_WATT = LUMEN.divide(WATT).as(LUMINOUS_EFFICACY);
-
-    // Illuminance
-    public static final Unit<Illuminance> LUX = LUMEN.divide(SQUARE_METRE).alternate("lx").as(ILLUMINANCE);
-
     // Catalytic Activity
     public static final Unit<CatalyticActivity> KATAL = MOLE.divide(SECOND).alternate("kat").as(CATALYTIC_ACTIVITY);
 
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 2323874..5264595 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
@@ -46,13 +46,13 @@ private static List<UnitConverter> simplify(List<UnitConverter> converters) {
         outer:
         for (int i = 0; i < converters.size(); i++) {
             UnitConverter c = converters.get(i);
-            if (!(c instanceof MultiplicationConverter)) {
+            if (!(c instanceof LinearConverter)) {
                 simplified.add(c);
             }
 
             for (int j = i + 1; j < converters.size(); j++) {
                 UnitConverter c_ = converters.get(j);
-                if (!(c_ instanceof MultiplicationConverter)) {
+                if (!(c_ instanceof LinearConverter)) {
                     simplified.add(c);
                     i = j;
                     continue outer;
diff --git a/src/main/java/io/github/ititus/si/unit/converter/LinearConverter.java b/src/main/java/io/github/ititus/si/unit/converter/LinearConverter.java
new file mode 100644
index 0000000..a3400fd
--- /dev/null
+++ b/src/main/java/io/github/ititus/si/unit/converter/LinearConverter.java
@@ -0,0 +1,88 @@
+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 LinearConverter implements UnitConverter {
+
+    private final QuantityValue factor;
+    private final QuantityValue shift;
+
+    private LinearConverter(QuantityValue factor, QuantityValue shift) {
+        this.factor = factor;
+        this.shift = shift;
+    }
+
+    static UnitConverter ofFactor(QuantityValue factor) {
+        if (factor.isZero()) {
+            throw new IllegalArgumentException("0 not allowed");
+        } else if (factor.isOne()) {
+            return IDENTITY;
+        }
+
+        return new LinearConverter(factor, QuantityValue.ZERO);
+    }
+
+    static UnitConverter ofShift(QuantityValue shift) {
+        if (shift.isZero()) {
+            return IDENTITY;
+        }
+
+        return new LinearConverter(QuantityValue.ONE, shift);
+    }
+
+    static UnitConverter of(QuantityValue factor, QuantityValue shift) {
+        if (factor.isZero()) {
+            throw new IllegalArgumentException("0 not allowed");
+        } else if (factor.isOne() && shift.isZero()) {
+            return IDENTITY;
+        }
+
+        return new LinearConverter(factor, shift);
+    }
+
+    @Override
+    public QuantityValue convert(QuantityValue value) {
+        return value.multiply(factor).add(shift);
+    }
+
+    @Override
+    public UnitConverter inverse() {
+        return of(factor.inverse(), shift.divide(factor).negate());
+    }
+
+    @Override
+    public UnitConverter concat(UnitConverter converter) {
+        if (converter.isIdentity()) {
+            return this;
+        } else if (converter instanceof LinearConverter) {
+            LinearConverter that = (LinearConverter) converter;
+            return of(factor.multiply(that.factor), that.factor.multiply(shift).add(this.shift));
+        }
+
+        return UnitConverter.compound(List.of(this, converter));
+    }
+
+    @Override
+    public boolean isIdentity() {
+        return false;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        } else if (!(o instanceof LinearConverter)) {
+            return false;
+        }
+        LinearConverter that = (LinearConverter) o;
+        return factor.equals(that.factor) && shift.equals(that.shift);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(factor, shift);
+    }
+}
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
deleted file mode 100644
index bb0f6ef..0000000
--- a/src/main/java/io/github/ititus/si/unit/converter/MultiplicationConverter.java
+++ /dev/null
@@ -1,68 +0,0 @@
-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 QuantityValue factor;
-
-    private MultiplicationConverter(QuantityValue factor) {
-        this.factor = factor;
-    }
-
-    static UnitConverter of(QuantityValue factor) {
-        if (factor.isZero()) {
-            throw new IllegalArgumentException("0 not allowed");
-        } else if (factor.isOne()) {
-            return IDENTITY;
-        }
-
-        return new MultiplicationConverter(factor);
-    }
-
-    @Override
-    public QuantityValue convert(QuantityValue value) {
-        return value.multiply(factor);
-    }
-
-    @Override
-    public UnitConverter inverse() {
-        return of(factor.inverse());
-    }
-
-    @Override
-    public UnitConverter concat(UnitConverter converter) {
-        if (converter.isIdentity()) {
-            return this;
-        } else if (converter instanceof MultiplicationConverter) {
-            return of(factor.multiply(((MultiplicationConverter) converter).factor));
-        }
-
-        return UnitConverter.compound(List.of(this, converter));
-    }
-
-    @Override
-    public boolean isIdentity() {
-        return false;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (!(o instanceof MultiplicationConverter)) {
-            return false;
-        }
-        MultiplicationConverter that = (MultiplicationConverter) o;
-        return factor.equals(that.factor);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(factor);
-    }
-}
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 39896a9..045acf2 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
@@ -6,10 +6,18 @@
 
 public interface UnitConverter {
 
-    IdentityConverter IDENTITY = IdentityConverter.IDENTITY;
+    UnitConverter IDENTITY = IdentityConverter.IDENTITY;
+
+    static UnitConverter shift(QuantityValue shift) {
+        return LinearConverter.ofShift(shift);
+    }
 
     static UnitConverter factor(QuantityValue factor) {
-        return MultiplicationConverter.of(factor);
+        return LinearConverter.ofFactor(factor);
+    }
+
+    static UnitConverter linear(QuantityValue factor, QuantityValue shift) {
+        return LinearConverter.of(factor, shift);
     }
 
     static UnitConverter compound(List<UnitConverter> converters) {
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 12cc960..c37170c 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
@@ -7,10 +7,10 @@
 import static io.github.ititus.si.unit.Units.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class ForceTest {
+class ForceTest {
 
     @Test
-    public void compoundTest() {
+    void compoundTest() {
         Quantity<Mass> twoKilos = KILOGRAM.get(2);
         Quantity<Acceleration> acceleration = METRES_PER_SECOND_SQUARED.get(5);
 
@@ -21,7 +21,7 @@ public void compoundTest() {
     }
 
     @Test
-    public void compoundWithStandardTest() {
+    void compoundWithStandardTest() {
         Quantity<Mass> twoKilos = KILOGRAM.get(2);
         Quantity<Acceleration> acceleration = METRES_PER_SECOND_SQUARED.get(5);
 
@@ -32,7 +32,7 @@ public void compoundWithStandardTest() {
     }
 
     @Test
-    public void compoundSymbolTest() {
+    void compoundSymbolTest() {
         Quantity<Mass> twoKilos = KILOGRAM.get(2);
         Quantity<Acceleration> acceleration = METRES_PER_SECOND_SQUARED.get(5);
 
@@ -41,7 +41,7 @@ public void compoundSymbolTest() {
     }
 
     @Test
-    public void compoundFromMomentum() {
+    void compoundFromMomentum() {
         Quantity<Mass> kilogram = KILOGRAM.get(5);
         Quantity<Speed> metresPerSecond = METRES_PER_SECOND.get(3);
         Quantity<?> momentumDelta = kilogram.multiply(metresPerSecond);
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 7497f0a..bb00ecb 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
@@ -13,10 +13,10 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Percentage.withPercentage;
 
-public class LengthTest {
+class LengthTest {
 
     @Test
-    public void metreToCentiMetre() {
+    void metreToCentiMetre() {
         Quantity<Length> metres = METRE.get(1.35);
         Quantity<Length> centiMetres = metres.convertTo(METRE.prefix(CENTI));
 
@@ -25,7 +25,7 @@ public void metreToCentiMetre() {
     }
 
     @Test
-    public void milliMetreToMiles() {
+    void milliMetreToMiles() {
         Quantity<Length> milliMetre = METRE.prefix(MILLI).get(23);
         Quantity<Length> miles = milliMetre.convertTo(MILE);
 
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 e2e8cd6..c3cc452 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
@@ -12,10 +12,10 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.Percentage.withPercentage;
 
-public class MassTest {
+class MassTest {
 
     @Test
-    public void kilogramToNanoGrams() {
+    void kilogramToNanoGrams() {
         Quantity<Mass> kiloGrams = KILOGRAM.get(1.35);
         Quantity<Mass> nanoGrams = kiloGrams.convertTo(GRAM.prefix(NANO));
 
diff --git a/src/test/java/io/github/ititus/si/quantity/type/TemperatureTest.java b/src/test/java/io/github/ititus/si/quantity/type/TemperatureTest.java
new file mode 100644
index 0000000..2c2350e
--- /dev/null
+++ b/src/test/java/io/github/ititus/si/quantity/type/TemperatureTest.java
@@ -0,0 +1,29 @@
+package io.github.ititus.si.quantity.type;
+
+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.si.quantity.value.QuantityValue.of;
+import static io.github.ititus.si.unit.Units.CELSIUS;
+import static io.github.ititus.si.unit.Units.KELVIN;
+import static org.assertj.core.data.Percentage.withPercentage;
+
+class TemperatureTest {
+
+    @Test
+    void kelvinToCelsius() {
+        Quantity<ThermodynamicTemperature> kelvin = KELVIN.get(0);
+        Quantity<ThermodynamicTemperature> celsius = kelvin.convertTo(CELSIUS);
+
+        assertThat(celsius.getValue()).isCloseTo(of(-273.15), withPercentage(1.0));
+    }
+
+    @Test
+    void celsiusToKelvin() {
+        Quantity<ThermodynamicTemperature> celsius = CELSIUS.get(0);
+        Quantity<ThermodynamicTemperature> kelvin = celsius.convertTo(KELVIN);
+
+        assertThat(kelvin.getValue()).isCloseTo(of(273.15), withPercentage(1.0));
+    }
+}