Merge release 1.0.0 into stable branchHEADstable

See the tag 'v1.0.0' or the changelog for more information about this
release.

30 files changed, 1540 insertions, 1840 deletions

diff --git a/src/main/java/sevenUnits/ProgramInfo.java b/src/main/java/sevenUnits/ProgramInfo.java
index 9c23c49..e74a99b 100644
--- a/src/main/java/sevenUnits/ProgramInfo.java
+++ b/src/main/java/sevenUnits/ProgramInfo.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2021-2024 Adrien Hopkins
+ * Copyright (C) 2021-2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -20,15 +20,14 @@ import sevenUnits.utils.SemanticVersionNumber;
 
 /**
  * Information about 7Units
- * 
- * @since 0.3.1
+ *
  * @since 2021-06-28
+ * @since v0.3.1
  */
 public final class ProgramInfo {
-
-	/** The version number (0.5.0) */
+	/** The version number (1.0.0) */
 	public static final SemanticVersionNumber VERSION = SemanticVersionNumber
-			.stableVersion(0, 5, 0);
+			.stableVersion(1, 0, 0);
 
 	private ProgramInfo() {
 		// this class is only for static variables, you shouldn't be able to
diff --git a/src/main/java/sevenUnits/package-info.java b/src/main/java/sevenUnits/package-info.java
index 33b98fc..dc27e1f 100644
--- a/src/main/java/sevenUnits/package-info.java
+++ b/src/main/java/sevenUnits/package-info.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019-2021 Adrien Hopkins
+ * Copyright (C) 2019-2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -16,7 +16,7 @@
  */
 /**
  * A program that converts units.
- * 
+ *
  * @author Adrien Hopkins
  * @version v0.3.0
  * @since 2019-01-25
diff --git a/src/main/java/sevenUnits/unit/BaseDimension.java b/src/main/java/sevenUnits/unit/BaseDimension.java
index 3f1f75f..11b822e 100644
--- a/src/main/java/sevenUnits/unit/BaseDimension.java
+++ b/src/main/java/sevenUnits/unit/BaseDimension.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019, 2022 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -23,26 +23,26 @@ import sevenUnits.utils.Nameable;
 
 /**
  * A dimension that defines a {@code BaseUnit}
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public final class BaseDimension implements Nameable {
 	/**
 	 * Gets a {@code BaseDimension} with the provided name and symbol.
-	 * 
+	 *
 	 * @param name   name of dimension
 	 * @param symbol symbol used for dimension
 	 * @return dimension
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public static BaseDimension valueOf(final String name, final String symbol) {
 		return new BaseDimension(name, symbol);
 	}
 
-	/**
-	 * The name of the dimension.
-	 */
+	/** The name of the dimension. */
 	private final String name;
 	/**
 	 * The symbol used by the dimension. Symbols should be short, generally one
@@ -52,20 +52,19 @@ public final class BaseDimension implements Nameable {
 
 	/**
 	 * Creates the {@code BaseDimension}.
-	 * 
+	 *
 	 * @param name   name of unit
 	 * @param symbol symbol of unit
 	 * @throws NullPointerException if any argument is null
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private BaseDimension(final String name, final String symbol) {
 		this.name = Objects.requireNonNull(name, "name must not be null.");
 		this.symbol = Objects.requireNonNull(symbol, "symbol must not be null.");
 	}
 
-	/**
-	 * @since v0.4.0
-	 */
+	/** @since v0.4.0 */
 	@Override
 	public NameSymbol getNameSymbol() {
 		return NameSymbol.of(this.name, this.symbol);
diff --git a/src/main/java/sevenUnits/unit/BaseUnit.java b/src/main/java/sevenUnits/unit/BaseUnit.java
index fe85a7b..13e76d9 100644
--- a/src/main/java/sevenUnits/unit/BaseUnit.java
+++ b/src/main/java/sevenUnits/unit/BaseUnit.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -28,19 +28,21 @@ import sevenUnits.utils.NameSymbol;
  * Note that BaseUnits <b>must</b> have names and symbols. This is because they
  * are used for toString code. Therefore, the Optionals provided by
  * {@link #getPrimaryName} and {@link #getSymbol} will always contain a value.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public final class BaseUnit extends Unit {
 	/**
 	 * Gets a base unit from the dimension it measures, its name and its symbol.
-	 * 
+	 *
 	 * @param dimension dimension measured by this unit
 	 * @param name      name of unit
 	 * @param symbol    symbol of unit
 	 * @return base unit
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public static BaseUnit valueOf(final BaseDimension dimension,
 			final String name, final String symbol) {
@@ -49,31 +51,32 @@ public final class BaseUnit extends Unit {
 
 	/**
 	 * Gets a base unit from the dimension it measures, its name and its symbol.
-	 * 
-	 * @param dimension dimension measured by this unit
-	 * @param name      name of unit
-	 * @param symbol    symbol of unit
+	 *
+	 * @param dimension  dimension measured by this unit
+	 * @param name       name of unit
+	 * @param symbol     symbol of unit
+	 * @param otherNames other possible names of unit
 	 * @return base unit
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 */
 	public static BaseUnit valueOf(final BaseDimension dimension,
 			final String name, final String symbol, final Set<String> otherNames) {
 		return new BaseUnit(dimension, name, symbol, otherNames);
 	}
 
-	/**
-	 * The dimension measured by this base unit.
-	 */
+	/** The dimension measured by this base unit. */
 	private final BaseDimension dimension;
 
 	/**
 	 * Creates the {@code BaseUnit}.
-	 * 
+	 *
 	 * @param dimension   dimension of unit
 	 * @param primaryName name of unit
 	 * @param symbol      symbol of unit
 	 * @throws NullPointerException if any argument is null
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private BaseUnit(final BaseDimension dimension, final String primaryName,
 			final String symbol, final Set<String> otherNames) {
@@ -86,9 +89,10 @@ public final class BaseUnit extends Unit {
 	 * Returns a {@code LinearUnit} with this unit as a base and a conversion
 	 * factor of 1. This operation must be done in order to allow units to be
 	 * created with operations.
-	 * 
+	 *
 	 * @return this unit as a {@code LinearUnit}
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public LinearUnit asLinearUnit() {
 		return LinearUnit.valueOf(this.getBase(), 1);
@@ -107,8 +111,9 @@ public final class BaseUnit extends Unit {
 	/**
 	 * @return dimension
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
-	public final BaseDimension getBaseDimension() {
+	public BaseDimension getBaseDimension() {
 		return this.dimension;
 	}
 
diff --git a/src/main/java/sevenUnits/unit/BritishImperial.java b/src/main/java/sevenUnits/unit/BritishImperial.java
index 69a3c05..408e9e8 100644
--- a/src/main/java/sevenUnits/unit/BritishImperial.java
+++ b/src/main/java/sevenUnits/unit/BritishImperial.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -20,16 +20,21 @@ import sevenUnits.utils.NameSymbol;
 
 /**
  * A static utility class that contains units in the British Imperial system.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-21
+ * @since v0.3.0
  */
+// this class is just constants, most of which are obvious from the variable name
+// so no need to check for missing values
+@SuppressWarnings("javadoc")
 public final class BritishImperial {
 	/**
 	 * Imperial units that measure area
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Area {
 		public static final LinearUnit SQUARE_FOOT = Length.FOOT.toExponent(2);
@@ -42,9 +47,10 @@ public final class BritishImperial {
 
 	/**
 	 * Imperial units that measure length
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-28
+	 * @since v0.3.0
 	 */
 	public static final class Length {
 		/**
@@ -55,11 +61,18 @@ public final class BritishImperial {
 		public static final LinearUnit FOOT = YARD.dividedBy(3);
 		public static final LinearUnit INCH = FOOT.dividedBy(12);
 		public static final LinearUnit THOU = INCH.dividedBy(1000);
+		/** A chain, equal to 22 yards. */
 		public static final LinearUnit CHAIN = YARD.times(22);
+		/** A furlong, equal to 10 chains or 220 yards. */
 		public static final LinearUnit FURLONG = CHAIN.times(10);
+		/** A mile, equal to 8 furlongs or 1760 yards. */
 		public static final LinearUnit MILE = FURLONG.times(8);
+		/** A league, equal to 3 miles. */
 		public static final LinearUnit LEAGUE = MILE.times(3);
 
+		/**
+		 * A nautical mile, around 1 arcminute around the Earth's circumference.
+		 */
 		public static final LinearUnit NAUTICAL_MILE = Metric.METRE.times(1852);
 		public static final LinearUnit CABLE = NAUTICAL_MILE.dividedBy(10);
 		public static final LinearUnit FATHOM = CABLE.dividedBy(100);
@@ -70,9 +83,10 @@ public final class BritishImperial {
 
 	/**
 	 * British Imperial units that measure mass.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Mass {
 		public static final LinearUnit POUND = Metric.GRAM.times(453.59237);
@@ -88,9 +102,10 @@ public final class BritishImperial {
 
 	/**
 	 * British Imperial units that measure volume
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Volume {
 		public static final LinearUnit FLUID_OUNCE = Metric.LITRE
diff --git a/src/main/java/sevenUnits/unit/FunctionalUnit.java b/src/main/java/sevenUnits/unit/FunctionalUnit.java
index 6de446f..1d55b42 100644
--- a/src/main/java/sevenUnits/unit/FunctionalUnit.java
+++ b/src/main/java/sevenUnits/unit/FunctionalUnit.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -24,30 +24,33 @@ import sevenUnits.utils.ObjectProduct;
 
 /**
  * A unit that uses functional objects to convert to and from its base.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-05-22
+ * @since v0.3.0
  */
 final class FunctionalUnit extends Unit {
 	/**
 	 * A function that accepts a value expressed in the unit's base and returns
 	 * that value expressed in this unit.
-	 * 
+	 *
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 */
 	private final DoubleUnaryOperator converterFrom;
 
 	/**
 	 * A function that accepts a value expressed in the unit and returns that
 	 * value expressed in the unit's base.
-	 * 
+	 *
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 */
 	private final DoubleUnaryOperator converterTo;
 
 	/**
 	 * Creates the {@code FunctionalUnit}.
-	 * 
+	 *
 	 * @param base          unit's base
 	 * @param converterFrom function that accepts a value expressed in the unit's
 	 *                      base and returns that value expressed in this unit.
@@ -55,6 +58,7 @@ final class FunctionalUnit extends Unit {
 	 *                      and returns that value expressed in the unit's base.
 	 * @throws NullPointerException if any argument is null
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 */
 	public FunctionalUnit(final ObjectProduct<BaseUnit> base,
 			final DoubleUnaryOperator converterFrom,
@@ -68,14 +72,16 @@ final class FunctionalUnit extends Unit {
 
 	/**
 	 * Creates the {@code FunctionalUnit}.
-	 * 
+	 *
 	 * @param base          unit's base
 	 * @param converterFrom function that accepts a value expressed in the unit's
 	 *                      base and returns that value expressed in this unit.
 	 * @param converterTo   function that accepts a value expressed in the unit
 	 *                      and returns that value expressed in the unit's base.
+	 * @param ns            name and symbol of resulting unit
 	 * @throws NullPointerException if any argument is null
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 */
 	public FunctionalUnit(final ObjectProduct<BaseUnit> base,
 			final DoubleUnaryOperator converterFrom,
@@ -89,7 +95,7 @@ final class FunctionalUnit extends Unit {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses {@code converterFrom} to convert.
 	 */
 	@Override
@@ -99,7 +105,7 @@ final class FunctionalUnit extends Unit {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses {@code converterTo} to convert.
 	 */
 	@Override
diff --git a/src/main/java/sevenUnits/unit/FunctionalUnitlike.java b/src/main/java/sevenUnits/unit/FunctionalUnitlike.java
deleted file mode 100644
index e9b4d1f..0000000
--- a/src/main/java/sevenUnits/unit/FunctionalUnitlike.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * Copyright (C) 2020 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package sevenUnits.unit;
-
-import java.util.function.DoubleFunction;
-import java.util.function.ToDoubleFunction;
-
-import sevenUnits.utils.NameSymbol;
-import sevenUnits.utils.ObjectProduct;
-
-/**
- * A unitlike form that converts using two conversion functions.
- *
- * @since 2020-09-07
- */
-final class FunctionalUnitlike<V> extends Unitlike<V> {
-	/**
-	 * A function that accepts a value in the unitlike form's base and returns a
-	 * value in the unitlike form.
-	 * 
-	 * @since 2020-09-07
-	 */
-	private final DoubleFunction<V> converterFrom;
-
-	/**
-	 * A function that accepts a value in the unitlike form and returns a value
-	 * in the unitlike form's base.
-	 */
-	private final ToDoubleFunction<V> converterTo;
-
-	/**
-	 * Creates the {@code FunctionalUnitlike}.
-	 * 
-	 * @param base          unitlike form's base
-	 * @param converterFrom function that accepts a value in the unitlike form's
-	 *                      base and returns a value in the unitlike form.
-	 * @param converterTo   function that accepts a value in the unitlike form
-	 *                      and returns a value in the unitlike form's base.
-	 * @throws NullPointerException if any argument is null
-	 * @since 2019-05-22
-	 */
-	protected FunctionalUnitlike(ObjectProduct<BaseUnit> unitBase, NameSymbol ns,
-			DoubleFunction<V> converterFrom, ToDoubleFunction<V> converterTo) {
-		super(unitBase, ns);
-		this.converterFrom = converterFrom;
-		this.converterTo = converterTo;
-	}
-
-	@Override
-	protected V convertFromBase(double value) {
-		return this.converterFrom.apply(value);
-	}
-
-	@Override
-	protected double convertToBase(V value) {
-		return this.converterTo.applyAsDouble(value);
-	}
-
-}
diff --git a/src/main/java/sevenUnits/unit/LinearUnit.java b/src/main/java/sevenUnits/unit/LinearUnit.java
index 6489229..85f6dd9 100644
--- a/src/main/java/sevenUnits/unit/LinearUnit.java
+++ b/src/main/java/sevenUnits/unit/LinearUnit.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -26,19 +26,21 @@ import sevenUnits.utils.UncertainDouble;
 /**
  * A unit that can be expressed as a product of its base and a number. For
  * example, kilometres, inches and pounds.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public final class LinearUnit extends Unit {
 	/**
 	 * Gets a {@code LinearUnit} from a unit and a value. For example, converts
 	 * '59 °F' to a linear unit with the value of '288.15 K'
-	 * 
+	 *
 	 * @param unit  unit to convert
 	 * @param value value to convert
 	 * @return value expressed as a {@code LinearUnit}
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if unit is null
 	 */
 	public static LinearUnit fromUnitValue(final Unit unit, final double value) {
@@ -50,12 +52,13 @@ public final class LinearUnit extends Unit {
 	/**
 	 * Gets a {@code LinearUnit} from a unit and a value. For example, converts
 	 * '59 °F' to a linear unit with the value of '288.15 K'
-	 * 
+	 *
 	 * @param unit  unit to convert
 	 * @param value value to convert
 	 * @param ns    name(s) and symbol of unit
 	 * @return value expressed as a {@code LinearUnit}
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if unit or ns is null
 	 */
 	public static LinearUnit fromUnitValue(final Unit unit, final double value,
@@ -66,32 +69,26 @@ public final class LinearUnit extends Unit {
 	}
 
 	/**
+	 * @param unit unit to get base version of
 	 * @return the base unit associated with {@code unit}, as a
 	 *         {@code LinearUnit}.
 	 * @since 2020-10-02
+	 * @since v0.3.0
 	 */
 	public static LinearUnit getBase(final Unit unit) {
 		return new LinearUnit(unit.getBase(), 1, NameSymbol.EMPTY);
 	}
 
 	/**
-	 * @return the base unit associated with {@code unitlike}, as a
-	 *         {@code LinearUnit}.
-	 * @since 2020-10-02
-	 */
-	public static LinearUnit getBase(final Unitlike<?> unit) {
-		return new LinearUnit(unit.getBase(), 1, NameSymbol.EMPTY);
-	}
-
-	/**
 	 * Gets a {@code LinearUnit} from a unit base and a conversion factor. In
 	 * other words, gets the product of {@code unitBase} and
 	 * {@code conversionFactor}, expressed as a {@code LinearUnit}.
-	 * 
+	 *
 	 * @param unitBase         unit base to multiply by
 	 * @param conversionFactor number to multiply base by
 	 * @return product of base and conversion factor
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if unitBase is null
 	 */
 	public static LinearUnit valueOf(final ObjectProduct<BaseUnit> unitBase,
@@ -103,12 +100,13 @@ public final class LinearUnit extends Unit {
 	 * Gets a {@code LinearUnit} from a unit base and a conversion factor. In
 	 * other words, gets the product of {@code unitBase} and
 	 * {@code conversionFactor}, expressed as a {@code LinearUnit}.
-	 * 
+	 *
 	 * @param unitBase         unit base to multiply by
 	 * @param conversionFactor number to multiply base by
 	 * @param ns               name(s) and symbol of unit
 	 * @return product of base and conversion factor
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if unitBase is null
 	 */
 	public static LinearUnit valueOf(final ObjectProduct<BaseUnit> unitBase,
@@ -118,21 +116,23 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * The value of this unit as represented in its base form. Mathematically,
-	 * 
+	 *
 	 * <pre>
 	 * this = conversionFactor * getBase()
 	 * </pre>
-	 * 
+	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private final double conversionFactor;
 
 	/**
 	 * Creates the {@code LinearUnit}.
-	 * 
+	 *
 	 * @param unitBase         base of linear unit
 	 * @param conversionFactor conversion factor between base and unit
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private LinearUnit(final ObjectProduct<BaseUnit> unitBase,
 			final double conversionFactor, final NameSymbol ns) {
@@ -142,7 +142,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Converts by dividing by {@code conversionFactor}
 	 */
 	@Override
@@ -153,11 +153,12 @@ public final class LinearUnit extends Unit {
 	/**
 	 * Converts an {@code UncertainDouble} value expressed in this unit to an
 	 * {@code UncertainValue} value expressed in {@code other}.
-	 * 
+	 *
 	 * @param other unit to convert to
 	 * @param value value to convert
 	 * @return converted value
 	 * @since 2019-09-07
+	 * @since v0.3.0
 	 * @throws IllegalArgumentException if {@code other} is incompatible for
 	 *                                  conversion with this unit (as tested by
 	 *                                  {@link Unit#canConvertTo}).
@@ -169,15 +170,14 @@ public final class LinearUnit extends Unit {
 		if (this.canConvertTo(other))
 			return value.timesExact(
 					this.getConversionFactor() / other.getConversionFactor());
-		else
-			throw new IllegalArgumentException(
-					String.format("Cannot convert from %s to %s.", this, other));
+		throw new IllegalArgumentException(
+				String.format("Cannot convert from %s to %s.", this, other));
 
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Converts by multiplying by {@code conversionFactor}
 	 */
 	@Override
@@ -187,8 +187,9 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Converts an {@code UncertainDouble} to the base unit.
-	 * 
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	UncertainDouble convertToBase(final UncertainDouble value) {
 		return value.timesExact(this.getConversionFactor());
@@ -196,7 +197,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Divides this unit by a scalar.
-	 * 
+	 *
 	 * @param divisor scalar to divide by
 	 * @return quotient
 	 * @since 2018-12-23
@@ -208,7 +209,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Returns the quotient of this unit and another.
-	 * 
+	 *
 	 * @param divisor unit to divide by
 	 * @return quotient of two units
 	 * @throws NullPointerException if {@code divisor} is null
@@ -219,22 +220,35 @@ public final class LinearUnit extends Unit {
 		Objects.requireNonNull(divisor, "other must not be null");
 
 		// divide the units
-		final ObjectProduct<BaseUnit> base = this.getBase()
-				.dividedBy(divisor.getBase());
+		final var base = this.getBase().dividedBy(divisor.getBase());
 		return valueOf(base,
 				this.getConversionFactor() / divisor.getConversionFactor());
 	}
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses the base and conversion factor of units to test for equality.
 	 */
 	@Override
 	public boolean equals(final Object obj) {
 		if (!(obj instanceof LinearUnit))
 			return false;
-		final LinearUnit other = (LinearUnit) obj;
+		final var other = (LinearUnit) obj;
+		return Objects.equals(this.getBase(), other.getBase())
+				&& Double.compare(this.getConversionFactor(),
+						other.getConversionFactor()) == 0;
+	}
+
+	/**
+	 * @param other unit to test equality with
+	 * @return true iff this unit and other are equal, ignoring small differences
+	 *         caused by floating-point error.
+	 *
+	 * @apiNote This method is not transitive, so it cannot be used as an equals
+	 *          method.
+	 */
+	public boolean equalsApproximately(final LinearUnit other) {
 		return Objects.equals(this.getBase(), other.getBase())
 				&& DecimalComparison.equals(this.getConversionFactor(),
 						other.getConversionFactor());
@@ -243,6 +257,7 @@ public final class LinearUnit extends Unit {
 	/**
 	 * @return conversion factor
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public double getConversionFactor() {
 		return this.conversionFactor;
@@ -250,13 +265,13 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses the base and conversion factor to compute a hash code.
 	 */
 	@Override
 	public int hashCode() {
 		return 31 * this.getBase().hashCode()
-				+ DecimalComparison.hash(this.getConversionFactor());
+				+ Double.hashCode(this.getConversionFactor());
 	}
 
 	/**
@@ -264,6 +279,7 @@ public final class LinearUnit extends Unit {
 	 *         is a {@code BaseUnit b} where
 	 *         {@code b.asLinearUnit().equals(this)} returns {@code true}.)
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public boolean isBase() {
 		return this.isCoherent() && this.getBase().isSingleObject();
@@ -272,6 +288,7 @@ public final class LinearUnit extends Unit {
 	/**
 	 * @return whether this unit is coherent (i.e. has conversion factor 1)
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public boolean isCoherent() {
 		return this.getConversionFactor() == 1;
@@ -285,7 +302,7 @@ public final class LinearUnit extends Unit {
 	 * does not meet this condition, an {@code IllegalArgumentException} will be
 	 * thrown.
 	 * </p>
-	 * 
+	 *
 	 * @param subtrahend unit to subtract
 	 * @return difference of units
 	 * @throws IllegalArgumentException if {@code subtrahend} is not compatible
@@ -316,7 +333,7 @@ public final class LinearUnit extends Unit {
 	 * does not meet this condition, an {@code IllegalArgumentException} will be
 	 * thrown.
 	 * </p>
-	 * 
+	 *
 	 * @param addend unit to add
 	 * @return sum of units
 	 * @throws IllegalArgumentException if {@code addend} is not compatible for
@@ -341,7 +358,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Multiplies this unit by a scalar.
-	 * 
+	 *
 	 * @param multiplier scalar to multiply by
 	 * @return product
 	 * @since 2018-12-23
@@ -353,7 +370,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Returns the product of this unit and another.
-	 * 
+	 *
 	 * @param multiplier unit to multiply by
 	 * @return product of two units
 	 * @throws NullPointerException if {@code multiplier} is null
@@ -364,8 +381,7 @@ public final class LinearUnit extends Unit {
 		Objects.requireNonNull(multiplier, "other must not be null");
 
 		// multiply the units
-		final ObjectProduct<BaseUnit> base = this.getBase()
-				.times(multiplier.getBase());
+		final var base = this.getBase().times(multiplier.getBase());
 		return valueOf(base,
 				this.getConversionFactor() * multiplier.getConversionFactor());
 	}
@@ -379,7 +395,7 @@ public final class LinearUnit extends Unit {
 
 	/**
 	 * Returns this unit but to an exponent.
-	 * 
+	 *
 	 * @param exponent exponent to exponentiate unit to
 	 * @return exponentiated unit
 	 * @since 2019-01-15
@@ -390,6 +406,21 @@ public final class LinearUnit extends Unit {
 				Math.pow(this.conversionFactor, exponent));
 	}
 
+	/**
+	 * Returns this unit to an exponent, rounding the resulting dimensions to the
+	 * nearest integer.
+	 *
+	 * @param exponent exponent to raise unit to
+	 * @return result of rounded exponentation
+	 * @since 2024-08-22
+	 * @since v1.0.0
+	 * @see ObjectProduct#toExponentRounded
+	 */
+	public LinearUnit toExponentRounded(final double exponent) {
+		return valueOf(this.getBase().toExponentRounded(exponent),
+				Math.pow(this.conversionFactor, exponent));
+	}
+
 	@Override
 	public LinearUnit withName(final NameSymbol ns) {
 		return valueOf(this.getBase(), this.getConversionFactor(), ns);
@@ -404,7 +435,7 @@ public final class LinearUnit extends Unit {
 	 * have a symbol. <br>
 	 * This method ignores alternate names of both this unit and the provided
 	 * prefix.
-	 * 
+	 *
 	 * @param prefix prefix to apply
 	 * @return unit with prefix
 	 * @since 2019-03-18
@@ -412,7 +443,7 @@ public final class LinearUnit extends Unit {
 	 * @throws NullPointerException if prefix is null
 	 */
 	public LinearUnit withPrefix(final UnitPrefix prefix) {
-		final LinearUnit unit = this.times(prefix.getMultiplier());
+		final var unit = this.times(prefix.getMultiplier());
 
 		// create new name and symbol, if possible
 		final String name;
diff --git a/src/main/java/sevenUnits/unit/LinearUnitValue.java b/src/main/java/sevenUnits/unit/LinearUnitValue.java
index 3a9428b..ce60e3b 100644
--- a/src/main/java/sevenUnits/unit/LinearUnitValue.java
+++ b/src/main/java/sevenUnits/unit/LinearUnitValue.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -17,33 +17,38 @@
 package sevenUnits.unit;
 
 import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 
 import sevenUnits.utils.DecimalComparison;
+import sevenUnits.utils.ObjectProduct;
 import sevenUnits.utils.UncertainDouble;
 
 /**
  * A possibly uncertain value expressed in a linear unit.
- * 
+ *
  * Unless otherwise indicated, all methods in this class throw a
  * {@code NullPointerException} when an argument is null.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2020-07-26
+ * @since v0.3.0
  */
 public final class LinearUnitValue {
+	/** The value 1 as a LinearUnitValue. */
 	public static final LinearUnitValue ONE = getExact(Metric.ONE, 1);
 
 	/**
 	 * Gets an exact {@code LinearUnitValue}
-	 * 
+	 *
 	 * @param unit  unit to express with
 	 * @param value value to express
 	 * @return exact {@code LinearUnitValue} instance
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
-	public static final LinearUnitValue getExact(final LinearUnit unit,
+	public static LinearUnitValue getExact(final LinearUnit unit,
 			final double value) {
 		return new LinearUnitValue(
 				Objects.requireNonNull(unit, "unit must not be null"),
@@ -52,14 +57,14 @@ public final class LinearUnitValue {
 
 	/**
 	 * Gets an uncertain {@code LinearUnitValue}
-	 * 
-	 * @param unit        unit to express with
-	 * @param value       value to express
-	 * @param uncertainty absolute uncertainty of value
+	 *
+	 * @param unit  unit to express with
+	 * @param value value to express
 	 * @return uncertain {@code LinearUnitValue} instance
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
-	public static final LinearUnitValue of(final LinearUnit unit,
+	public static LinearUnitValue of(final LinearUnit unit,
 			final UncertainDouble value) {
 		return new LinearUnitValue(
 				Objects.requireNonNull(unit, "unit must not be null"),
@@ -74,6 +79,7 @@ public final class LinearUnitValue {
 	 * @param unit  unit to express as
 	 * @param value value to express
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
 	private LinearUnitValue(final LinearUnit unit, final UncertainDouble value) {
 		this.unit = unit;
@@ -84,8 +90,9 @@ public final class LinearUnitValue {
 	 * @return this value as a {@code UnitValue}. All uncertainty information is
 	 *         removed from the returned value.
 	 * @since 2020-08-04
+	 * @since v0.3.0
 	 */
-	public final UnitValue asUnitValue() {
+	public UnitValue asUnitValue() {
 		return UnitValue.of(this.unit, this.value.value());
 	}
 
@@ -93,29 +100,68 @@ public final class LinearUnitValue {
 	 * @param other a {@code LinearUnit}
 	 * @return true iff this value can be represented with {@code other}.
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
-	public final boolean canConvertTo(final LinearUnit other) {
+	public boolean canConvertTo(final LinearUnit other) {
 		return this.unit.canConvertTo(other);
 	}
 
 	/**
 	 * Returns a LinearUnitValue that represents the same value expressed in a
 	 * different unit
-	 * 
+	 *
 	 * @param other new unit to express value in
 	 * @return value expressed in {@code other}
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
-	public final LinearUnitValue convertTo(final LinearUnit other) {
+	public LinearUnitValue convertTo(final LinearUnit other) {
 		return LinearUnitValue.of(other, this.unit.convertTo(other, this.value));
 	}
 
 	/**
+	 * Convert a LinearUnitValue to a sum of multiple units, where all but the
+	 * last have exact integer values.
+	 *
+	 * @param others units to convert to
+	 * @return terms of the sum
+	 * @throws IllegalArgumentException if no units are provided or units
+	 *                                  provided have incompatible bases
+	 * @since 2024-08-15
+	 * @since v1.0.0
+	 */
+	public List<LinearUnitValue> convertToMultiple(
+			final List<LinearUnit> others) {
+		if (others.size() < 1)
+			throw new IllegalArgumentException("Must have at least one unit");
+		for (final LinearUnit unit : others) {
+			if (!Objects.equals(this.unit.getBase(), unit.getBase()))
+				throw new IllegalArgumentException(
+						"All provided units must have the same base as the value.");
+		}
+
+		var remaining = this;
+		final List<LinearUnitValue> values = new ArrayList<>(others.size());
+		for (final LinearUnit unit : others.subList(0, others.size() - 1)) {
+			final var remainingInUnit = remaining.convertTo(unit);
+			final var value = getExact(unit,
+					Math.floor(remainingInUnit.getValueExact() + 1e-12));
+			values.add(value);
+			remaining = remaining.minus(value);
+		}
+
+		final var lastValue = remaining.convertTo(others.get(others.size() - 1));
+		values.add(lastValue);
+		return values;
+	}
+
+	/**
 	 * Divides this value by a scalar
-	 * 
+	 *
 	 * @param divisor value to divide by
 	 * @return multiplied value
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue dividedBy(final double divisor) {
 		return LinearUnitValue.of(this.unit, this.value.dividedByExact(divisor));
@@ -123,10 +169,11 @@ public final class LinearUnitValue {
 
 	/**
 	 * Divides this value by another value
-	 * 
+	 *
 	 * @param divisor value to multiply by
 	 * @return quotient
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue dividedBy(final LinearUnitValue divisor) {
 		return LinearUnitValue.of(this.unit.dividedBy(divisor.unit),
@@ -137,15 +184,16 @@ public final class LinearUnitValue {
 	 * Returns true if this and obj represent the same value, regardless of
 	 * whether or not they are expressed in the same unit. So (1000 m).equals(1
 	 * km) returns true.
-	 * 
+	 *
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 * @see #equals(Object, boolean)
 	 */
 	@Override
 	public boolean equals(final Object obj) {
 		if (!(obj instanceof LinearUnitValue))
 			return false;
-		final LinearUnitValue other = (LinearUnitValue) obj;
+		final var other = (LinearUnitValue) obj;
 		return Objects.equals(this.unit.getBase(), other.unit.getBase())
 				&& this.unit.convertToBase(this.value)
 						.equals(other.unit.convertToBase(other.value));
@@ -155,18 +203,22 @@ public final class LinearUnitValue {
 	 * Returns true if this and obj represent the same value, regardless of
 	 * whether or not they are expressed in the same unit. So (1000 m).equals(1
 	 * km) returns true.
-	 * <p>
-	 * If avoidFPErrors is true, this method will attempt to avoid floating-point
-	 * errors, at the cost of not always being transitive.
-	 * 
+	 *
+	 * @param obj           object to test equality with
+	 * @param avoidFPErrors if true, this method will attempt to avoid
+	 *                      floating-point errors, at the cost of not always
+	 *                      being transitive.
+	 * @return true iff this and obj are equal
+	 *
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public boolean equals(final Object obj, final boolean avoidFPErrors) {
 		if (!avoidFPErrors)
 			return this.equals(obj);
 		if (!(obj instanceof LinearUnitValue))
 			return false;
-		final LinearUnitValue other = (LinearUnitValue) obj;
+		final var other = (LinearUnitValue) obj;
 		return Objects.equals(this.unit.getBase(), other.unit.getBase())
 				&& DecimalComparison.equals(this.unit.convertToBase(this.value),
 						other.unit.convertToBase(other.value));
@@ -175,16 +227,17 @@ public final class LinearUnitValue {
 	/**
 	 * @param other another {@code LinearUnitValue}
 	 * @return true iff this and other are within each other's uncertainty range
-	 * 
+	 *
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
 	public boolean equivalent(final LinearUnitValue other) {
 		if (other == null
 				|| !Objects.equals(this.unit.getBase(), other.unit.getBase()))
 			return false;
-		final LinearUnit base = LinearUnit.valueOf(this.unit.getBase(), 1);
-		final LinearUnitValue thisBase = this.convertTo(base);
-		final LinearUnitValue otherBase = other.convertTo(base);
+		final var base = LinearUnit.valueOf(this.unit.getBase(), 1);
+		final var thisBase = this.convertTo(base);
+		final var otherBase = other.convertTo(base);
 
 		return thisBase.value.equivalent(otherBase.value);
 	}
@@ -192,24 +245,27 @@ public final class LinearUnitValue {
 	/**
 	 * @return the unit
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final LinearUnit getUnit() {
+	public LinearUnit getUnit() {
 		return this.unit;
 	}
 
 	/**
 	 * @return the value
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble getValue() {
+	public UncertainDouble getValue() {
 		return this.value;
 	}
 
 	/**
 	 * @return the exact value
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final double getValueExact() {
+	public double getValueExact() {
 		return this.value.value();
 	}
 
@@ -222,12 +278,13 @@ public final class LinearUnitValue {
 	/**
 	 * Returns the difference of this value and another, expressed in this
 	 * value's unit
-	 * 
+	 *
 	 * @param subtrahend value to subtract
 	 * @return difference of values
 	 * @throws IllegalArgumentException if {@code subtrahend} has a unit that is
 	 *                                  not compatible for addition
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue minus(final LinearUnitValue subtrahend) {
 		Objects.requireNonNull(subtrahend, "subtrahend may not be null");
@@ -237,19 +294,20 @@ public final class LinearUnitValue {
 					"Incompatible units for subtraction \"%s\" and \"%s\".",
 					this.unit, subtrahend.unit));
 
-		final LinearUnitValue otherConverted = subtrahend.convertTo(this.unit);
+		final var otherConverted = subtrahend.convertTo(this.unit);
 		return LinearUnitValue.of(this.unit,
 				this.value.minus(otherConverted.value));
 	}
 
 	/**
 	 * Returns the sum of this value and another, expressed in this value's unit
-	 * 
+	 *
 	 * @param addend value to add
 	 * @return sum of values
 	 * @throws IllegalArgumentException if {@code addend} has a unit that is not
 	 *                                  compatible for addition
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue plus(final LinearUnitValue addend) {
 		Objects.requireNonNull(addend, "addend may not be null");
@@ -259,17 +317,18 @@ public final class LinearUnitValue {
 					"Incompatible units for addition \"%s\" and \"%s\".", this.unit,
 					addend.unit));
 
-		final LinearUnitValue otherConverted = addend.convertTo(this.unit);
+		final var otherConverted = addend.convertTo(this.unit);
 		return LinearUnitValue.of(this.unit,
 				this.value.plus(otherConverted.value));
 	}
 
 	/**
 	 * Multiplies this value by a scalar
-	 * 
+	 *
 	 * @param multiplier value to multiply by
 	 * @return multiplied value
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue times(final double multiplier) {
 		return LinearUnitValue.of(this.unit, this.value.timesExact(multiplier));
@@ -277,10 +336,11 @@ public final class LinearUnitValue {
 
 	/**
 	 * Multiplies this value by another value
-	 * 
+	 *
 	 * @param multiplier value to multiply by
 	 * @return product
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue times(final LinearUnitValue multiplier) {
 		return LinearUnitValue.of(this.unit.times(multiplier.unit),
@@ -289,16 +349,32 @@ public final class LinearUnitValue {
 
 	/**
 	 * Raises a value to an exponent
-	 * 
+	 *
 	 * @param exponent exponent to raise to
 	 * @return result of exponentiation
 	 * @since 2020-07-28
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue toExponent(final int exponent) {
 		return LinearUnitValue.of(this.unit.toExponent(exponent),
 				this.value.toExponentExact(exponent));
 	}
 
+	/**
+	 * Raises this value to an exponent, rounding all dimensions to integers.
+	 *
+	 * @param exponent exponent to raise this value to
+	 * @return result of exponentation
+	 *
+	 * @since 2024-08-22
+	 * @since v1.0.0
+	 * @see ObjectProduct#toExponentRounded
+	 */
+	public LinearUnitValue toExponentRounded(final double exponent) {
+		return LinearUnitValue.of(this.unit.toExponentRounded(exponent),
+				this.value.toExponentExact(exponent));
+	}
+
 	@Override
 	public String toString() {
 		return this.toString(!this.value.isExact(), RoundingMode.HALF_EVEN);
@@ -313,23 +389,28 @@ public final class LinearUnitValue {
 	 * single numbers.
 	 * <p>
 	 * Non-exact values are rounded intelligently based on their uncertainty.
-	 * 
+	 *
+	 * @param showUncertainty whether to show the value's uncertainty
+	 * @param roundingMode    how to round numbers in this string
+	 * @return string representing this value
+	 *
 	 * @since 2020-07-26
+	 * @since v0.3.0
 	 */
 	public String toString(final boolean showUncertainty,
 			RoundingMode roundingMode) {
-		final Optional<String> primaryName = this.unit.getPrimaryName();
-		final Optional<String> symbol = this.unit.getSymbol();
-		final String chosenName = symbol.orElse(primaryName.orElse(null));
+		final var primaryName = this.unit.getPrimaryName();
+		final var symbol = this.unit.getSymbol();
+		final var chosenName = symbol.orElse(primaryName.orElse(null));
 
-		final UncertainDouble baseValue = this.unit.convertToBase(this.value);
+		final var baseValue = this.unit.convertToBase(this.value);
 
 		// get rounded strings
 		// if showUncertainty is true, add brackets around the string
-		final String valueString = (showUncertainty ? "(" : "")
+		final var valueString = (showUncertainty ? "(" : "")
 				+ this.value.toString(showUncertainty, roundingMode)
 				+ (showUncertainty ? ")" : "");
-		final String baseValueString = (showUncertainty ? "(" : "")
+		final var baseValueString = (showUncertainty ? "(" : "")
 				+ baseValue.toString(showUncertainty, roundingMode)
 				+ (showUncertainty ? ")" : "");
 
@@ -338,7 +419,6 @@ public final class LinearUnitValue {
 			return String.format("%s unnamed unit (= %s %s)", valueString,
 					baseValueString, this.unit.getBase()
 							.toString(unit -> unit.getSymbol().orElseThrow()));
-		else
-			return String.format("%s %s", valueString, chosenName);
+		return String.format("%s %s", valueString, chosenName);
 	}
 }
diff --git a/src/main/java/sevenUnits/unit/LoadingException.java b/src/main/java/sevenUnits/unit/LoadingException.java
new file mode 100644
index 0000000..2a75c99
--- /dev/null
+++ b/src/main/java/sevenUnits/unit/LoadingException.java
@@ -0,0 +1,122 @@
+/**
+ * Copyright (C) 2024, 2025 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package sevenUnits.unit;
+
+import java.nio.file.Path;
+import java.util.Optional;
+
+/**
+ * An exception that occurred when loading a file. This wrapper class adds more
+ * info about the error.
+ *
+ * @author Adrien Hopkins
+ * @since 2024-08-22
+ * @since v1.0.0
+ */
+public final class LoadingException extends RuntimeException {
+	/** The type of file that was being loaded. */
+	public enum FileType {
+		@SuppressWarnings("javadoc")
+		UNIT, @SuppressWarnings("javadoc")
+		DIMENSION
+	}
+
+	private static final long serialVersionUID = -8167971828216907607L;
+
+	private final long lineNumber;
+	private final String line;
+	private final Optional<Path> file;
+
+	private final FileType fileType;
+
+	private final RuntimeException problem;
+
+	/**
+	 * Create a LoadingException from some information, without a file.
+	 *
+	 * @param lineNumber line number error happened on
+	 * @param line       text of invalid line
+	 * @param fileType   type of file
+	 * @param problem    problem, as an Exception
+	 */
+	public LoadingException(long lineNumber, String line, FileType fileType,
+			RuntimeException problem) {
+		super(problem);
+		this.lineNumber = lineNumber;
+		this.line = line;
+		this.file = Optional.empty();
+		this.fileType = fileType;
+		this.problem = problem;
+	}
+
+	/**
+	 * Create a LoadingException from some information, with a file.
+	 *
+	 * @param lineNumber line number error happened on
+	 * @param line       text of invalid line
+	 * @param file       file error happened on
+	 * @param fileType   type of file
+	 * @param problem    problem, as an Exception
+	 */
+	public LoadingException(long lineNumber, String line, Path file,
+			FileType fileType, RuntimeException problem) {
+		super(problem);
+		this.lineNumber = lineNumber;
+		this.line = line;
+		this.file = Optional.of(file);
+		this.fileType = fileType;
+		this.problem = problem;
+	}
+
+	/** @return the file this error happened in, if there is one */
+	public Optional<Path> file() {
+		return this.file;
+	}
+
+	/** @return type of file that this error happened in */
+	public FileType fileType() {
+		return this.fileType;
+	}
+
+	@Override
+	public String getMessage() {
+		return this.file
+				.map(f -> String.format(
+						"Error parsing line %d of %s file '%s' (\"%s\"): %s",
+						this.lineNumber, this.fileType.toString().toLowerCase(), f,
+						this.line, this.problem))
+				.orElse(String.format(
+						"Error parsing line %d of %s stream (\"%s\"): %s",
+						this.lineNumber, this.fileType.toString().toLowerCase(),
+						this.line, this.problem));
+	}
+
+	/** @return text of line that caused this error */
+	public String line() {
+		return this.line;
+	}
+
+	/** @return number of line that caused this error */
+	public long lineNumber() {
+		return this.lineNumber;
+	}
+
+	/** @return the error, as an exception */
+	public RuntimeException problem() {
+		return this.problem;
+	}
+}
diff --git a/src/main/java/sevenUnits/unit/Metric.java b/src/main/java/sevenUnits/unit/Metric.java
index 7841987..e712dc3 100644
--- a/src/main/java/sevenUnits/unit/Metric.java
+++ b/src/main/java/sevenUnits/unit/Metric.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2018 Adrien Hopkins
+ * Copyright (C) 2018, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -24,19 +24,23 @@ import sevenUnits.utils.ObjectProduct;
 /**
  * All of the units, prefixes and dimensions that are used by the SI, as well as
  * some outside the SI.
- * 
+ *
  * <p>
  * This class does not include prefixed units. To obtain prefixed units, use
  * {@link LinearUnit#withPrefix}:
- * 
+ *
  * <pre>
  * LinearUnit KILOMETRE = SI.METRE.withPrefix(SI.KILO);
  * </pre>
- * 
- * 
+ *
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
+// this class is just constants, most of which are obvious from the variable name
+// so no need to check for missing values
+@SuppressWarnings("javadoc")
 public final class Metric {
 	/// dimensions used by SI units
 	// base dimensions, as BaseDimensions
@@ -67,8 +71,10 @@ public final class Metric {
 	}
 
 	/// base units of the SI
-	// suppressing warnings since these are the same object, but in a different
-	/// form (class)
+	// suppressing warnings since these are the same object,
+	// but in a different form (class)
+	// and because these objects are only used outside this class,
+	// where hiding is not a problem.
 	@SuppressWarnings("hiding")
 	public static final class BaseUnits {
 		public static final BaseUnit METRE = BaseUnit
@@ -101,9 +107,10 @@ public final class Metric {
 
 	/**
 	 * Constants that relate to the SI or other systems.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Constants {
 		public static final LinearUnit EARTH_GRAVITY = METRE.dividedBy(SECOND)
@@ -343,7 +350,7 @@ public final class Metric {
 			pr -> 0.5 * Math.log(pr), Np -> Math.exp(2 * Np))
 			.withName(NameSymbol.of("neper", "Np"));
 	public static final Unit BEL = Unit.fromConversionFunctions(ONE.getBase(),
-			pr -> Math.log10(pr), dB -> Math.pow(10, dB))
+			Math::log10, dB -> Math.pow(10, dB))
 			.withName(NameSymbol.of("bel", "B"));
 	public static final Unit DECIBEL = Unit
 			.fromConversionFunctions(ONE.getBase(), pr -> 10 * Math.log10(pr),
diff --git a/src/main/java/sevenUnits/unit/MultiUnit.java b/src/main/java/sevenUnits/unit/MultiUnit.java
deleted file mode 100644
index 950c547..0000000
--- a/src/main/java/sevenUnits/unit/MultiUnit.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/**
- * Copyright (C) 2020 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package sevenUnits.unit;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import sevenUnits.utils.NameSymbol;
-import sevenUnits.utils.ObjectProduct;
-
-/**
- * A combination of units, like "5 foot + 7 inch". All but the last units should
- * have a whole number value associated with them.
- *
- * @since 2020-10-02
- */
-public final class MultiUnit extends Unitlike<List<Double>> {
-	/**
-	 * Creates a {@code MultiUnit} from its units. It will not have a name or
-	 * symbol.
-	 *
-	 * @since 2020-10-03
-	 */
-	public static final MultiUnit of(LinearUnit... units) {
-		return of(Arrays.asList(units));
-	}
-
-	/**
-	 * Creates a {@code MultiUnit} from its units. It will not have a name or
-	 * symbol.
-	 *
-	 * @since 2020-10-03
-	 */
-	public static final MultiUnit of(List<LinearUnit> units) {
-		if (units.size() < 1)
-			throw new IllegalArgumentException("Must have at least one unit");
-		final ObjectProduct<BaseUnit> unitBase = units.get(0).getBase();
-		for (final LinearUnit unit : units) {
-			if (!unitBase.equals(unit.getBase()))
-				throw new IllegalArgumentException(
-						"All units must have the same base.");
-		}
-		return new MultiUnit(new ArrayList<>(units), unitBase, NameSymbol.EMPTY);
-	}
-
-	/**
-	 * The units that make up this value.
-	 */
-	private final List<LinearUnit> units;
-
-	/**
-	 * Creates a {@code MultiUnit}.
-	 *
-	 * @since 2020-10-03
-	 */
-	private MultiUnit(List<LinearUnit> units, ObjectProduct<BaseUnit> unitBase,
-			NameSymbol ns) {
-		super(unitBase, ns);
-		this.units = units;
-	}
-
-	@Override
-	protected List<Double> convertFromBase(double value) {
-		final List<Double> values = new ArrayList<>(this.units.size());
-		double temp = value;
-
-		for (final LinearUnit unit : this.units.subList(0,
-				this.units.size() - 1)) {
-			values.add(Math.floor(temp / unit.getConversionFactor()));
-			temp %= unit.getConversionFactor();
-		}
-
-		values.add(this.units.size() - 1,
-				this.units.get(this.units.size() - 1).convertFromBase(temp));
-
-		return values;
-	}
-
-	/**
-	 * Converts a value expressed in this unitlike form to a value expressed in
-	 * {@code other}.
-	 * 
-	 * @implSpec If conversion is possible, this implementation returns
-	 *           {@code other.convertFromBase(this.convertToBase(value))}.
-	 *           Therefore, overriding either of those methods will change the
-	 *           output of this method.
-	 * 
-	 * @param other unit to convert to
-	 * @param value value to convert
-	 * @return converted value
-	 * @since 2020-10-03
-	 * @throws IllegalArgumentException if {@code other} is incompatible for
-	 *                                  conversion with this unitlike form (as
-	 *                                  tested by {@link Unit#canConvertTo}).
-	 * @throws NullPointerException     if other is null
-	 */
-	public final <U extends Unitlike<V>, V> V convertTo(U other,
-			double... values) {
-		final List<Double> valueList = new ArrayList<>(values.length);
-		for (final double d : values) {
-			valueList.add(d);
-		}
-
-		return this.convertTo(other, valueList);
-	}
-
-	/**
-	 * Converts a value expressed in this unitlike form to a value expressed in
-	 * {@code other}.
-	 * 
-	 * @implSpec If conversion is possible, this implementation returns
-	 *           {@code other.convertFromBase(this.convertToBase(value))}.
-	 *           Therefore, overriding either of those methods will change the
-	 *           output of this method.
-	 * 
-	 * @param other unit to convert to
-	 * @param value value to convert
-	 * @return converted value
-	 * @since 2020-10-03
-	 * @throws IllegalArgumentException if {@code other} is incompatible for
-	 *                                  conversion with this unitlike form (as
-	 *                                  tested by {@link Unit#canConvertTo}).
-	 * @throws NullPointerException     if other is null
-	 */
-	public final double convertTo(Unit other, double... values) {
-		final List<Double> valueList = new ArrayList<>(values.length);
-		for (final double d : values) {
-			valueList.add(d);
-		}
-
-		return this.convertTo(other, valueList);
-	}
-
-	@Override
-	protected double convertToBase(List<Double> value) {
-		if (value.size() != this.units.size())
-			throw new IllegalArgumentException("Wrong number of values for "
-					+ this.units.size() + "-unit MultiUnit.");
-
-		double baseValue = 0;
-		for (int i = 0; i < this.units.size(); i++) {
-			baseValue += value.get(i) * this.units.get(i).getConversionFactor();
-		}
-		return baseValue;
-	}
-}
diff --git a/src/main/java/sevenUnits/unit/USCustomary.java b/src/main/java/sevenUnits/unit/USCustomary.java
index fce829e..ef12043 100644
--- a/src/main/java/sevenUnits/unit/USCustomary.java
+++ b/src/main/java/sevenUnits/unit/USCustomary.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -18,16 +18,21 @@ package sevenUnits.unit;
 
 /**
  * A static utility class that contains units in the US Customary system.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-21
+ * @since v0.3.0
  */
+// this class is just constants, most of which are obvious from the variable name
+// so no need to check for missing values
+@SuppressWarnings("javadoc")
 public final class USCustomary {
 	/**
 	 * US Customary units that measure area
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Area {
 		public static final LinearUnit SQUARE_SURVEY_FOOT = Length.SURVEY_FOOT
@@ -43,9 +48,10 @@ public final class USCustomary {
 
 	/**
 	 * US Customary units that measure length
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-28
+	 * @since v0.3.0
 	 */
 	public static final class Length {
 		public static final LinearUnit FOOT = BritishImperial.Length.FOOT;
@@ -73,9 +79,10 @@ public final class USCustomary {
 
 	/**
 	 * mass units
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Mass {
 		public static final LinearUnit GRAIN = BritishImperial.Mass.GRAIN;
@@ -93,9 +100,10 @@ public final class USCustomary {
 
 	/**
 	 * Volume units
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-11-08
+	 * @since v0.3.0
 	 */
 	public static final class Volume {
 		public static final LinearUnit CUBIC_INCH = Length.INCH.toExponent(3);
diff --git a/src/main/java/sevenUnits/unit/Unit.java b/src/main/java/sevenUnits/unit/Unit.java
index 59e928a..40e6e0d 100644
--- a/src/main/java/sevenUnits/unit/Unit.java
+++ b/src/main/java/sevenUnits/unit/Unit.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -28,22 +28,23 @@ import sevenUnits.utils.ObjectProduct;
 
 /**
  * A unit that is composed of base units.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public abstract class Unit implements Nameable {
 	/**
 	 * Returns a unit from its base and the functions it uses to convert to and
 	 * from its base.
-	 * 
+	 *
 	 * <p>
 	 * For example, to get a unit representing the degree Celsius, the following
 	 * code can be used:
-	 * 
+	 *
 	 * {@code Unit.fromConversionFunctions(SI.KELVIN, tempK -> tempK - 273.15, tempC -> tempC + 273.15);}
 	 * </p>
-	 * 
+	 *
 	 * @param base          unit's base
 	 * @param converterFrom function that accepts a value expressed in the unit's
 	 *                      base and returns that value expressed in this unit.
@@ -51,6 +52,7 @@ public abstract class Unit implements Nameable {
 	 *                      and returns that value expressed in the unit's base.
 	 * @return a unit that uses the provided functions to convert.
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 * @throws NullPointerException if any argument is null
 	 */
 	public static final Unit fromConversionFunctions(
@@ -63,14 +65,14 @@ public abstract class Unit implements Nameable {
 	/**
 	 * Returns a unit from its base and the functions it uses to convert to and
 	 * from its base.
-	 * 
+	 *
 	 * <p>
 	 * For example, to get a unit representing the degree Celsius, the following
 	 * code can be used:
-	 * 
+	 *
 	 * {@code Unit.fromConversionFunctions(SI.KELVIN, tempK -> tempK - 273.15, tempC -> tempC + 273.15);}
 	 * </p>
-	 * 
+	 *
 	 * @param base          unit's base
 	 * @param converterFrom function that accepts a value expressed in the unit's
 	 *                      base and returns that value expressed in this unit.
@@ -79,6 +81,7 @@ public abstract class Unit implements Nameable {
 	 * @param ns            names and symbol of unit
 	 * @return a unit that uses the provided functions to convert.
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 * @throws NullPointerException if any argument is null
 	 */
 	public static final Unit fromConversionFunctions(
@@ -90,15 +93,17 @@ public abstract class Unit implements Nameable {
 
 	/**
 	 * The combination of units that this unit is based on.
-	 * 
+	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private final ObjectProduct<BaseUnit> unitBase;
 
 	/**
 	 * This unit's name(s) and symbol
-	 * 
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	private final NameSymbol nameSymbol;
 
@@ -106,28 +111,30 @@ public abstract class Unit implements Nameable {
 	 * Cache storing the result of getDimension()
 	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private transient ObjectProduct<BaseDimension> dimension = null;
 
 	/**
 	 * A constructor that constructs {@code BaseUnit} instances.
-	 * 
+	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	Unit(final NameSymbol nameSymbol) {
-		if (this instanceof BaseUnit) {
-			this.unitBase = ObjectProduct.oneOf((BaseUnit) this);
-		} else
+		if (!(this instanceof BaseUnit))
 			throw new AssertionError();
+		this.unitBase = ObjectProduct.oneOf((BaseUnit) this);
 		this.nameSymbol = nameSymbol;
 	}
 
 	/**
 	 * Creates the {@code Unit}.
-	 * 
+	 *
 	 * @param unitBase base of unit
 	 * @param ns       names and symbol of unit
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if unitBase or ns is null
 	 */
 	protected Unit(ObjectProduct<BaseUnit> unitBase, NameSymbol ns) {
@@ -137,18 +144,9 @@ public abstract class Unit implements Nameable {
 	}
 
 	/**
-	 * @return this unit as a {@link Unitlike}
-	 * @since 2020-09-07
-	 */
-	public final Unitlike<Double> asUnitlike() {
-		return Unitlike.fromConversionFunctions(this.getBase(),
-				this::convertFromBase, this::convertToBase, this.getNameSymbol());
-	}
-
-	/**
 	 * Checks if a value expressed in this unit can be converted to a value
 	 * expressed in {@code other}
-	 * 
+	 *
 	 * @param other unit or unitlike form to test with
 	 * @return true if they are compatible
 	 * @since 2019-01-13
@@ -161,21 +159,6 @@ public abstract class Unit implements Nameable {
 	}
 
 	/**
-	 * Checks if a value expressed in this unit can be converted to a value
-	 * expressed in {@code other}
-	 * 
-	 * @param other unit or unitlike form to test with
-	 * @return true if they are compatible
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 * @throws NullPointerException if other is null
-	 */
-	public final <W> boolean canConvertTo(final Unitlike<W> other) {
-		Objects.requireNonNull(other, "other must not be null.");
-		return Objects.equals(this.getBase(), other.getBase());
-	}
-
-	/**
 	 * Converts from a value expressed in this unit's base unit to a value
 	 * expressed in this unit.
 	 * <p>
@@ -187,10 +170,10 @@ public abstract class Unit implements Nameable {
 	 * If this unit <i>is</i> a base unit, this method should return
 	 * {@code value}.
 	 * </p>
-	 * 
+	 *
 	 * @implSpec This method is used by {@link #convertTo}, and its behaviour
 	 *           affects the behaviour of {@code convertTo}.
-	 * 
+	 *
 	 * @param value value expressed in <b>base</b> unit
 	 * @return value expressed in <b>this</b> unit
 	 * @since 2018-12-22
@@ -201,16 +184,17 @@ public abstract class Unit implements Nameable {
 	/**
 	 * Converts a value expressed in this unit to a value expressed in
 	 * {@code other}.
-	 * 
+	 *
 	 * @implSpec If unit conversion is possible, this implementation returns
 	 *           {@code other.convertFromBase(this.convertToBase(value))}.
 	 *           Therefore, overriding either of those methods will change the
 	 *           output of this method.
-	 * 
+	 *
 	 * @param other unit to convert to
 	 * @param value value to convert
 	 * @return converted value
 	 * @since 2019-05-22
+	 * @since v0.3.0
 	 * @throws IllegalArgumentException if {@code other} is incompatible for
 	 *                                  conversion with this unit (as tested by
 	 *                                  {@link Unit#canConvertTo}).
@@ -220,37 +204,8 @@ public abstract class Unit implements Nameable {
 		Objects.requireNonNull(other, "other must not be null.");
 		if (this.canConvertTo(other))
 			return other.convertFromBase(this.convertToBase(value));
-		else
-			throw new IllegalArgumentException(
-					String.format("Cannot convert from %s to %s.", this, other));
-	}
-
-	/**
-	 * Converts a value expressed in this unit to a value expressed in
-	 * {@code other}.
-	 * 
-	 * @implSpec If conversion is possible, this implementation returns
-	 *           {@code other.convertFromBase(this.convertToBase(value))}.
-	 *           Therefore, overriding either of those methods will change the
-	 *           output of this method.
-	 * 
-	 * @param other unitlike form to convert to
-	 * @param value value to convert
-	 * @param <W>   type of value to convert to
-	 * @return converted value
-	 * @since 2020-09-07
-	 * @throws IllegalArgumentException if {@code other} is incompatible for
-	 *                                  conversion with this unit (as tested by
-	 *                                  {@link Unit#canConvertTo}).
-	 * @throws NullPointerException     if other is null
-	 */
-	public final <W> W convertTo(final Unitlike<W> other, final double value) {
-		Objects.requireNonNull(other, "other must not be null.");
-		if (this.canConvertTo(other))
-			return other.convertFromBase(this.convertToBase(value));
-		else
-			throw new IllegalArgumentException(
-					String.format("Cannot convert from %s to %s.", this, other));
+		throw new IllegalArgumentException(
+				String.format("Cannot convert from %s to %s.", this, other));
 	}
 
 	/**
@@ -265,10 +220,10 @@ public abstract class Unit implements Nameable {
 	 * If this unit <i>is</i> a base unit, this method should return
 	 * {@code value}.
 	 * </p>
-	 * 
+	 *
 	 * @implSpec This method is used by {@link #convertTo}, and its behaviour
 	 *           affects the behaviour of {@code convertTo}.
-	 * 
+	 *
 	 * @param value value expressed in <b>this</b> unit
 	 * @return value expressed in <b>base</b> unit
 	 * @since 2018-12-22
@@ -292,7 +247,7 @@ public abstract class Unit implements Nameable {
 	 */
 	public final ObjectProduct<BaseDimension> getDimension() {
 		if (this.dimension == null) {
-			final Map<BaseUnit, Integer> mapping = this.unitBase.exponentMap();
+			final var mapping = this.unitBase.exponentMap();
 			final Map<BaseDimension, Integer> dimensionMap = new HashMap<>();
 
 			for (final BaseUnit key : mapping.keySet()) {
@@ -307,6 +262,7 @@ public abstract class Unit implements Nameable {
 	/**
 	 * @return the nameSymbol
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	@Override
 	public final NameSymbol getNameSymbol() {
@@ -314,7 +270,7 @@ public abstract class Unit implements Nameable {
 	}
 
 	/**
-	 * Returns true iff this unit is metric.
+	 * Determines whether this unit is metric.
 	 * <p>
 	 * "Metric" is defined by three conditions:
 	 * <ul>
@@ -329,14 +285,17 @@ public abstract class Unit implements Nameable {
 	 * <p>
 	 * All SI units (as designated by the BIPM) except the degree Celsius are
 	 * considered "metric" by this definition.
-	 * 
+	 *
+	 * @return true iff this unit is metric.
+	 *
 	 * @since 2020-08-27
+	 * @since v0.3.0
 	 */
 	public final boolean isMetric() {
 		// first condition - check that it is a linear unit
 		if (!(this instanceof LinearUnit))
 			return false;
-		final LinearUnit linear = (LinearUnit) this;
+		final var linear = (LinearUnit) this;
 
 		// second condition - check that
 		for (final BaseUnit b : linear.getBase().getBaseSet()) {
@@ -352,18 +311,18 @@ public abstract class Unit implements Nameable {
 	/**
 	 * @return a string representing this unit's definition
 	 * @since 2022-03-10
+	 * @since v0.3.0
 	 */
 	public String toDefinitionString() {
 		if (!this.unitBase.getNameSymbol().isEmpty())
 			return "derived from " + this.unitBase.getName();
-		else
-			return "derived from "
-					+ this.getBase().toString(BaseUnit::getShortName);
+		return "derived from " + this.getBase().toString(BaseUnit::getShortName);
 	}
 
 	/**
 	 * @return a string containing both this unit's name and its definition
 	 * @since 2022-03-10
+	 * @since v0.3.0
 	 */
 	public final String toFullString() {
 		return this.toString() + " (" + this.toDefinitionString() + ")";
@@ -375,14 +334,14 @@ public abstract class Unit implements Nameable {
 				&& this.nameSymbol.getSymbol().isPresent())
 			return this.nameSymbol.getPrimaryName().orElseThrow() + " ("
 					+ this.nameSymbol.getSymbol().orElseThrow() + ")";
-		else
-			return this.getName();
+		return this.getName();
 	}
 
 	/**
 	 * @param ns name(s) and symbol to use
 	 * @return a copy of this unit with provided name(s) and symbol
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if ns is null
 	 */
 	public Unit withName(final NameSymbol ns) {
diff --git a/src/main/java/sevenUnits/unit/UnitDatabase.java b/src/main/java/sevenUnits/unit/UnitDatabase.java
index 0120067..36c225f 100644
--- a/src/main/java/sevenUnits/unit/UnitDatabase.java
+++ b/src/main/java/sevenUnits/unit/UnitDatabase.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2018-2024 Adrien Hopkins
+ * Copyright (C) 2018-2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -40,11 +40,9 @@ import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import sevenUnits.utils.ConditionalExistenceCollections;
-import sevenUnits.utils.DecimalComparison;
 import sevenUnits.utils.ExpressionParser;
 import sevenUnits.utils.NameSymbol;
 import sevenUnits.utils.ObjectProduct;
@@ -52,7 +50,7 @@ import sevenUnits.utils.UncertainDouble;
 
 /**
  * A database of units, prefixes and dimensions, and their names.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-01-07
  * @since v0.1.0
@@ -89,7 +87,7 @@ public final class UnitDatabase {
 	 * Because of ambiguities between prefixes (i.e. kilokilo = mega),
 	 * {@link #containsValue} and {@link #values()} currently ignore prefixes.
 	 * </p>
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-04-13
 	 * @since v0.2.0
@@ -97,7 +95,7 @@ public final class UnitDatabase {
 	private static final class PrefixedUnitMap implements Map<String, Unit> {
 		/**
 		 * The class used for entry sets.
-		 * 
+		 *
 		 * <p>
 		 * If the map that created this set is infinite in size (has at least one
 		 * unit and at least one prefix), this set is infinite as well. If this
@@ -105,7 +103,7 @@ public final class UnitDatabase {
 		 * {@code IllegalStateException} instead of creating an infinite-sized
 		 * array.
 		 * </p>
-		 * 
+		 *
 		 * @author Adrien Hopkins
 		 * @since 2019-04-13
 		 * @since v0.2.0
@@ -114,7 +112,7 @@ public final class UnitDatabase {
 				extends AbstractSet<Map.Entry<String, Unit>> {
 			/**
 			 * The entry for this set.
-			 * 
+			 *
 			 * @author Adrien Hopkins
 			 * @since 2019-04-14
 			 * @since v0.2.0
@@ -126,7 +124,7 @@ public final class UnitDatabase {
 
 				/**
 				 * Creates the {@code PrefixedUnitEntry}.
-				 * 
+				 *
 				 * @param key   key
 				 * @param value value
 				 * @since 2019-04-14
@@ -139,6 +137,7 @@ public final class UnitDatabase {
 
 				/**
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				@Override
 				public boolean equals(final Object o) {
@@ -161,6 +160,7 @@ public final class UnitDatabase {
 
 				/**
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				@Override
 				public int hashCode() {
@@ -180,8 +180,9 @@ public final class UnitDatabase {
 				 * string is the string representation of the key, then the equals
 				 * ({@code =}) character, then the string representation of the
 				 * value.
-				 * 
+				 *
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				@Override
 				public String toString() {
@@ -192,7 +193,7 @@ public final class UnitDatabase {
 			/**
 			 * An iterator that iterates over the units of a
 			 * {@code PrefixedUnitNameSet}.
-			 * 
+			 *
 			 * @author Adrien Hopkins
 			 * @since 2019-04-14
 			 * @since v0.2.0
@@ -212,7 +213,9 @@ public final class UnitDatabase {
 				/**
 				 * Creates the
 				 * {@code UnitsDatabase.PrefixedUnitMap.PrefixedUnitNameSet.PrefixedUnitNameIterator}.
-				 * 
+				 *
+				 * @param map map to base iterator on
+				 *
 				 * @since 2019-04-14
 				 * @since v0.2.0
 				 */
@@ -228,7 +231,7 @@ public final class UnitDatabase {
 				 * @since v0.2.0
 				 */
 				private String getCurrentUnitName() {
-					final StringBuilder unitName = new StringBuilder();
+					final var unitName = new StringBuilder();
 					for (final int i : this.prefixCoordinates) {
 						unitName.append(this.prefixNames.get(i));
 					}
@@ -241,18 +244,15 @@ public final class UnitDatabase {
 				public boolean hasNext() {
 					if (this.unitNames.isEmpty())
 						return false;
-					else {
-						if (this.prefixNames.isEmpty())
-							return this.prefixCoordinates.isEmpty()
-									&& this.unitNamePosition < this.unitNames.size();
-						else
-							return true;
-					}
+					if (this.prefixNames.isEmpty())
+						return this.prefixCoordinates.isEmpty()
+								&& this.unitNamePosition < this.unitNames.size();
+					return true;
 				}
 
 				/**
 				 * Changes this iterator's position to the next available one.
-				 * 
+				 *
 				 * @since 2019-04-14
 				 * @since v0.2.0
 				 */
@@ -268,7 +268,7 @@ public final class UnitDatabase {
 							this.prefixCoordinates.add(0, 0);
 						} else {
 							// get the prefix coordinate to increment, then increment
-							int i = this.prefixCoordinates.size() - 1;
+							var i = this.prefixCoordinates.size() - 1;
 							this.prefixCoordinates.set(i,
 									this.prefixCoordinates.get(i) + 1);
 
@@ -294,7 +294,7 @@ public final class UnitDatabase {
 				@Override
 				public Entry<String, Unit> next() {
 					// get next element
-					final Entry<String, Unit> nextEntry = this.peek();
+					final var nextEntry = this.peek();
 
 					// iterate to next position
 					this.incrementPosition();
@@ -306,6 +306,7 @@ public final class UnitDatabase {
 				 * @return the next element in the iterator, without iterating over
 				 *         it
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				private Entry<String, Unit> peek() {
 					if (!this.hasNext())
@@ -322,7 +323,7 @@ public final class UnitDatabase {
 						}
 					}
 
-					final String nextName = this.getCurrentUnitName();
+					final var nextName = this.getCurrentUnitName();
 
 					return new PrefixedUnitEntry(nextName, this.map.get(nextName));
 				}
@@ -330,8 +331,9 @@ public final class UnitDatabase {
 				/**
 				 * Returns a string representation of the object. The exact details
 				 * of the representation are unspecified and subject to change.
-				 * 
+				 *
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				@Override
 				public String toString() {
@@ -346,7 +348,7 @@ public final class UnitDatabase {
 
 			/**
 			 * Creates the {@code PrefixedUnitNameSet}.
-			 * 
+			 *
 			 * @param map map that created this set
 			 * @since 2019-04-13
 			 * @since v0.2.0
@@ -383,7 +385,7 @@ public final class UnitDatabase {
 					// This is OK because I'm in a try-catch block, catching the
 					// exact exception that would be thrown.
 					@SuppressWarnings("unchecked")
-					final Entry<String, Unit> tempEntry = (Entry<String, Unit>) o;
+					final var tempEntry = (Entry<String, Unit>) o;
 					entry = tempEntry;
 				} catch (final ClassCastException e) {
 					throw new IllegalArgumentException(
@@ -441,55 +443,45 @@ public final class UnitDatabase {
 			public int size() {
 				if (this.map.units.isEmpty())
 					return 0;
-				else {
-					if (this.map.prefixes.isEmpty())
-						return this.map.units.size();
-					else
-						// infinite set
-						return Integer.MAX_VALUE;
-				}
+				if (this.map.prefixes.isEmpty())
+					return this.map.units.size();
+				// infinite set
+				return Integer.MAX_VALUE;
 			}
 
-			/**
-			 * @throws IllegalStateException if the set is infinite in size
-			 */
+			/** @throws IllegalStateException if the set is infinite in size */
 			@Override
 			public Object[] toArray() {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toArray();
-				else
-					// infinite set
-					throw new IllegalStateException(
-							"Cannot make an infinite set into an array.");
+				// infinite set
+				throw new IllegalStateException(
+						"Cannot make an infinite set into an array.");
 			}
 
-			/**
-			 * @throws IllegalStateException if the set is infinite in size
-			 */
+			/** @throws IllegalStateException if the set is infinite in size */
 			@Override
 			public <T> T[] toArray(final T[] a) {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toArray(a);
-				else
-					// infinite set
-					throw new IllegalStateException(
-							"Cannot make an infinite set into an array.");
+				// infinite set
+				throw new IllegalStateException(
+						"Cannot make an infinite set into an array.");
 			}
 
 			@Override
 			public String toString() {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toString();
-				else
-					return String.format(
-							"Infinite set of name-unit entries created from units %s and prefixes %s",
-							this.map.units, this.map.prefixes);
+				return String.format(
+						"Infinite set of name-unit entries created from units %s and prefixes %s",
+						this.map.units, this.map.prefixes);
 			}
 		}
 
 		/**
 		 * The class used for unit name sets.
-		 * 
+		 *
 		 * <p>
 		 * If the map that created this set is infinite in size (has at least one
 		 * unit and at least one prefix), this set is infinite as well. If this
@@ -497,7 +489,7 @@ public final class UnitDatabase {
 		 * {@code IllegalStateException} instead of creating an infinite-sized
 		 * array.
 		 * </p>
-		 * 
+		 *
 		 * @author Adrien Hopkins
 		 * @since 2019-04-13
 		 * @since v0.2.0
@@ -507,7 +499,7 @@ public final class UnitDatabase {
 			/**
 			 * An iterator that iterates over the units of a
 			 * {@code PrefixedUnitNameSet}.
-			 * 
+			 *
 			 * @author Adrien Hopkins
 			 * @since 2019-04-14
 			 * @since v0.2.0
@@ -527,7 +519,9 @@ public final class UnitDatabase {
 				/**
 				 * Creates the
 				 * {@code UnitsDatabase.PrefixedUnitMap.PrefixedUnitNameSet.PrefixedUnitNameIterator}.
-				 * 
+				 *
+				 * @param map map to base itorator on
+				 *
 				 * @since 2019-04-14
 				 * @since v0.2.0
 				 */
@@ -543,7 +537,7 @@ public final class UnitDatabase {
 				 * @since v0.2.0
 				 */
 				private String getCurrentUnitName() {
-					final StringBuilder unitName = new StringBuilder();
+					final var unitName = new StringBuilder();
 					for (final int i : this.prefixCoordinates) {
 						unitName.append(this.prefixNames.get(i));
 					}
@@ -556,18 +550,15 @@ public final class UnitDatabase {
 				public boolean hasNext() {
 					if (this.unitNames.isEmpty())
 						return false;
-					else {
-						if (this.prefixNames.isEmpty())
-							return this.prefixCoordinates.isEmpty()
-									&& this.unitNamePosition < this.unitNames.size();
-						else
-							return true;
-					}
+					if (this.prefixNames.isEmpty())
+						return this.prefixCoordinates.isEmpty()
+								&& this.unitNamePosition < this.unitNames.size();
+					return true;
 				}
 
 				/**
 				 * Changes this iterator's position to the next available one.
-				 * 
+				 *
 				 * @since 2019-04-14
 				 * @since v0.2.0
 				 */
@@ -583,7 +574,7 @@ public final class UnitDatabase {
 							this.prefixCoordinates.add(0, 0);
 						} else {
 							// get the prefix coordinate to increment, then increment
-							int i = this.prefixCoordinates.size() - 1;
+							var i = this.prefixCoordinates.size() - 1;
 							this.prefixCoordinates.set(i,
 									this.prefixCoordinates.get(i) + 1);
 
@@ -608,7 +599,7 @@ public final class UnitDatabase {
 
 				@Override
 				public String next() {
-					final String nextName = this.peek();
+					final var nextName = this.peek();
 
 					this.incrementPosition();
 
@@ -619,6 +610,7 @@ public final class UnitDatabase {
 				 * @return the next element in the iterator, without iterating over
 				 *         it
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				private String peek() {
 					if (!this.hasNext())
@@ -640,8 +632,9 @@ public final class UnitDatabase {
 				/**
 				 * Returns a string representation of the object. The exact details
 				 * of the representation are unspecified and subject to change.
-				 * 
+				 *
 				 * @since 2019-05-03
+				 * @since v0.3.0
 				 */
 				@Override
 				public String toString() {
@@ -656,7 +649,7 @@ public final class UnitDatabase {
 
 			/**
 			 * Creates the {@code PrefixedUnitNameSet}.
-			 * 
+			 *
 			 * @param map map that created this set
 			 * @since 2019-04-13
 			 * @since v0.2.0
@@ -734,56 +727,46 @@ public final class UnitDatabase {
 			public int size() {
 				if (this.map.units.isEmpty())
 					return 0;
-				else {
-					if (this.map.prefixes.isEmpty())
-						return this.map.units.size();
-					else
-						// infinite set
-						return Integer.MAX_VALUE;
-				}
+				if (this.map.prefixes.isEmpty())
+					return this.map.units.size();
+				// infinite set
+				return Integer.MAX_VALUE;
 			}
 
-			/**
-			 * @throws IllegalStateException if the set is infinite in size
-			 */
+			/** @throws IllegalStateException if the set is infinite in size */
 			@Override
 			public Object[] toArray() {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toArray();
-				else
-					// infinite set
-					throw new IllegalStateException(
-							"Cannot make an infinite set into an array.");
+				// infinite set
+				throw new IllegalStateException(
+						"Cannot make an infinite set into an array.");
 
 			}
 
-			/**
-			 * @throws IllegalStateException if the set is infinite in size
-			 */
+			/** @throws IllegalStateException if the set is infinite in size */
 			@Override
 			public <T> T[] toArray(final T[] a) {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toArray(a);
-				else
-					// infinite set
-					throw new IllegalStateException(
-							"Cannot make an infinite set into an array.");
+				// infinite set
+				throw new IllegalStateException(
+						"Cannot make an infinite set into an array.");
 			}
 
 			@Override
 			public String toString() {
 				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
 					return super.toString();
-				else
-					return String.format(
-							"Infinite set of name-unit entries created from units %s and prefixes %s",
-							this.map.units, this.map.prefixes);
+				return String.format(
+						"Infinite set of name-unit entries created from units %s and prefixes %s",
+						this.map.units, this.map.prefixes);
 			}
 		}
 
 		/**
 		 * The units stored in this collection, without prefixes.
-		 * 
+		 *
 		 * @since 2019-04-13
 		 * @since v0.2.0
 		 */
@@ -791,7 +774,7 @@ public final class UnitDatabase {
 
 		/**
 		 * The available prefixes for use.
-		 * 
+		 *
 		 * @since 2019-04-13
 		 * @since v0.2.0
 		 */
@@ -804,7 +787,7 @@ public final class UnitDatabase {
 
 		/**
 		 * Creates the {@code PrefixedUnitMap}.
-		 * 
+		 *
 		 * @param units    map mapping unit names to units
 		 * @param prefixes map mapping prefix names to prefixes
 		 * @since 2019-04-13
@@ -855,11 +838,11 @@ public final class UnitDatabase {
 			if (!(key instanceof String))
 				throw new IllegalArgumentException(
 						"Attempted to test for a unit using a non-string name.");
-			final String unitName = (String) key;
+			final var unitName = (String) key;
 
 			// Then, look for the longest prefix that is attached to a valid unit
 			String longestPrefix = null;
-			int longestLength = 0;
+			var longestLength = 0;
 
 			for (final String prefixName : this.prefixes.keySet()) {
 				// a prefix name is valid if:
@@ -871,7 +854,7 @@ public final class UnitDatabase {
 				// linear units can have prefixes)
 				if (unitName.startsWith(prefixName)
 						&& prefixName.length() > longestLength) {
-					final String rest = unitName.substring(prefixName.length());
+					final var rest = unitName.substring(prefixName.length());
 					if (this.containsKey(rest)
 							&& this.get(rest) instanceof LinearUnit) {
 						longestPrefix = prefixName;
@@ -885,7 +868,7 @@ public final class UnitDatabase {
 
 		/**
 		 * {@inheritDoc}
-		 * 
+		 *
 		 * <p>
 		 * Because of ambiguities between prefixes (i.e. kilokilo = mega), this
 		 * method only tests for prefixless units.
@@ -914,11 +897,11 @@ public final class UnitDatabase {
 			if (!(key instanceof String))
 				throw new IllegalArgumentException(
 						"Attempted to obtain a unit using a non-string name.");
-			final String unitName = (String) key;
+			final var unitName = (String) key;
 
 			// Then, look for the longest prefix that is attached to a valid unit
 			String longestPrefix = null;
-			int longestLength = 0;
+			var longestLength = 0;
 
 			for (final String prefixName : this.prefixes.keySet()) {
 				// a prefix name is valid if:
@@ -930,7 +913,7 @@ public final class UnitDatabase {
 				// linear units can have prefixes)
 				if (unitName.startsWith(prefixName)
 						&& prefixName.length() > longestLength) {
-					final String rest = unitName.substring(prefixName.length());
+					final var rest = unitName.substring(prefixName.length());
 					if (this.containsKey(rest)
 							&& this.get(rest) instanceof LinearUnit) {
 						longestPrefix = prefixName;
@@ -942,16 +925,14 @@ public final class UnitDatabase {
 			// if none found, returns null
 			if (longestPrefix == null)
 				return null;
-			else {
-				// get necessary data
-				final String rest = unitName.substring(longestLength);
-				// this cast will not fail because I verified that it would work
-				// before selecting this prefix
-				final LinearUnit unit = (LinearUnit) this.get(rest);
-				final UnitPrefix prefix = this.prefixes.get(longestPrefix);
-
-				return unit.withPrefix(prefix);
-			}
+			// get necessary data
+			final var rest = unitName.substring(longestLength);
+			// this cast will not fail because I verified that it would work
+			// before selecting this prefix
+			final var unit = (LinearUnit) this.get(rest);
+			final var prefix = this.prefixes.get(longestPrefix);
+
+			return unit.withPrefix(prefix);
 		}
 
 		@Override
@@ -1028,28 +1009,24 @@ public final class UnitDatabase {
 		public int size() {
 			if (this.units.isEmpty())
 				return 0;
-			else {
-				if (this.prefixes.isEmpty())
-					return this.units.size();
-				else
-					// infinite set
-					return Integer.MAX_VALUE;
-			}
+			if (this.prefixes.isEmpty())
+				return this.units.size();
+			// infinite set
+			return Integer.MAX_VALUE;
 		}
 
 		@Override
 		public String toString() {
 			if (this.units.isEmpty() || this.prefixes.isEmpty())
 				return new HashMap<>(this).toString();
-			else
-				return String.format(
-						"Infinite map of name-unit entries created from units %s and prefixes %s",
-						this.units, this.prefixes);
+			return String.format(
+					"Infinite map of name-unit entries created from units %s and prefixes %s",
+					this.units, this.prefixes);
 		}
 
 		/**
 		 * {@inheritDoc}
-		 * 
+		 *
 		 * <p>
 		 * Because of ambiguities between prefixes (i.e. kilokilo = mega), this
 		 * method ignores prefixes.
@@ -1066,34 +1043,6 @@ public final class UnitDatabase {
 	}
 
 	/**
-	 * Replacements done to *all* expression types
-	 */
-	private static final Map<Pattern, String> EXPRESSION_REPLACEMENTS = new HashMap<>();
-
-	// add data to expression replacements
-	static {
-		// add spaces around operators
-		for (final String operator : Arrays.asList("\\*", "/", "\\|", "\\^")) {
-			EXPRESSION_REPLACEMENTS.put(Pattern.compile(operator),
-					" " + operator + " ");
-		}
-
-		// replace multiple spaces with a single space
-		EXPRESSION_REPLACEMENTS.put(Pattern.compile(" +"), " ");
-		// place brackets around any expression of the form "number unit", with or
-		// without the space
-		EXPRESSION_REPLACEMENTS.put(Pattern.compile("((?:-?[1-9]\\d*|0)" // integer
-				+ "(?:\\.\\d+(?:[eE]\\d+))?)" // optional decimal point with numbers
-														// after it
-				+ "\\s*" // optional space(s)
-				+ "([a-zA-Z]+(?:\\^\\d+)?" // any string of letters
-				+ "(?:\\s+[a-zA-Z]+(?:\\^\\d+)?))" // optional other letters
-				+ "(?!-?\\d)" // no number directly afterwards (avoids matching
-									// "1e3")
-		), "\\($1 $2\\)");
-	}
-
-	/**
 	 * A regular expression that separates names and expressions in unit files.
 	 */
 	private static final Pattern NAME_EXPRESSION = Pattern
@@ -1108,66 +1057,76 @@ public final class UnitDatabase {
 
 	/**
 	 * The exponent operator
-	 * 
+	 *
 	 * @param base         base of exponentiation
 	 * @param exponentUnit exponent
 	 * @return result
 	 * @since 2019-04-10
 	 * @since v0.2.0
 	 */
-	private static final LinearUnit exponentiateUnits(final LinearUnit base,
+	private static LinearUnit exponentiateUnits(final LinearUnit base,
 			final LinearUnit exponentUnit) {
-		// exponent function - first check if o2 is a number,
-		if (exponentUnit.getBase().equals(Metric.ONE.getBase())) {
-			// then check if it is an integer,
-			final double exponent = exponentUnit.getConversionFactor();
-			if (DecimalComparison.equals(exponent % 1, 0))
-				// then exponentiate
-				return base.toExponent((int) (exponent + 0.5));
-			else
-				// not an integer
-				throw new UnsupportedOperationException(
-						"Decimal exponents are currently not supported.");
-		} else
-			// not a number
-			throw new IllegalArgumentException("Exponents must be numbers.");
+		if (!exponentUnit.getBase().equals(Metric.ONE.getBase()))
+			throw new IllegalArgumentException(String.format(
+					"Tried to exponentiate %s^%s, but exponents must be dimensionless numbers.",
+					base, exponentUnit));
+
+		final var exponent = exponentUnit.getConversionFactor();
+		return base.toExponentRounded(exponent);
 	}
 
 	/**
 	 * The exponent operator
-	 * 
+	 *
 	 * @param base         base of exponentiation
 	 * @param exponentUnit exponent
 	 * @return result
 	 * @since 2020-08-04
+	 * @since v0.3.0
 	 */
-	private static final LinearUnitValue exponentiateUnitValues(
+	private static LinearUnitValue exponentiateUnitValues(
 			final LinearUnitValue base, final LinearUnitValue exponentValue) {
-		// exponent function - first check if o2 is a number,
-		if (exponentValue.canConvertTo(Metric.ONE)) {
-			// then check if it is an integer,
-			final double exponent = exponentValue.getValueExact();
-			if (DecimalComparison.equals(exponent % 1, 0))
-				// then exponentiate
-				return base.toExponent((int) (exponent + 0.5));
-			else
-				// not an integer
-				throw new UnsupportedOperationException(
-						"Decimal exponents are currently not supported.");
-		} else
-			// not a number
-			throw new IllegalArgumentException("Exponents must be numbers.");
+		if (!exponentValue.canConvertTo(Metric.ONE))
+			throw new IllegalArgumentException(String.format(
+					"Tried to exponentiate %s^%s, but exponents must be dimensionless numbers.",
+					base, exponentValue));
+
+		final var exponent = exponentValue.getValueExact();
+		return base.toExponentRounded(exponent);
+	}
+
+	/**
+	 * Formats an expression so it can be parsed by the expression parser.
+	 *
+	 * Specifically, puts spaces around all operators so they can be parsed as
+	 * words.
+	 *
+	 * @param expression expression to format
+	 * @return formatted expression
+	 * @since 2025-06-07
+	 * @since v1.0.0
+	 */
+	static String formatExpression(String expression) {
+		var modifiedExpression = expression;
+		for (final String operator : Arrays.asList("\\*", "/", "\\|", "\\^")) {
+			modifiedExpression = modifiedExpression.replaceAll(operator,
+					" " + operator + " ");
+		}
+
+		modifiedExpression = modifiedExpression.replaceAll("\\s+", " ");
+		return modifiedExpression;
 	}
 
 	/**
 	 * @return true if entry represents a removable duplicate entry of map.
 	 * @since 2021-05-22
+	 * @since v0.3.0
 	 */
 	static <T> boolean isRemovableDuplicate(Map<String, T> map,
 			Entry<String, T> entry) {
 		for (final Entry<String, T> e : map.entrySet()) {
-			final String name = e.getKey();
-			final T value = e.getValue();
+			final var name = e.getKey();
+			final var value = e.getValue();
 			if (lengthFirstComparator.compare(entry.getKey(), name) < 0
 					&& Objects.equals(map.get(entry.getKey()), value))
 				return true;
@@ -1177,7 +1136,7 @@ public final class UnitDatabase {
 
 	/**
 	 * The units in this system, excluding prefixes.
-	 * 
+	 *
 	 * @since 2019-01-07
 	 * @since v0.1.0
 	 */
@@ -1185,7 +1144,7 @@ public final class UnitDatabase {
 
 	/**
 	 * The unit prefixes in this system.
-	 * 
+	 *
 	 * @since 2019-01-14
 	 * @since v0.1.0
 	 */
@@ -1193,7 +1152,7 @@ public final class UnitDatabase {
 
 	/**
 	 * The dimensions in this system.
-	 * 
+	 *
 	 * @since 2019-03-14
 	 * @since v0.2.0
 	 */
@@ -1201,13 +1160,21 @@ public final class UnitDatabase {
 
 	/**
 	 * A map mapping strings to units (including prefixes)
-	 * 
+	 *
 	 * @since 2019-04-13
 	 * @since v0.2.0
 	 */
 	private final Map<String, Unit> units;
 
 	/**
+	 * A map mapping strings to unit sets
+	 *
+	 * @since 2024-08-16
+	 * @since v1.0.0
+	 */
+	private final Map<String, List<LinearUnit>> unitSets;
+
+	/**
 	 * The rule that specifies when prefix repetition is allowed. It takes in one
 	 * argument: a list of the prefixes being applied to the unit
 	 * <p>
@@ -1221,71 +1188,72 @@ public final class UnitDatabase {
 
 	/**
 	 * A parser that can parse unit expressions.
-	 * 
+	 *
 	 * @since 2019-03-22
 	 * @since v0.2.0
 	 */
 	private final ExpressionParser<LinearUnit> unitExpressionParser = new ExpressionParser.Builder<>(
-			this::getLinearUnit).addBinaryOperator("+", (o1, o2) -> o1.plus(o2), 0)
-			.addBinaryOperator("-", (o1, o2) -> o1.minus(o2), 0)
-			.addBinaryOperator("*", (o1, o2) -> o1.times(o2), 1)
-			.addSpaceFunction("*")
-			.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 1)
-			.addBinaryOperator("|", (o1, o2) -> o1.dividedBy(o2), 3)
-			.addBinaryOperator("^", UnitDatabase::exponentiateUnits, 2).build();
+			this::getLinearUnit).addBinaryOperator("+", LinearUnit::plus, 0)
+			.addBinaryOperator("-", LinearUnit::minus, 0)
+			.addBinaryOperator("*", LinearUnit::times, 1)
+			.addBinaryOperator("space_times", LinearUnit::times, 2)
+			.addSpaceFunction("space_times")
+			.addBinaryOperator("/", LinearUnit::dividedBy, 1)
+			.addBinaryOperator("|", LinearUnit::dividedBy, 4)
+			.addBinaryOperator("^", UnitDatabase::exponentiateUnits, 3).build();
 
 	/**
 	 * A parser that can parse unit value expressions.
-	 * 
+	 *
 	 * @since 2020-08-04
+	 * @since v0.3.0
 	 */
 	private final ExpressionParser<LinearUnitValue> unitValueExpressionParser = new ExpressionParser.Builder<>(
 			this::getLinearUnitValue)
-			.addBinaryOperator("+", (o1, o2) -> o1.plus(o2), 0)
-			.addBinaryOperator("-", (o1, o2) -> o1.minus(o2), 0)
-			.addBinaryOperator("*", (o1, o2) -> o1.times(o2), 1)
-			.addSpaceFunction("*")
-			.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 1)
-			.addBinaryOperator("|", (o1, o2) -> o1.dividedBy(o2), 3)
-			.addBinaryOperator("^", UnitDatabase::exponentiateUnitValues, 2)
+			.addBinaryOperator("+", LinearUnitValue::plus, 0)
+			.addBinaryOperator("-", LinearUnitValue::minus, 0)
+			.addBinaryOperator("*", LinearUnitValue::times, 1)
+			.addBinaryOperator("space_times", LinearUnitValue::times, 2)
+			.addSpaceFunction("space_times")
+			.addBinaryOperator("/", LinearUnitValue::dividedBy, 1)
+			.addBinaryOperator("|", LinearUnitValue::dividedBy, 4)
+			.addBinaryOperator("^", UnitDatabase::exponentiateUnitValues, 3)
 			.build();
 
 	/**
 	 * A parser that can parse unit prefix expressions
-	 * 
+	 *
 	 * @since 2019-04-13
 	 * @since v0.2.0
 	 */
 	private final ExpressionParser<UnitPrefix> prefixExpressionParser = new ExpressionParser.Builder<>(
-			this::getPrefix).addBinaryOperator("+", (o1, o2) -> o1.plus(o2), 0)
-			.addBinaryOperator("-", (o1, o2) -> o1.minus(o2), 0)
-			.addBinaryOperator("*", (o1, o2) -> o1.times(o2), 1)
-			.addSpaceFunction("*")
-			.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 1)
-			.addBinaryOperator("|", (o1, o2) -> o1.dividedBy(o2), 3)
-			.addBinaryOperator("^", (o1, o2) -> o1.toExponent(o2.getMultiplier()),
-					2)
+			this::getPrefix).addBinaryOperator("+", UnitPrefix::plus, 0)
+			.addBinaryOperator("-", UnitPrefix::minus, 0)
+			.addBinaryOperator("*", UnitPrefix::times, 1).addSpaceFunction("*")
+			.addBinaryOperator("/", UnitPrefix::dividedBy, 1)
+			.addBinaryOperator("|", UnitPrefix::dividedBy, 3).addBinaryOperator(
+					"^", (o1, o2) -> o1.toExponent(o2.getMultiplier()), 2)
 			.build();
 
 	/**
 	 * A parser that can parse unit dimension expressions.
-	 * 
+	 *
 	 * @since 2019-04-13
 	 * @since v0.2.0
 	 */
 	private final ExpressionParser<ObjectProduct<BaseDimension>> unitDimensionParser = new ExpressionParser.Builder<>(
-			this::getDimension).addBinaryOperator("*", (o1, o2) -> o1.times(o2), 0)
+			this::getDimension).addBinaryOperator("*", ObjectProduct::times, 0)
 			.addSpaceFunction("*")
-			.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 0)
-			.addBinaryOperator("|", (o1, o2) -> o1.dividedBy(o2), 2)
+			.addBinaryOperator("/", ObjectProduct::dividedBy, 0)
+			.addBinaryOperator("|", ObjectProduct::dividedBy, 2)
 			.addNumericOperator("^", (o1, o2) -> {
-				int exponent = (int) Math.round(o2.value());
+				final var exponent = (int) Math.round(o2.value());
 				return o1.toExponent(exponent);
 			}, 1).build();
 
 	/**
 	 * Creates the {@code UnitsDatabase}.
-	 * 
+	 *
 	 * @since 2019-01-10
 	 * @since v0.1.0
 	 */
@@ -1295,10 +1263,11 @@ public final class UnitDatabase {
 
 	/**
 	 * Creates the {@code UnitsDatabase}
-	 * 
+	 *
 	 * @param prefixRepetitionRule the rule that determines when prefix
 	 *                             repetition is allowed
 	 * @since 2020-08-26
+	 * @since v0.3.0
 	 */
 	public UnitDatabase(Predicate<List<UnitPrefix>> prefixRepetitionRule) {
 		this.prefixlessUnits = new HashMap<>();
@@ -1309,11 +1278,12 @@ public final class UnitDatabase {
 				new PrefixedUnitMap(this.prefixlessUnits, this.prefixes),
 				entry -> this.prefixRepetitionRule
 						.test(this.getPrefixesFromName(entry.getKey())));
+		this.unitSets = new HashMap<>();
 	}
 
 	/**
 	 * Adds a unit dimension to the database.
-	 * 
+	 *
 	 * @param name      dimension's name
 	 * @param dimension dimension to add
 	 * @throws NullPointerException if name or dimension is null
@@ -1324,14 +1294,14 @@ public final class UnitDatabase {
 			final ObjectProduct<BaseDimension> dimension) {
 		Objects.requireNonNull(name, "name may not be null");
 		Objects.requireNonNull(dimension, "dimension may not be null");
-		final ObjectProduct<BaseDimension> namedDimension = dimension
+		final var namedDimension = dimension
 				.withName(dimension.getNameSymbol().withExtraName(name));
 		this.dimensions.put(name, namedDimension);
 	}
 
 	/**
 	 * Adds to the list from a line in a unit dimension file.
-	 * 
+	 *
 	 * @param line        line to look at
 	 * @param lineCounter number of line, for error messages
 	 * @since 2019-04-10
@@ -1349,13 +1319,13 @@ public final class UnitDatabase {
 		}
 
 		// divide line into name and expression
-		final Matcher lineMatcher = NAME_EXPRESSION.matcher(line);
+		final var lineMatcher = NAME_EXPRESSION.matcher(line);
 		if (!lineMatcher.matches())
 			throw new IllegalArgumentException(String.format(
 					"Error at line %d: Lines of a dimension file must consist of a dimension name, then spaces or tabs, then a dimension expression.",
 					lineCounter));
-		final String name = lineMatcher.group(1);
-		final String expression = lineMatcher.group(2);
+		final var name = lineMatcher.group(1);
+		final var expression = lineMatcher.group(2);
 
 		// if (name.endsWith(" ")) {
 		// System.err.printf("Warning - line %d's dimension name ends in a space",
@@ -1369,22 +1339,13 @@ public final class UnitDatabase {
 				throw new IllegalArgumentException(String.format(
 						"! used but no dimension found (line %d).", lineCounter));
 		} else {
-			// it's a unit, get the unit
-			final ObjectProduct<BaseDimension> dimension;
-			try {
-				dimension = this.getDimensionFromExpression(expression);
-			} catch (final IllegalArgumentException | NoSuchElementException e) {
-				System.err.printf("Parsing error on line %d:%n", lineCounter);
-				throw e;
-			}
-
-			this.addDimension(name, dimension);
+			this.addDimension(name, this.getDimensionFromExpression(expression));
 		}
 	}
 
 	/**
 	 * Adds a unit prefix to the database.
-	 * 
+	 *
 	 * @param name   prefix's name
 	 * @param prefix prefix to add
 	 * @throws NullPointerException if name or prefix is null
@@ -1401,7 +1362,7 @@ public final class UnitDatabase {
 
 	/**
 	 * Adds a unit to the database.
-	 * 
+	 *
 	 * @param name unit's name
 	 * @param unit unit to add
 	 * @throws NullPointerException if unit is null
@@ -1418,7 +1379,7 @@ public final class UnitDatabase {
 
 	/**
 	 * Adds to the list from a line in a unit file.
-	 * 
+	 *
 	 * @param line        line to look at
 	 * @param lineCounter number of line, for error messages
 	 * @since 2019-04-10
@@ -1436,14 +1397,14 @@ public final class UnitDatabase {
 		}
 
 		// divide line into name and expression
-		final Matcher lineMatcher = NAME_EXPRESSION.matcher(line);
+		final var lineMatcher = NAME_EXPRESSION.matcher(line);
 		if (!lineMatcher.matches())
 			throw new IllegalArgumentException(String.format(
 					"Error at line %d: Lines of a unit file must consist of a unit name, then spaces or tabs, then a unit expression.",
 					lineCounter));
-		final String name = lineMatcher.group(1);
+		final var name = lineMatcher.group(1);
 
-		final String expression = lineMatcher.group(2);
+		final var expression = lineMatcher.group(2);
 
 		// this code should never occur
 		// if (name.endsWith(" ")) {
@@ -1457,47 +1418,55 @@ public final class UnitDatabase {
 			if (!this.containsUnitName(name))
 				throw new IllegalArgumentException(String
 						.format("! used but no unit found (line %d).", lineCounter));
+		} else if (name.endsWith("-")) {
+			final var prefixName = name.substring(0, name.length() - 1);
+			this.addPrefix(prefixName, this.getPrefixFromExpression(expression));
+		} else if (expression.contains(";")) {
+			// it's a multi-unit
+			this.addUnitSet(name, this.getUnitSetFromExpression(expression));
 		} else {
-			if (name.endsWith("-")) {
-				final UnitPrefix prefix;
-				try {
-					prefix = this.getPrefixFromExpression(expression);
-				} catch (final IllegalArgumentException
-						| NoSuchElementException e) {
-					System.err.printf("Parsing error on line %d:%n", lineCounter);
-					throw e;
-				}
-				final String prefixName = name.substring(0, name.length() - 1);
-				this.addPrefix(prefixName, prefix);
-			} else {
-				// it's a unit, get the unit
-				final Unit unit;
-				try {
-					unit = this.getUnitFromExpression(expression);
-				} catch (final IllegalArgumentException
-						| NoSuchElementException e) {
-					System.err.printf("Parsing error on line %d:%n", lineCounter);
-					throw e;
-				}
-				this.addUnit(name, unit);
-			}
+			// it's a unit, get the unit
+			this.addUnit(name, this.getUnitFromExpression(expression));
 		}
 	}
 
 	/**
-	 * Removes all units, prefixes and dimensions from this database.
-	 * 
+	 * Add a unit set to the database.
+	 *
+	 * @param name  name of unit set
+	 * @param value unit set to add
+	 * @since 2024-08-16
+	 * @since v1.0.0
+	 */
+	public void addUnitSet(String name, List<LinearUnit> value) {
+		if (value.isEmpty())
+			throw new IllegalArgumentException("Unit sets must not be empty.");
+		for (final LinearUnit unit : value.subList(1, value.size())) {
+			if (!Objects.equals(unit.getDimension(), value.get(0).getDimension()))
+				throw new IllegalArgumentException(
+						"Unit sets must be all the same dimension, " + value
+								+ " is not.");
+		}
+
+		this.unitSets.put(name, value);
+	}
+
+	/**
+	 * Removes all units, unit sets, prefixes and dimensions from this database.
+	 *
 	 * @since 2022-02-26
+	 * @since v0.4.0
 	 */
 	public void clear() {
 		this.dimensions.clear();
 		this.prefixes.clear();
 		this.prefixlessUnits.clear();
+		this.unitSets.clear();
 	}
 
 	/**
 	 * Tests if the database has a unit dimension with this name.
-	 * 
+	 *
 	 * @param name name to test
 	 * @return if database contains name
 	 * @since 2019-03-14
@@ -1509,7 +1478,7 @@ public final class UnitDatabase {
 
 	/**
 	 * Tests if the database has a unit prefix with this name.
-	 * 
+	 *
 	 * @param name name to test
 	 * @return if database contains name
 	 * @since 2019-01-13
@@ -1522,7 +1491,7 @@ public final class UnitDatabase {
 	/**
 	 * Tests if the database has a unit with this name, taking prefixes into
 	 * consideration
-	 * 
+	 *
 	 * @param name name to test
 	 * @return if database contains name
 	 * @since 2019-01-13
@@ -1533,6 +1502,19 @@ public final class UnitDatabase {
 	}
 
 	/**
+	 * Returns true iff there is a unit set with this name.
+	 *
+	 * @param name name to check for
+	 * @return true iff there is a unit set with this name
+	 *
+	 * @since 2024-08-16
+	 * @since v1.0.0
+	 */
+	public boolean containsUnitSetName(String name) {
+		return this.unitSets.containsKey(name);
+	}
+
+	/**
 	 * @return a map mapping dimension names to dimensions
 	 * @since 2019-04-13
 	 * @since v0.2.0
@@ -1544,10 +1526,11 @@ public final class UnitDatabase {
 	/**
 	 * Evaluates a unit expression, following the same rules as
 	 * {@link #getUnitFromExpression}.
-	 * 
+	 *
 	 * @param expression expression to parse
 	 * @return {@code LinearUnitValue} representing value of expression
 	 * @since 2020-08-04
+	 * @since v0.3.0
 	 */
 	public LinearUnitValue evaluateUnitExpression(final String expression) {
 		Objects.requireNonNull(expression, "expression must not be null.");
@@ -1556,37 +1539,13 @@ public final class UnitDatabase {
 		if (this.containsUnitName(expression))
 			return this.getLinearUnitValue(expression);
 
-		// force operators to have spaces
-		String modifiedExpression = expression;
-		modifiedExpression = modifiedExpression.replaceAll("\\+", " \\+ ");
-		modifiedExpression = modifiedExpression.replaceAll("-", " - ");
-
-		// format expression
-		for (final Entry<Pattern, String> replacement : EXPRESSION_REPLACEMENTS
-				.entrySet()) {
-			modifiedExpression = replacement.getKey().matcher(modifiedExpression)
-					.replaceAll(replacement.getValue());
-		}
-
-		// the previous operation breaks negative numbers, fix them!
-		// (i.e. -2 becomes - 2)
-		// FIXME the previous operaton also breaks stuff like "1e-5"
-		for (int i = 0; i < modifiedExpression.length(); i++) {
-			if (modifiedExpression.charAt(i) == '-'
-					&& (i < 2 || Arrays.asList('+', '-', '*', '/', '|', '^')
-							.contains(modifiedExpression.charAt(i - 2)))) {
-				// found a broken negative number
-				modifiedExpression = modifiedExpression.substring(0, i + 1)
-						+ modifiedExpression.substring(i + 2);
-			}
-		}
-
-		return this.unitValueExpressionParser.parseExpression(modifiedExpression);
+		return this.unitValueExpressionParser
+				.parseExpression(formatExpression(expression));
 	}
 
 	/**
 	 * Gets a unit dimension from the database using its name.
-	 * 
+	 *
 	 * @param name dimension's name
 	 * @return dimension
 	 * @since 2019-03-14
@@ -1594,12 +1553,11 @@ public final class UnitDatabase {
 	 */
 	public ObjectProduct<BaseDimension> getDimension(final String name) {
 		Objects.requireNonNull(name, "name must not be null.");
-		final ObjectProduct<BaseDimension> dimension = this.dimensions.get(name);
+		final var dimension = this.dimensions.get(name);
 		if (dimension == null)
 			throw new NoSuchElementException(
 					"No dimension with name \"" + name + "\".");
-		else
-			return dimension;
+		return dimension;
 	}
 
 	/**
@@ -1614,8 +1572,9 @@ public final class UnitDatabase {
 	 * multiplication)</li>
 	 * <li>The operator '^' which exponentiates. Exponents must be integers.</li>
 	 * </ul>
-	 * 
+	 *
 	 * @param expression expression to parse
+	 * @return parsed unit dimension
 	 * @throws IllegalArgumentException if the expression cannot be parsed
 	 * @throws NullPointerException     if expression is null
 	 * @since 2019-04-13
@@ -1629,23 +1588,14 @@ public final class UnitDatabase {
 		if (this.containsDimensionName(expression))
 			return this.getDimension(expression);
 
-		// force operators to have spaces
-		String modifiedExpression = expression;
-
-		// format expression
-		for (final Entry<Pattern, String> replacement : EXPRESSION_REPLACEMENTS
-				.entrySet()) {
-			modifiedExpression = replacement.getKey().matcher(modifiedExpression)
-					.replaceAll(replacement.getValue());
-		}
-
-		return this.unitDimensionParser.parseExpression(modifiedExpression);
+		return this.unitDimensionParser
+				.parseExpression(formatExpression(expression));
 	}
 
 	/**
 	 * Gets a unit. If it is linear, cast it to a LinearUnit and return it.
 	 * Otherwise, throw an {@code IllegalArgumentException}.
-	 * 
+	 *
 	 * @param name unit's name
 	 * @return unit
 	 * @since 2019-03-22
@@ -1662,29 +1612,28 @@ public final class UnitDatabase {
 						"Format nonlinear units like: unit(value).");
 
 			// solve the function
-			final Unit unit = this.getUnit(parts.get(0));
-			final double value = Double.parseDouble(
+			final var unit = this.getUnit(parts.get(0));
+			final var value = Double.parseDouble(
 					parts.get(1).substring(0, parts.get(1).length() - 1));
 			return LinearUnit.fromUnitValue(unit, value);
-		} else {
-			// get a linear unit
-			final Unit unit = this.getUnit(name);
-
-			if (unit instanceof LinearUnit)
-				return (LinearUnit) unit;
-			else
-				throw new IllegalArgumentException(
-						String.format("%s is not a linear unit.", name));
 		}
+		// get a linear unit
+		final var unit = this.getUnit(name);
+
+		if (unit instanceof LinearUnit)
+			return (LinearUnit) unit;
+		throw new IllegalArgumentException(
+				String.format("%s is not a linear unit.", name));
 	}
 
 	/**
 	 * Gets a {@code LinearUnitValue} from a unit name. Nonlinear units will be
 	 * converted to their base units.
-	 * 
+	 *
 	 * @param name name of unit
 	 * @return {@code LinearUnitValue} instance
 	 * @since 2020-08-04
+	 * @since v0.3.0
 	 */
 	LinearUnitValue getLinearUnitValue(final String name) {
 		try {
@@ -1698,7 +1647,7 @@ public final class UnitDatabase {
 
 	/**
 	 * Gets a unit prefix from the database from its name
-	 * 
+	 *
 	 * @param name prefix's name
 	 * @return prefix
 	 * @since 2019-01-10
@@ -1708,30 +1657,30 @@ public final class UnitDatabase {
 		try {
 			return UnitPrefix.valueOf(Double.parseDouble(name));
 		} catch (final NumberFormatException e) {
-			final UnitPrefix prefix = this.prefixes.get(name);
+			final var prefix = this.prefixes.get(name);
 			if (prefix == null)
 				throw new NoSuchElementException(
 						"No prefix with name \"" + name + "\".");
-			else
-				return prefix;
+			return prefix;
 		}
 	}
 
 	/**
 	 * Gets all of the prefixes that are on a unit name, in application order.
-	 * 
+	 *
 	 * @param unitName name of unit
 	 * @return prefixes
 	 * @since 2020-08-26
+	 * @since v0.3.0
 	 */
 	List<UnitPrefix> getPrefixesFromName(final String unitName) {
 		final List<UnitPrefix> prefixes = new ArrayList<>();
-		String name = unitName;
+		var name = unitName;
 
 		while (!this.prefixlessUnits.containsKey(name)) {
 			// find the longest prefix
 			String longestPrefixName = null;
-			int longestLength = name.length();
+			var longestLength = name.length();
 
 			while (longestPrefixName == null) {
 				longestLength--;
@@ -1744,7 +1693,7 @@ public final class UnitDatabase {
 			}
 
 			// longest prefix found!
-			final UnitPrefix prefix = this.getPrefix(longestPrefixName);
+			final var prefix = this.getPrefix(longestPrefixName);
 			prefixes.add(0, prefix);
 			name = name.substring(longestLength);
 		}
@@ -1757,7 +1706,7 @@ public final class UnitDatabase {
 	 * Currently, prefix expressions are much simpler than unit expressions: They
 	 * are either a number or the name of another prefix
 	 * </p>
-	 * 
+	 *
 	 * @param expression expression to input
 	 * @return prefix
 	 * @throws IllegalArgumentException if expression cannot be parsed
@@ -1772,30 +1721,22 @@ public final class UnitDatabase {
 		if (this.containsUnitName(expression))
 			return this.getPrefix(expression);
 
-		// force operators to have spaces
-		String modifiedExpression = expression;
-
-		// format expression
-		for (final Entry<Pattern, String> replacement : EXPRESSION_REPLACEMENTS
-				.entrySet()) {
-			modifiedExpression = replacement.getKey().matcher(modifiedExpression)
-					.replaceAll(replacement.getValue());
-		}
-
-		return this.prefixExpressionParser.parseExpression(modifiedExpression);
+		return this.prefixExpressionParser
+				.parseExpression(formatExpression(expression));
 	}
 
 	/**
 	 * @return the prefixRepetitionRule
 	 * @since 2020-08-26
+	 * @since v0.3.0
 	 */
-	public final Predicate<List<UnitPrefix>> getPrefixRepetitionRule() {
+	public Predicate<List<UnitPrefix>> getPrefixRepetitionRule() {
 		return this.prefixRepetitionRule;
 	}
 
 	/**
 	 * Gets a unit from the database from its name, looking for prefixes.
-	 * 
+	 *
 	 * @param name unit's name
 	 * @return unit
 	 * @since 2019-01-10
@@ -1803,27 +1744,28 @@ public final class UnitDatabase {
 	 */
 	public Unit getUnit(final String name) {
 		try {
-			final double value = Double.parseDouble(name);
+			final var value = Double.parseDouble(name);
 			return Metric.ONE.times(value);
 		} catch (final NumberFormatException e) {
-			final Unit unit = this.units.get(name);
+			final var unit = this.units.get(name);
 			if (unit == null)
 				throw new NoSuchElementException("No unit " + name);
-			else if (unit.getPrimaryName().isEmpty())
+			if (unit.getPrimaryName().isEmpty())
 				return unit.withName(NameSymbol.ofName(name));
-			else if (!unit.getPrimaryName().get().equals(name)) {
+			if (!unit.getPrimaryName().get().equals(name)) {
 				final Set<String> otherNames = new HashSet<>(unit.getOtherNames());
 				otherNames.add(unit.getPrimaryName().get());
 				return unit.withName(NameSymbol.ofNullable(name,
 						unit.getSymbol().orElse(null), otherNames));
-			} else if (!unit.getOtherNames().contains(name)) {
+			}
+			if (!unit.getOtherNames().contains(name)) {
 				final Set<String> otherNames = new HashSet<>(unit.getOtherNames());
 				otherNames.add(name);
 				return unit.withName(
 						NameSymbol.ofNullable(unit.getPrimaryName().orElse(null),
 								unit.getSymbol().orElse(null), otherNames));
-			} else
-				return unit;
+			}
+			return unit;
 		}
 
 	}
@@ -1842,8 +1784,9 @@ public final class UnitDatabase {
 	 * <li>A number which is multiplied or divided</li>
 	 * </ul>
 	 * This method only works with linear units.
-	 * 
+	 *
 	 * @param expression expression to parse
+	 * @return parsed unit
 	 * @throws IllegalArgumentException if the expression cannot be parsed
 	 * @throws NullPointerException     if expression is null
 	 * @since 2019-01-07
@@ -1856,31 +1799,51 @@ public final class UnitDatabase {
 		if (this.containsUnitName(expression))
 			return this.getUnit(expression);
 
-		// force operators to have spaces
-		String modifiedExpression = expression;
-		modifiedExpression = modifiedExpression.replaceAll("\\+", " \\+ ");
-		modifiedExpression = modifiedExpression.replaceAll("-", " - ");
+		return this.unitExpressionParser
+				.parseExpression(formatExpression(expression));
+	}
 
-		// format expression
-		for (final Entry<Pattern, String> replacement : EXPRESSION_REPLACEMENTS
-				.entrySet()) {
-			modifiedExpression = replacement.getKey().matcher(modifiedExpression)
-					.replaceAll(replacement.getValue());
-		}
+	/**
+	 * Get a unit set from its name, throwing a {@link NoSuchElementException} if
+	 * there is none.
+	 *
+	 * @param name name of unit set
+	 * @return unit set with that name
+	 *
+	 * @since 2024-08-16
+	 * @since v1.0.0
+	 */
+	public List<LinearUnit> getUnitSet(String name) {
+		final var unitSet = this.unitSets.get(name);
+		if (unitSet == null)
+			throw new NoSuchElementException("No unit set with name " + name);
+		return unitSet;
+	}
 
-		// the previous operation breaks negative numbers, fix them!
-		// (i.e. -2 becomes - 2)
-		for (int i = 0; i < modifiedExpression.length(); i++) {
-			if (modifiedExpression.charAt(i) == '-'
-					&& (i < 2 || Arrays.asList('+', '-', '*', '/', '|', '^')
-							.contains(modifiedExpression.charAt(i - 2)))) {
-				// found a broken negative number
-				modifiedExpression = modifiedExpression.substring(0, i + 1)
-						+ modifiedExpression.substring(i + 2);
-			}
-		}
+	/**
+	 * Parses a semicolon-separated expression to get the unit set being used.
+	 *
+	 * @since 2024-08-22
+	 * @since v1.0.0
+	 */
+	List<LinearUnit> getUnitSetFromExpression(String expression) {
+		final var parts = expression.split(";");
+		final List<LinearUnit> units = new ArrayList<>(parts.length);
+		for (final String unitName : parts) {
+			final var unit = this.getUnitFromExpression(unitName.trim());
 
-		return this.unitExpressionParser.parseExpression(modifiedExpression);
+			if (!(unit instanceof LinearUnit))
+				throw new IllegalArgumentException(String.format(
+						"Unit '%s' is in a unit-set expression, but is not linear.",
+						unitName));
+			if (units.size() > 0 && !unit.canConvertTo(units.get(0)))
+				throw new IllegalArgumentException(String.format(
+						"Units in expression '%s' have different dimensions.",
+						expression));
+
+			units.add((LinearUnit) unit);
+		}
+		return units;
 	}
 
 	/**
@@ -1901,26 +1864,32 @@ public final class UnitDatabase {
 	 * no unit is found, an IllegalArgumentException is thrown. This is used to
 	 * define initial units and ensure that the database contains them.</li>
 	 * </ul>
-	 * 
+	 *
 	 * @param file file to read
-	 * @throws IllegalArgumentException if the file cannot be parsed, found or
-	 *                                  read
-	 * @throws NullPointerException     if file is null
+	 * @throws NullPointerException if file is null
+	 * @return list of errors that happened when loading file
 	 * @since 2019-01-13
 	 * @since v0.1.0
 	 */
-	public void loadDimensionFile(final Path file) {
+	public List<LoadingException> loadDimensionFile(final Path file) {
 		Objects.requireNonNull(file, "file must not be null.");
+		final List<LoadingException> errors = new ArrayList<>();
 		try {
-			long lineCounter = 0;
+			var lineCounter = 0L;
 			for (final String line : Files.readAllLines(file)) {
-				this.addDimensionFromLine(line, ++lineCounter);
+				try {
+					this.addDimensionFromLine(line, ++lineCounter);
+				} catch (IllegalArgumentException | NoSuchElementException e) {
+					errors.add(new LoadingException(lineCounter, line, file,
+							LoadingException.FileType.DIMENSION, e));
+				}
 			}
 		} catch (final FileNotFoundException e) {
 			throw new IllegalArgumentException("Could not find file " + file, e);
 		} catch (final IOException e) {
 			throw new IllegalArgumentException("Could not read file " + file, e);
 		}
+		return errors;
 	}
 
 	/**
@@ -1928,15 +1897,26 @@ public final class UnitDatabase {
 	 * {@link #loadDimensionFile}.
 	 *
 	 * @param stream stream to load from
+	 * @return list of all errors that happened loading the stream
 	 * @since 2021-03-27
+	 * @since v0.3.0
 	 */
-	public void loadDimensionsFromStream(final InputStream stream) {
-		try (final Scanner scanner = new Scanner(stream)) {
-			long lineCounter = 0;
+	public List<LoadingException> loadDimensionsFromStream(
+			final InputStream stream) {
+		final List<LoadingException> errors = new ArrayList<>();
+		try (final var scanner = new Scanner(stream)) {
+			var lineCounter = 0L;
 			while (scanner.hasNextLine()) {
-				this.addDimensionFromLine(scanner.nextLine(), ++lineCounter);
+				final var line = scanner.nextLine();
+				try {
+					this.addDimensionFromLine(line, ++lineCounter);
+				} catch (IllegalArgumentException | NoSuchElementException e) {
+					errors.add(new LoadingException(lineCounter, line,
+							LoadingException.FileType.DIMENSION, e));
+				}
 			}
 		}
+		return errors;
 	}
 
 	/**
@@ -1956,26 +1936,32 @@ public final class UnitDatabase {
 	 * no unit is found, an IllegalArgumentException is thrown. This is used to
 	 * define initial units and ensure that the database contains them.</li>
 	 * </ul>
-	 * 
+	 *
 	 * @param file file to read
-	 * @throws IllegalArgumentException if the file cannot be parsed, found or
-	 *                                  read
-	 * @throws NullPointerException     if file is null
+	 * @throws NullPointerException if file is null
+	 * @return list of errors that happened when loading file
 	 * @since 2019-01-13
 	 * @since v0.1.0
 	 */
-	public void loadUnitsFile(final Path file) {
+	public List<LoadingException> loadUnitsFile(final Path file) {
 		Objects.requireNonNull(file, "file must not be null.");
+		final List<LoadingException> errors = new ArrayList<>();
 		try {
-			long lineCounter = 0;
+			var lineCounter = 0L;
 			for (final String line : Files.readAllLines(file)) {
-				this.addUnitOrPrefixFromLine(line, ++lineCounter);
+				try {
+					this.addUnitOrPrefixFromLine(line, ++lineCounter);
+				} catch (IllegalArgumentException | NoSuchElementException e) {
+					errors.add(new LoadingException(lineCounter, line, file,
+							LoadingException.FileType.UNIT, e));
+				}
 			}
 		} catch (final FileNotFoundException e) {
 			throw new IllegalArgumentException("Could not find file " + file, e);
 		} catch (final IOException e) {
 			throw new IllegalArgumentException("Could not read file " + file, e);
 		}
+		return errors;
 	}
 
 	/**
@@ -1983,15 +1969,25 @@ public final class UnitDatabase {
 	 * {@link #loadUnitsFile}.
 	 *
 	 * @param stream stream to load from
+	 * @return list of all errors that happened loading the stream
 	 * @since 2021-03-27
+	 * @since v0.3.0
 	 */
-	public void loadUnitsFromStream(InputStream stream) {
-		try (final Scanner scanner = new Scanner(stream)) {
-			long lineCounter = 0;
+	public List<LoadingException> loadUnitsFromStream(InputStream stream) {
+		final List<LoadingException> errors = new ArrayList<>();
+		try (final var scanner = new Scanner(stream)) {
+			var lineCounter = 0L;
 			while (scanner.hasNextLine()) {
-				this.addUnitOrPrefixFromLine(scanner.nextLine(), ++lineCounter);
+				final var line = scanner.nextLine();
+				try {
+					this.addUnitOrPrefixFromLine(line, ++lineCounter);
+				} catch (IllegalArgumentException | NoSuchElementException e) {
+					errors.add(new LoadingException(lineCounter, line,
+							LoadingException.FileType.UNIT, e));
+				}
 			}
 		}
+		return errors;
 	}
 
 	/**
@@ -2003,17 +1999,17 @@ public final class UnitDatabase {
 	public Map<String, UnitPrefix> prefixMap(boolean includeDuplicates) {
 		if (includeDuplicates)
 			return Collections.unmodifiableMap(this.prefixes);
-		else
-			return Collections.unmodifiableMap(ConditionalExistenceCollections
-					.conditionalExistenceMap(this.prefixes,
-							entry -> !isRemovableDuplicate(this.prefixes, entry)));
+		return Collections.unmodifiableMap(ConditionalExistenceCollections
+				.conditionalExistenceMap(this.prefixes,
+						entry -> !isRemovableDuplicate(this.prefixes, entry)));
 	}
 
 	/**
 	 * @param prefixRepetitionRule the prefixRepetitionRule to set
 	 * @since 2020-08-26
+	 * @since v0.3.0
 	 */
-	public final void setPrefixRepetitionRule(
+	public void setPrefixRepetitionRule(
 			Predicate<List<UnitPrefix>> prefixRepetitionRule) {
 		this.prefixRepetitionRule = prefixRepetitionRule;
 	}
@@ -2041,18 +2037,18 @@ public final class UnitDatabase {
 	 * <p>
 	 * Specifically, the operations that will throw an IllegalStateException if
 	 * the map is infinite in size are:
+	 * </p>
 	 * <ul>
 	 * <li>{@code unitMap.entrySet().toArray()} (either overloading)</li>
 	 * <li>{@code unitMap.keySet().toArray()} (either overloading)</li>
 	 * </ul>
-	 * </p>
 	 * <p>
 	 * Because of ambiguities between prefixes (i.e. kilokilo = mega), the map's
 	 * {@link PrefixedUnitMap#containsValue containsValue} and
 	 * {@link PrefixedUnitMap#values() values()} methods currently ignore
 	 * prefixes.
 	 * </p>
-	 * 
+	 *
 	 * @return a map mapping unit names to units, including prefixed names
 	 * @since 2019-04-13
 	 * @since v0.2.0
@@ -2073,10 +2069,17 @@ public final class UnitDatabase {
 	public Map<String, Unit> unitMapPrefixless(boolean includeDuplicates) {
 		if (includeDuplicates)
 			return Collections.unmodifiableMap(this.prefixlessUnits);
-		else
-			return Collections.unmodifiableMap(ConditionalExistenceCollections
-					.conditionalExistenceMap(this.prefixlessUnits,
-							entry -> !isRemovableDuplicate(this.prefixlessUnits,
-									entry)));
+		return Collections.unmodifiableMap(ConditionalExistenceCollections
+				.conditionalExistenceMap(this.prefixlessUnits,
+						entry -> !isRemovableDuplicate(this.prefixlessUnits, entry)));
+	}
+
+	/**
+	 * @return an unmodifiable map mapping names to unit sets
+	 * @since 2024-08-16
+	 * @since v1.0.0
+	 */
+	public Map<String, List<LinearUnit>> unitSetMap() {
+		return Collections.unmodifiableMap(this.unitSets);
 	}
 }
diff --git a/src/main/java/sevenUnits/unit/UnitPrefix.java b/src/main/java/sevenUnits/unit/UnitPrefix.java
index 9035969..af106b9 100644
--- a/src/main/java/sevenUnits/unit/UnitPrefix.java
+++ b/src/main/java/sevenUnits/unit/UnitPrefix.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -25,17 +25,19 @@ import sevenUnits.utils.Nameable;
 /**
  * A prefix that can be applied to a {@code LinearUnit} to multiply it by some
  * value
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public final class UnitPrefix implements Nameable {
 	/**
 	 * Gets a {@code UnitPrefix} from a multiplier
-	 * 
+	 *
 	 * @param multiplier multiplier of prefix
 	 * @return prefix
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public static UnitPrefix valueOf(final double multiplier) {
 		return new UnitPrefix(multiplier, NameSymbol.EMPTY);
@@ -43,11 +45,12 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * Gets a {@code UnitPrefix} from a multiplier and a name
-	 * 
+	 *
 	 * @param multiplier multiplier of prefix
 	 * @param ns         name(s) and symbol of prefix
 	 * @return prefix
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if ns is null
 	 */
 	public static UnitPrefix valueOf(final double multiplier,
@@ -58,21 +61,23 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * This prefix's name(s) and symbol.
-	 * 
+	 *
 	 * @since 2022-04-16
+	 * @since v0.4.0
 	 */
 	private final NameSymbol nameSymbol;
 
 	/**
 	 * The number that this prefix multiplies units by
-	 * 
+	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	private final double multiplier;
 
 	/**
 	 * Creates the {@code DefaultUnitPrefix}.
-	 * 
+	 *
 	 * @param multiplier
 	 * @since 2019-01-14
 	 * @since v0.2.0
@@ -84,10 +89,11 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * Divides this prefix by a scalar
-	 * 
+	 *
 	 * @param divisor number to divide by
 	 * @return quotient of prefix and scalar
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public UnitPrefix dividedBy(final double divisor) {
 		return valueOf(this.getMultiplier() / divisor);
@@ -95,7 +101,7 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * Divides this prefix by {@code other}.
-	 * 
+	 *
 	 * @param other prefix to divide by
 	 * @return quotient of prefixes
 	 * @since 2019-04-13
@@ -107,18 +113,32 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses the prefix's multiplier to determine equality.
 	 */
 	@Override
 	public boolean equals(final Object obj) {
 		if (this == obj)
 			return true;
-		if (obj == null)
+		if ((obj == null) || !(obj instanceof UnitPrefix))
 			return false;
-		if (!(obj instanceof UnitPrefix))
+		final var other = (UnitPrefix) obj;
+		return Double.compare(this.getMultiplier(), other.getMultiplier()) == 0;
+	}
+
+	/**
+	 * @param other prefix to compare to
+	 * @return true iff this prefix and other are equal, ignoring small
+	 *         differences caused by floating-point error.
+	 *
+	 * @apiNote This method is not transitive, so it cannot be used as an equals
+	 *          method.
+	 */
+	public boolean equalsApproximately(final UnitPrefix other) {
+		if (this == other)
+			return true;
+		if (other == null)
 			return false;
-		final UnitPrefix other = (UnitPrefix) obj;
 		return DecimalComparison.equals(this.getMultiplier(),
 				other.getMultiplier());
 	}
@@ -126,6 +146,7 @@ public final class UnitPrefix implements Nameable {
 	/**
 	 * @return prefix's multiplier
 	 * @since 2019-11-26
+	 * @since v0.3.0
 	 */
 	public double getMultiplier() {
 		return this.multiplier;
@@ -138,46 +159,55 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * {@inheritDoc}
-	 * 
+	 *
 	 * Uses the prefix's multiplier to determine a hash code.
 	 */
 	@Override
 	public int hashCode() {
-		return DecimalComparison.hash(this.getMultiplier());
+		return Double.hashCode(this.getMultiplier());
 	}
 
 	/**
-	 * Multiplies this prefix by a scalar
-	 * 
-	 * @param multiplicand number to multiply by
-	 * @return product of prefix and scalar
-	 * @since 2019-10-16
+	 * Subtracts {@code other} from this prefix and returns the result.
+	 *
+	 * @param other prefix to subtract
+	 * @return difference of prefixes
+	 *
+	 * @since 2024-03-03
+	 * @since v0.5.0
 	 */
-	public UnitPrefix times(final double multiplicand) {
-		return valueOf(this.getMultiplier() * multiplicand);
+	public UnitPrefix minus(final UnitPrefix other) {
+		return valueOf(this.getMultiplier() - other.getMultiplier());
 	}
 
 	/**
 	 * Adds {@code other} to this prefix and returns the result.
-	 * 
+	 *
+	 * @param other prefix to add
+	 * @return sum of prefixes
+	 *
 	 * @since 2024-03-03
+	 * @since v0.5.0
 	 */
 	public UnitPrefix plus(final UnitPrefix other) {
 		return valueOf(this.getMultiplier() + other.getMultiplier());
 	}
 
 	/**
-	 * Subtracts {@code other} from this prefix and returns the result.
-	 * 
-	 * @since 2024-03-03
+	 * Multiplies this prefix by a scalar
+	 *
+	 * @param multiplicand number to multiply by
+	 * @return product of prefix and scalar
+	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
-	public UnitPrefix minus(final UnitPrefix other) {
-		return valueOf(this.getMultiplier() - other.getMultiplier());
+	public UnitPrefix times(final double multiplicand) {
+		return valueOf(this.getMultiplier() * multiplicand);
 	}
 
 	/**
 	 * Multiplies this prefix by {@code other}.
-	 * 
+	 *
 	 * @param other prefix to multiply by
 	 * @return product of prefixes
 	 * @since 2019-04-13
@@ -189,7 +219,7 @@ public final class UnitPrefix implements Nameable {
 
 	/**
 	 * Raises this prefix to an exponent.
-	 * 
+	 *
 	 * @param exponent exponent to raise to
 	 * @return result of exponentiation.
 	 * @since 2019-04-13
@@ -199,25 +229,23 @@ public final class UnitPrefix implements Nameable {
 		return valueOf(Math.pow(this.getMultiplier(), exponent));
 	}
 
-	/**
-	 * @return a string describing the prefix and its multiplier
-	 */
+	/** @return a string describing the prefix and its multiplier */
 	@Override
 	public String toString() {
 		if (this.getPrimaryName().isPresent())
 			return String.format("%s (\u00D7 %s)", this.getPrimaryName().get(),
 					this.multiplier);
-		else if (this.getSymbol().isPresent())
+		if (this.getSymbol().isPresent())
 			return String.format("%s (\u00D7 %s)", this.getSymbol().get(),
 					this.multiplier);
-		else
-			return String.format("Unit Prefix (\u00D7 %s)", this.multiplier);
+		return String.format("Unit Prefix (\u00D7 %s)", this.multiplier);
 	}
 
 	/**
 	 * @param ns name(s) and symbol to use
 	 * @return copy of this prefix with provided name(s) and symbol
 	 * @since 2019-11-26
+	 * @since v0.3.0
 	 * @throws NullPointerException if ns is null
 	 */
 	public UnitPrefix withName(final NameSymbol ns) {
diff --git a/src/main/java/sevenUnits/unit/UnitType.java b/src/main/java/sevenUnits/unit/UnitType.java
index 9a87288..b195f13 100644
--- a/src/main/java/sevenUnits/unit/UnitType.java
+++ b/src/main/java/sevenUnits/unit/UnitType.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2022 Adrien Hopkins
+ * Copyright (C) 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -30,9 +30,15 @@ import java.util.function.Predicate;
  * </ul>
  *
  * @since 2022-04-10
+ * @since v0.4.0
  */
 public enum UnitType {
-	METRIC, SEMI_METRIC, NON_METRIC;
+	/** Units that pass {@link Unit#isMetric} */
+	METRIC,
+	/** certain exceptions like the degree Celsius */
+	SEMI_METRIC,
+	/** Non-metric, non-excepted units */
+	NON_METRIC;
 
 	/**
 	 * Determines which type a unit is. The type will be:
@@ -46,13 +52,13 @@ public enum UnitType {
 	 * @param isSemiMetric predicate to determine if a unit is semi-metric
 	 * @return type of unit
 	 * @since 2022-04-18
+	 * @since v0.4.0
 	 */
 	public static final UnitType getType(Unit u, Predicate<Unit> isSemiMetric) {
 		if (isSemiMetric.test(u))
 			return SEMI_METRIC;
-		else if (u.isMetric())
+		if (u.isMetric())
 			return METRIC;
-		else
-			return NON_METRIC;
+		return NON_METRIC;
 	}
 }
diff --git a/src/main/java/sevenUnits/unit/UnitValue.java b/src/main/java/sevenUnits/unit/UnitValue.java
index 2d01831..e24b6e2 100644
--- a/src/main/java/sevenUnits/unit/UnitValue.java
+++ b/src/main/java/sevenUnits/unit/UnitValue.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -17,23 +17,23 @@
 package sevenUnits.unit;
 
 import java.util.Objects;
-import java.util.Optional;
 
 import sevenUnits.utils.NameSymbol;
 
 /**
  * A value expressed in a unit.
- * 
+ *
  * Unless otherwise indicated, all methods in this class throw a
  * {@code NullPointerException} when an argument is null.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2020-07-26
+ * @since v0.3.0
  */
 public final class UnitValue {
 	/**
 	 * Creates a {@code UnitValue} from a unit and the associated value.
-	 * 
+	 *
 	 * @param unit  unit to use
 	 * @param value value to use
 	 * @return {@code UnitValue} instance
@@ -56,67 +56,52 @@ public final class UnitValue {
 	}
 
 	/**
+	 * @param other unit to try to convert to
 	 * @return true if this value can be converted to {@code other}.
 	 * @since 2020-10-01
+	 * @since v0.3.0
 	 */
-	public final boolean canConvertTo(Unit other) {
-		return this.unit.canConvertTo(other);
-	}
-
-	/**
-	 * @return true if this value can be converted to {@code other}.
-	 * @since 2020-10-01
-	 */
-	public final <W> boolean canConvertTo(Unitlike<W> other) {
+	public boolean canConvertTo(Unit other) {
 		return this.unit.canConvertTo(other);
 	}
 
 	/**
-	 * Returns a UnitlikeValue that represents the same value expressed in a
-	 * different unitlike form.
-	 * 
-	 * @param other new unit to express value in
-	 * @return value expressed in {@code other}
-	 */
-	public final <U extends Unitlike<W>, W> UnitlikeValue<U, W> convertTo(
-			U other) {
-		return UnitlikeValue.of(other,
-				this.unit.convertTo(other, this.getValue()));
-	}
-
-	/**
 	 * Returns a UnitValue that represents the same value expressed in a
 	 * different unit
-	 * 
+	 *
 	 * @param other new unit to express value in
 	 * @return value expressed in {@code other}
 	 */
-	public final UnitValue convertTo(Unit other) {
+	public UnitValue convertTo(Unit other) {
 		return UnitValue.of(other,
 				this.getUnit().convertTo(other, this.getValue()));
 	}
 
 	/**
-	 * Returns this unit value represented as a {@code LinearUnitValue} with this
+	 * Returns this unit value represented as a {@link LinearUnitValue} with this
 	 * unit's base unit as the base.
 	 *
 	 * @param ns name and symbol for the base unit, use NameSymbol.EMPTY if not
 	 *           needed.
+	 * @return this unit as a {@link LinearUnitValue}
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final LinearUnitValue convertToBase(NameSymbol ns) {
-		final LinearUnit base = LinearUnit.getBase(this.unit).withName(ns);
+	public LinearUnitValue convertToBase(NameSymbol ns) {
+		final var base = LinearUnit.getBase(this.unit).withName(ns);
 		return this.convertToLinear(base);
 	}
 
 	/**
+	 * @param newUnit unit to use for this value
 	 * @return a {@code LinearUnitValue} that is equivalent to this value. It
 	 *         will have zero uncertainty.
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final LinearUnitValue convertToLinear(LinearUnit other) {
-		return LinearUnitValue.getExact(other,
-				this.getUnit().convertTo(other, this.getValue()));
+	public LinearUnitValue convertToLinear(LinearUnit newUnit) {
+		return LinearUnitValue.getExact(newUnit,
+				this.getUnit().convertTo(newUnit, this.getValue()));
 	}
 
 	/**
@@ -128,7 +113,7 @@ public final class UnitValue {
 	public boolean equals(Object obj) {
 		if (!(obj instanceof UnitValue))
 			return false;
-		final UnitValue other = (UnitValue) obj;
+		final var other = (UnitValue) obj;
 		return Objects.equals(this.getUnit().getBase(), other.getUnit().getBase())
 				&& Double.doubleToLongBits(
 						this.getUnit().convertToBase(this.getValue())) == Double
@@ -139,16 +124,18 @@ public final class UnitValue {
 	/**
 	 * @return the unit
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final Unit getUnit() {
+	public Unit getUnit() {
 		return this.unit;
 	}
 
 	/**
 	 * @return the value
 	 * @since 2020-09-29
+	 * @since v0.3.0
 	 */
-	public final double getValue() {
+	public double getValue() {
 		return this.value;
 	}
 
@@ -160,16 +147,15 @@ public final class UnitValue {
 
 	@Override
 	public String toString() {
-		final Optional<String> primaryName = this.getUnit().getPrimaryName();
-		final Optional<String> symbol = this.getUnit().getSymbol();
+		final var primaryName = this.getUnit().getPrimaryName();
+		final var symbol = this.getUnit().getSymbol();
 		if (primaryName.isEmpty() && symbol.isEmpty()) {
-			final double baseValue = this.getUnit().convertToBase(this.getValue());
+			final var baseValue = this.getUnit().convertToBase(this.getValue());
 			return String.format("%s unnamed unit (= %s %s)", this.getValue(),
 					baseValue, this.getUnit().getBase()
 							.toString(unit -> unit.getSymbol().orElseThrow()));
-		} else {
-			final String unitName = symbol.orElse(primaryName.get());
-			return this.getValue() + " " + unitName;
 		}
+		final var unitName = symbol.orElse(primaryName.get());
+		return this.getValue() + " " + unitName;
 	}
 }
diff --git a/src/main/java/sevenUnits/unit/Unitlike.java b/src/main/java/sevenUnits/unit/Unitlike.java
deleted file mode 100644
index fef424e..0000000
--- a/src/main/java/sevenUnits/unit/Unitlike.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/**
- * Copyright (C) 2020 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package sevenUnits.unit;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.DoubleFunction;
-import java.util.function.ToDoubleFunction;
-
-import sevenUnits.utils.NameSymbol;
-import sevenUnits.utils.Nameable;
-import sevenUnits.utils.ObjectProduct;
-
-/**
- * An object that can convert a value between multiple forms (instances of the
- * object); like a unit but the "converted value" can be any type.
- *
- * @since 2020-09-07
- */
-public abstract class Unitlike<V> implements Nameable {
-	/**
-	 * Returns a unitlike form from its base and the functions it uses to convert
-	 * to and from its base.
-	 * 
-	 * @param base          unitlike form's base
-	 * @param converterFrom function that accepts a value expressed in the
-	 *                      unitlike form's base and returns that value expressed
-	 *                      in this unitlike form.
-	 * @param converterTo   function that accepts a value expressed in the
-	 *                      unitlike form and returns that value expressed in the
-	 *                      unit's base.
-	 * @return a unitlike form that uses the provided functions to convert.
-	 * @since 2020-09-07
-	 * @throws NullPointerException if any argument is null
-	 */
-	public static final <W> Unitlike<W> fromConversionFunctions(
-			final ObjectProduct<BaseUnit> base,
-			final DoubleFunction<W> converterFrom,
-			final ToDoubleFunction<W> converterTo) {
-		return new FunctionalUnitlike<>(base, NameSymbol.EMPTY, converterFrom,
-				converterTo);
-	}
-
-	/**
-	 * Returns a unitlike form from its base and the functions it uses to convert
-	 * to and from its base.
-	 * 
-	 * @param base          unitlike form's base
-	 * @param converterFrom function that accepts a value expressed in the
-	 *                      unitlike form's base and returns that value expressed
-	 *                      in this unitlike form.
-	 * @param converterTo   function that accepts a value expressed in the
-	 *                      unitlike form and returns that value expressed in the
-	 *                      unit's base.
-	 * @param ns            names and symbol of unit
-	 * @return a unitlike form that uses the provided functions to convert.
-	 * @since 2020-09-07
-	 * @throws NullPointerException if any argument is null
-	 */
-	public static final <W> Unitlike<W> fromConversionFunctions(
-			final ObjectProduct<BaseUnit> base,
-			final DoubleFunction<W> converterFrom,
-			final ToDoubleFunction<W> converterTo, final NameSymbol ns) {
-		return new FunctionalUnitlike<>(base, ns, converterFrom, converterTo);
-	}
-
-	/**
-	 * The combination of units that this unit is based on.
-	 * 
-	 * @since 2019-10-16
-	 */
-	private final ObjectProduct<BaseUnit> unitBase;
-
-	/**
-	 * This unit's name(s) and symbol
-	 * 
-	 * @since 2020-09-07
-	 */
-	private final NameSymbol nameSymbol;
-
-	/**
-	 * Cache storing the result of getDimension()
-	 *
-	 * @since 2019-10-16
-	 */
-	private transient ObjectProduct<BaseDimension> dimension = null;
-
-	/**
-	 * @param unitBase
-	 * @since 2020-09-07
-	 */
-	protected Unitlike(ObjectProduct<BaseUnit> unitBase, NameSymbol ns) {
-		this.unitBase = Objects.requireNonNull(unitBase,
-				"unitBase may not be null");
-		this.nameSymbol = Objects.requireNonNull(ns, "ns may not be null");
-	}
-
-	/**
-	 * Checks if a value expressed in this unitlike form can be converted to a
-	 * value expressed in {@code other}
-	 * 
-	 * @param other unit or unitlike form to test with
-	 * @return true if they are compatible
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 * @throws NullPointerException if other is null
-	 */
-	public final boolean canConvertTo(final Unit other) {
-		Objects.requireNonNull(other, "other must not be null.");
-		return Objects.equals(this.getBase(), other.getBase());
-	}
-
-	/**
-	 * Checks if a value expressed in this unitlike form can be converted to a
-	 * value expressed in {@code other}
-	 * 
-	 * @param other unit or unitlike form to test with
-	 * @return true if they are compatible
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 * @throws NullPointerException if other is null
-	 */
-	public final <W> boolean canConvertTo(final Unitlike<W> other) {
-		Objects.requireNonNull(other, "other must not be null.");
-		return Objects.equals(this.getBase(), other.getBase());
-	}
-
-	protected abstract V convertFromBase(double value);
-
-	/**
-	 * Converts a value expressed in this unitlike form to a value expressed in
-	 * {@code other}.
-	 * 
-	 * @implSpec If conversion is possible, this implementation returns
-	 *           {@code other.convertFromBase(this.convertToBase(value))}.
-	 *           Therefore, overriding either of those methods will change the
-	 *           output of this method.
-	 * 
-	 * @param other unit to convert to
-	 * @param value value to convert
-	 * @return converted value
-	 * @since 2019-05-22
-	 * @throws IllegalArgumentException if {@code other} is incompatible for
-	 *                                  conversion with this unitlike form (as
-	 *                                  tested by {@link Unit#canConvertTo}).
-	 * @throws NullPointerException     if other is null
-	 */
-	public final double convertTo(final Unit other, final V value) {
-		Objects.requireNonNull(other, "other must not be null.");
-		if (this.canConvertTo(other))
-			return other.convertFromBase(this.convertToBase(value));
-		else
-			throw new IllegalArgumentException(
-					String.format("Cannot convert from %s to %s.", this, other));
-	}
-
-	/**
-	 * Converts a value expressed in this unitlike form to a value expressed in
-	 * {@code other}.
-	 * 
-	 * @implSpec If conversion is possible, this implementation returns
-	 *           {@code other.convertFromBase(this.convertToBase(value))}.
-	 *           Therefore, overriding either of those methods will change the
-	 *           output of this method.
-	 * 
-	 * @param other unitlike form to convert to
-	 * @param value value to convert
-	 * @param <W>   type of value to convert to
-	 * @return converted value
-	 * @since 2020-09-07
-	 * @throws IllegalArgumentException if {@code other} is incompatible for
-	 *                                  conversion with this unitlike form (as
-	 *                                  tested by {@link Unit#canConvertTo}).
-	 * @throws NullPointerException     if other is null
-	 */
-	public final <W> W convertTo(final Unitlike<W> other, final V value) {
-		Objects.requireNonNull(other, "other must not be null.");
-		if (this.canConvertTo(other))
-			return other.convertFromBase(this.convertToBase(value));
-		else
-			throw new IllegalArgumentException(
-					String.format("Cannot convert from %s to %s.", this, other));
-	}
-
-	protected abstract double convertToBase(V value);
-
-	/**
-	 * @return combination of units that this unit is based on
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public final ObjectProduct<BaseUnit> getBase() {
-		return this.unitBase;
-	}
-
-	/**
-	 * @return dimension measured by this unit
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public final ObjectProduct<BaseDimension> getDimension() {
-		if (this.dimension == null) {
-			final Map<BaseUnit, Integer> mapping = this.unitBase.exponentMap();
-			final Map<BaseDimension, Integer> dimensionMap = new HashMap<>();
-
-			for (final BaseUnit key : mapping.keySet()) {
-				dimensionMap.put(key.getBaseDimension(), mapping.get(key));
-			}
-
-			this.dimension = ObjectProduct.fromExponentMapping(dimensionMap);
-		}
-		return this.dimension;
-	}
-
-	/**
-	 * @return the nameSymbol
-	 * @since 2020-09-07
-	 */
-	@Override
-	public final NameSymbol getNameSymbol() {
-		return this.nameSymbol;
-	}
-
-	@Override
-	public String toString() {
-		return this.getPrimaryName().orElse("Unnamed unitlike form")
-				+ (this.getSymbol().isPresent()
-						? String.format(" (%s)", this.getSymbol().get())
-						: "")
-				+ ", derived from "
-				+ this.getBase().toString(u -> u.getSymbol().get())
-				+ (this.getOtherNames().isEmpty() ? ""
-						: ", also called " + String.join(", ", this.getOtherNames()));
-	}
-
-	/**
-	 * @param ns name(s) and symbol to use
-	 * @return a copy of this unitlike form with provided name(s) and symbol
-	 * @since 2020-09-07
-	 * @throws NullPointerException if ns is null
-	 */
-	public Unitlike<V> withName(final NameSymbol ns) {
-		return fromConversionFunctions(this.getBase(), this::convertFromBase,
-				this::convertToBase,
-				Objects.requireNonNull(ns, "ns must not be null."));
-	}
-}
diff --git a/src/main/java/sevenUnits/unit/UnitlikeValue.java b/src/main/java/sevenUnits/unit/UnitlikeValue.java
deleted file mode 100644
index ad0d1ea..0000000
--- a/src/main/java/sevenUnits/unit/UnitlikeValue.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- * Copyright (C) 2020 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package sevenUnits.unit;
-
-import java.util.Optional;
-
-import sevenUnits.utils.NameSymbol;
-
-/**
- *
- * @since 2020-09-07
- */
-final class UnitlikeValue<T extends Unitlike<V>, V> {
-	/**
-	 * Gets a {@code UnitlikeValue<V>}.
-	 *
-	 * @since 2020-10-02
-	 */
-	public static <T extends Unitlike<V>, V> UnitlikeValue<T, V> of(T unitlike,
-			V value) {
-		return new UnitlikeValue<>(unitlike, value);
-	}
-
-	private final T unitlike;
-	private final V value;
-
-	/**
-	 * @param unitlike
-	 * @param value
-	 * @since 2020-09-07
-	 */
-	private UnitlikeValue(T unitlike, V value) {
-		this.unitlike = unitlike;
-		this.value = value;
-	}
-
-	/**
-	 * @return true if this value can be converted to {@code other}.
-	 * @since 2020-10-01
-	 */
-	public final boolean canConvertTo(Unit other) {
-		return this.unitlike.canConvertTo(other);
-	}
-
-	/**
-	 * @return true if this value can be converted to {@code other}.
-	 * @since 2020-10-01
-	 */
-	public final <W> boolean canConvertTo(Unitlike<W> other) {
-		return this.unitlike.canConvertTo(other);
-	}
-
-	/**
-	 * Returns a UnitlikeValue that represents the same value expressed in a
-	 * different unitlike form.
-	 * 
-	 * @param other new unit to express value in
-	 * @return value expressed in {@code other}
-	 */
-	public final <U extends Unitlike<W>, W> UnitlikeValue<U, W> convertTo(
-			U other) {
-		return UnitlikeValue.of(other,
-				this.unitlike.convertTo(other, this.getValue()));
-	}
-
-	/**
-	 * Returns a UnitValue that represents the same value expressed in a
-	 * different unit
-	 * 
-	 * @param other new unit to express value in
-	 * @return value expressed in {@code other}
-	 */
-	public final UnitValue convertTo(Unit other) {
-		return UnitValue.of(other,
-				this.unitlike.convertTo(other, this.getValue()));
-	}
-
-	/**
-	 * Returns this unit value represented as a {@code LinearUnitValue} with this
-	 * unit's base unit as the base.
-	 *
-	 * @param ns name and symbol for the base unit, use NameSymbol.EMPTY if not
-	 *           needed.
-	 * @since 2020-09-29
-	 */
-	public final LinearUnitValue convertToBase(NameSymbol ns) {
-		final LinearUnit base = LinearUnit.getBase(this.unitlike).withName(ns);
-		return this.convertToLinear(base);
-	}
-
-	/**
-	 * @return a {@code LinearUnitValue} that is equivalent to this value. It
-	 *         will have zero uncertainty.
-	 * @since 2020-09-29
-	 */
-	public final LinearUnitValue convertToLinear(LinearUnit other) {
-		return LinearUnitValue.getExact(other,
-				this.getUnitlike().convertTo(other, this.getValue()));
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (!(obj instanceof UnitlikeValue))
-			return false;
-		final UnitlikeValue<?, ?> other = (UnitlikeValue<?, ?>) obj;
-		if (this.getUnitlike() == null) {
-			if (other.getUnitlike() != null)
-				return false;
-		} else if (!this.getUnitlike().equals(other.getUnitlike()))
-			return false;
-		if (this.getValue() == null) {
-			if (other.getValue() != null)
-				return false;
-		} else if (!this.getValue().equals(other.getValue()))
-			return false;
-		return true;
-	}
-
-	/**
-	 * @return the unitlike
-	 * @since 2020-09-29
-	 */
-	public final Unitlike<V> getUnitlike() {
-		return this.unitlike;
-	}
-
-	/**
-	 * @return the value
-	 * @since 2020-09-29
-	 */
-	public final V getValue() {
-		return this.value;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result
-				+ (this.getUnitlike() == null ? 0 : this.getUnitlike().hashCode());
-		result = prime * result
-				+ (this.getValue() == null ? 0 : this.getValue().hashCode());
-		return result;
-	}
-
-	@Override
-	public String toString() {
-		final Optional<String> primaryName = this.getUnitlike().getPrimaryName();
-		final Optional<String> symbol = this.getUnitlike().getSymbol();
-		if (primaryName.isEmpty() && symbol.isEmpty()) {
-			final double baseValue = this.getUnitlike()
-					.convertToBase(this.getValue());
-			return String.format("%s unnamed unit (= %s %s)", this.getValue(),
-					baseValue, this.getUnitlike().getBase());
-		} else {
-			final String unitName = symbol.orElse(primaryName.get());
-			return this.getValue() + " " + unitName;
-		}
-	}
-}
diff --git a/src/main/java/sevenUnits/unit/package-info.java b/src/main/java/sevenUnits/unit/package-info.java
index 6aedb9d..c650b58 100644
--- a/src/main/java/sevenUnits/unit/package-info.java
+++ b/src/main/java/sevenUnits/unit/package-info.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019-2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -16,7 +16,7 @@
  */
 /**
  * Everything to do with the units that make up Unit Converter.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-16
  * @since v0.1.0
diff --git a/src/main/java/sevenUnits/utils/ConditionalExistenceCollections.java b/src/main/java/sevenUnits/utils/ConditionalExistenceCollections.java
index b71a4e0..6244ee6 100644
--- a/src/main/java/sevenUnits/utils/ConditionalExistenceCollections.java
+++ b/src/main/java/sevenUnits/utils/ConditionalExistenceCollections.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -49,18 +49,19 @@ import java.util.function.Predicate;
  * Other than that, <i>the only difference between the provided collections and
  * the returned collections are that elements don't exist if they don't pass the
  * provided condition</i>.
- * 
- * 
+ *
+ *
  * @author Adrien Hopkins
  * @since 2019-10-17
+ * @since v0.3.0
  */
-// TODO add conditional existence Lists and Sorted/Navigable Sets/Maps
 public final class ConditionalExistenceCollections {
 	/**
 	 * Elements in this collection only exist if they meet a condition.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 * @param <E> type of element in collection
 	 */
 	static final class ConditionalExistenceCollection<E>
@@ -70,10 +71,11 @@ public final class ConditionalExistenceCollections {
 
 		/**
 		 * Creates the {@code ConditionalExistenceCollection}.
-		 * 
+		 *
 		 * @param collection
 		 * @param existenceCondition
 		 * @since 2019-10-17
+		 * @since v0.3.0
 		 */
 		private ConditionalExistenceCollection(final Collection<E> collection,
 				final Predicate<E> existenceCondition) {
@@ -101,7 +103,7 @@ public final class ConditionalExistenceCollections {
 			// instance of E
 			// therefore this cast will always work
 			@SuppressWarnings("unchecked")
-			final E e = (E) o;
+			final var e = (E) o;
 
 			return this.existenceCondition.test(e);
 		}
@@ -116,7 +118,7 @@ public final class ConditionalExistenceCollections {
 		public boolean remove(final Object o) {
 			// remove() must be first in the && statement, otherwise it may not
 			// execute
-			final boolean containedObject = this.contains(o);
+			final var containedObject = this.contains(o);
 			return this.collection.remove(o) && containedObject;
 		}
 
@@ -147,9 +149,10 @@ public final class ConditionalExistenceCollections {
 
 	/**
 	 * Elements in this wrapper iterator only exist if they pass a condition.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 * @param <E> type of elements in iterator
 	 */
 	static final class ConditionalExistenceIterator<E> implements Iterator<E> {
@@ -160,10 +163,11 @@ public final class ConditionalExistenceCollections {
 
 		/**
 		 * Creates the {@code ConditionalExistenceIterator}.
-		 * 
+		 *
 		 * @param iterator
 		 * @param condition
 		 * @since 2019-10-17
+		 * @since v0.3.0
 		 */
 		private ConditionalExistenceIterator(final Iterator<E> iterator,
 				final Predicate<E> condition) {
@@ -174,8 +178,9 @@ public final class ConditionalExistenceCollections {
 
 		/**
 		 * Gets the next element, and sets nextElement and hasNext accordingly.
-		 * 
+		 *
 		 * @since 2019-10-17
+		 * @since v0.3.0
 		 */
 		private void getAndSetNextElement() {
 			do {
@@ -197,11 +202,11 @@ public final class ConditionalExistenceCollections {
 		@Override
 		public E next() {
 			if (this.hasNext()) {
-				final E next = this.nextElement;
+				final var next = this.nextElement;
 				this.getAndSetNextElement();
 				return next;
-			} else
-				throw new NoSuchElementException();
+			}
+			throw new NoSuchElementException();
 		}
 
 		@Override
@@ -212,9 +217,10 @@ public final class ConditionalExistenceCollections {
 
 	/**
 	 * Mappings in this map only exist if the entry passes some condition.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 * @param <K> key type
 	 * @param <V> value type
 	 */
@@ -224,10 +230,11 @@ public final class ConditionalExistenceCollections {
 
 		/**
 		 * Creates the {@code ConditionalExistenceMap}.
-		 * 
+		 *
 		 * @param map
 		 * @param entryExistenceCondition
 		 * @since 2019-10-17
+		 * @since v0.3.0
 		 */
 		private ConditionalExistenceMap(final Map<K, V> map,
 				final Predicate<Entry<K, V>> entryExistenceCondition) {
@@ -243,10 +250,10 @@ public final class ConditionalExistenceCollections {
 			// only instances of K have mappings in the backing map
 			// since we know that key is a valid key, it must be an instance of K
 			@SuppressWarnings("unchecked")
-			final K keyAsK = (K) key;
+			final var keyAsK = (K) key;
 
 			// get and test entry
-			final V value = this.map.get(key);
+			final var value = this.map.get(key);
 			final Entry<K, V> entry = new SimpleEntry<>(keyAsK, value);
 			return this.entryExistenceCondition.test(entry);
 		}
@@ -262,7 +269,7 @@ public final class ConditionalExistenceCollections {
 			return this.containsKey(key) ? this.map.get(key) : null;
 		}
 
-		private final Entry<K, V> getEntry(K key) {
+		private Entry<K, V> getEntry(K key) {
 			return new Entry<>() {
 				@Override
 				public K getKey() {
@@ -289,7 +296,7 @@ public final class ConditionalExistenceCollections {
 
 		@Override
 		public V put(final K key, final V value) {
-			final V oldValue = this.map.put(key, value);
+			final var oldValue = this.map.put(key, value);
 
 			// get and test entry
 			final Entry<K, V> entry = new SimpleEntry<>(key, oldValue);
@@ -298,7 +305,7 @@ public final class ConditionalExistenceCollections {
 
 		@Override
 		public V remove(final Object key) {
-			final V oldValue = this.map.remove(key);
+			final var oldValue = this.map.remove(key);
 			return this.containsKey(key) ? oldValue : null;
 		}
 
@@ -311,9 +318,10 @@ public final class ConditionalExistenceCollections {
 
 	/**
 	 * Elements in this set only exist if a certain condition is true.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 * @param <E> type of element in set
 	 */
 	static final class ConditionalExistenceSet<E> extends AbstractSet<E> {
@@ -322,10 +330,11 @@ public final class ConditionalExistenceCollections {
 
 		/**
 		 * Creates the {@code ConditionalNonexistenceSet}.
-		 * 
+		 *
 		 * @param set                set to use
 		 * @param existenceCondition condition where element exists
 		 * @since 2019-10-17
+		 * @since v0.3.0
 		 */
 		private ConditionalExistenceSet(final Set<E> set,
 				final Predicate<E> existenceCondition) {
@@ -359,7 +368,7 @@ public final class ConditionalExistenceCollections {
 			// of E
 			// therefore this cast will always work
 			@SuppressWarnings("unchecked")
-			final E e = (E) o;
+			final var e = (E) o;
 
 			return this.existenceCondition.test(e);
 		}
@@ -374,7 +383,7 @@ public final class ConditionalExistenceCollections {
 		public boolean remove(final Object o) {
 			// remove() must be first in the && statement, otherwise it may not
 			// execute
-			final boolean containedObject = this.contains(o);
+			final var containedObject = this.contains(o);
 			return this.set.remove(o) && containedObject;
 		}
 
@@ -405,14 +414,15 @@ public final class ConditionalExistenceCollections {
 	/**
 	 * Elements in the returned wrapper collection are ignored if they don't pass
 	 * a condition.
-	 * 
+	 *
 	 * @param <E>                type of elements in collection
 	 * @param collection         collection to wrap
 	 * @param existenceCondition elements only exist if this returns true
 	 * @return wrapper collection
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 */
-	public static final <E> Collection<E> conditionalExistenceCollection(
+	public static <E> Collection<E> conditionalExistenceCollection(
 			final Collection<E> collection,
 			final Predicate<E> existenceCondition) {
 		return new ConditionalExistenceCollection<>(collection,
@@ -422,14 +432,15 @@ public final class ConditionalExistenceCollections {
 	/**
 	 * Elements in the returned wrapper iterator are ignored if they don't pass a
 	 * condition.
-	 * 
+	 *
 	 * @param <E>                type of elements in iterator
 	 * @param iterator           iterator to wrap
 	 * @param existenceCondition elements only exist if this returns true
 	 * @return wrapper iterator
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 */
-	public static final <E> Iterator<E> conditionalExistenceIterator(
+	public static <E> Iterator<E> conditionalExistenceIterator(
 			final Iterator<E> iterator, final Predicate<E> existenceCondition) {
 		return new ConditionalExistenceIterator<>(iterator, existenceCondition);
 	}
@@ -437,16 +448,16 @@ public final class ConditionalExistenceCollections {
 	/**
 	 * Mappings in the returned wrapper map are ignored if the corresponding
 	 * entry doesn't pass a condition
-	 * 
+	 *
 	 * @param <K>                     type of key in map
 	 * @param <V>                     type of value in map
 	 * @param map                     map to wrap
 	 * @param entryExistenceCondition mappings only exist if this returns true
 	 * @return wrapper map
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 */
-	public static final <K, V> Map<K, V> conditionalExistenceMap(
-			final Map<K, V> map,
+	public static <K, V> Map<K, V> conditionalExistenceMap(final Map<K, V> map,
 			final Predicate<Entry<K, V>> entryExistenceCondition) {
 		return new ConditionalExistenceMap<>(map, entryExistenceCondition);
 	}
@@ -454,14 +465,15 @@ public final class ConditionalExistenceCollections {
 	/**
 	 * Elements in the returned wrapper set are ignored if they don't pass a
 	 * condition.
-	 * 
+	 *
 	 * @param <E>                type of elements in set
 	 * @param set                set to wrap
 	 * @param existenceCondition elements only exist if this returns true
 	 * @return wrapper set
 	 * @since 2019-10-17
+	 * @since v0.3.0
 	 */
-	public static final <E> Set<E> conditionalExistenceSet(final Set<E> set,
+	public static <E> Set<E> conditionalExistenceSet(final Set<E> set,
 			final Predicate<E> existenceCondition) {
 		return new ConditionalExistenceSet<>(set, existenceCondition);
 	}
diff --git a/src/main/java/sevenUnits/utils/DecimalComparison.java b/src/main/java/sevenUnits/utils/DecimalComparison.java
index 0515b6b..1366fd3 100644
--- a/src/main/java/sevenUnits/utils/DecimalComparison.java
+++ b/src/main/java/sevenUnits/utils/DecimalComparison.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -20,7 +20,7 @@ import java.math.BigDecimal;
 
 /**
  * A class that contains methods to compare float and double values.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-03-18
  * @since v0.2.0
@@ -29,7 +29,7 @@ public final class DecimalComparison {
 	/**
 	 * The value used for double comparison. If two double values are within this
 	 * value multiplied by the larger value, they are considered equal.
-	 * 
+	 *
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
@@ -38,7 +38,7 @@ public final class DecimalComparison {
 	/**
 	 * The value used for float comparison. If two float values are within this
 	 * value multiplied by the larger value, they are considered equal.
-	 * 
+	 *
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
@@ -63,21 +63,20 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code double} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a first value to test
 	 * @param b second value to test
 	 * @return whether they are equal
 	 * @since 2019-03-18
 	 * @since v0.2.0
-	 * @see #hashCode(double)
 	 */
-	public static final boolean equals(final double a, final double b) {
+	public static boolean equals(final double a, final double b) {
 		return DecimalComparison.equals(a, b, DOUBLE_EPSILON);
 	}
 
 	/**
 	 * Tests for double equality using a custom epsilon value.
-	 * 
+	 *
 	 * <p>
 	 * <strong>WARNING: </strong>this method is not technically transitive. If a
 	 * and b are off by slightly less than {@code epsilon * max(abs(a), abs(b))},
@@ -94,7 +93,7 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code double} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a       first value to test
 	 * @param b       second value to test
 	 * @param epsilon allowed difference
@@ -102,14 +101,14 @@ public final class DecimalComparison {
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
-	public static final boolean equals(final double a, final double b,
+	public static boolean equals(final double a, final double b,
 			final double epsilon) {
 		return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
 	}
 
 	/**
 	 * Tests for equality of float values using {@link #FLOAT_EPSILON}.
-	 * 
+	 *
 	 * <p>
 	 * <strong>WARNING: </strong>this method is not technically transitive. If a
 	 * and b are off by slightly less than {@code epsilon * max(abs(a), abs(b))},
@@ -126,20 +125,20 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code float} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a first value to test
 	 * @param b second value to test
 	 * @return whether they are equal
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
-	public static final boolean equals(final float a, final float b) {
+	public static boolean equals(final float a, final float b) {
 		return DecimalComparison.equals(a, b, FLOAT_EPSILON);
 	}
 
 	/**
 	 * Tests for float equality using a custom epsilon value.
-	 * 
+	 *
 	 * <p>
 	 * <strong>WARNING: </strong>this method is not technically transitive. If a
 	 * and b are off by slightly less than {@code epsilon * max(abs(a), abs(b))},
@@ -156,7 +155,7 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code float} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a       first value to test
 	 * @param b       second value to test
 	 * @param epsilon allowed difference
@@ -164,7 +163,7 @@ public final class DecimalComparison {
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
-	public static final boolean equals(final float a, final float b,
+	public static boolean equals(final float a, final float b,
 			final float epsilon) {
 		return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
 	}
@@ -189,14 +188,14 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code double} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a first value to test
 	 * @param b second value to test
 	 * @return whether they are equal
 	 * @since 2020-09-07
-	 * @see #hashCode(double)
+	 * @since v0.3.0
 	 */
-	public static final boolean equals(final UncertainDouble a,
+	public static boolean equals(final UncertainDouble a,
 			final UncertainDouble b) {
 		return DecimalComparison.equals(a.value(), b.value())
 				&& DecimalComparison.equals(a.uncertainty(), b.uncertainty());
@@ -204,7 +203,7 @@ public final class DecimalComparison {
 
 	/**
 	 * Tests for {@code UncertainDouble} equality using a custom epsilon value.
-	 * 
+	 *
 	 * <p>
 	 * <strong>WARNING: </strong>this method is not technically transitive. If a
 	 * and b are off by slightly less than {@code epsilon * max(abs(a), abs(b))},
@@ -221,7 +220,7 @@ public final class DecimalComparison {
 	 * <li>Use {@link BigDecimal} instead of {@code double} (this will make a
 	 * violation of transitivity 100% impossible)
 	 * </ol>
-	 * 
+	 *
 	 * @param a       first value to test
 	 * @param b       second value to test
 	 * @param epsilon allowed difference
@@ -229,25 +228,13 @@ public final class DecimalComparison {
 	 * @since 2019-03-18
 	 * @since v0.2.0
 	 */
-	public static final boolean equals(final UncertainDouble a,
+	public static boolean equals(final UncertainDouble a,
 			final UncertainDouble b, final double epsilon) {
 		return DecimalComparison.equals(a.value(), b.value(), epsilon)
 				&& DecimalComparison.equals(a.uncertainty(), b.uncertainty(),
 						epsilon);
 	}
 
-	/**
-	 * Takes the hash code of doubles. Values that are equal according to
-	 * {@link #equals(double, double)} will have the same hash code.
-	 * 
-	 * @param d double to hash
-	 * @return hash code of double
-	 * @since 2019-10-16
-	 */
-	public static final int hash(final double d) {
-		return Float.hashCode((float) d);
-	}
-
 	// You may NOT get any DecimalComparison instances
 	private DecimalComparison() {
 		throw new AssertionError();
diff --git a/src/main/java/sevenUnits/utils/ExpressionParser.java b/src/main/java/sevenUnits/utils/ExpressionParser.java
index e248ff0..03c763c 100644
--- a/src/main/java/sevenUnits/utils/ExpressionParser.java
+++ b/src/main/java/sevenUnits/utils/ExpressionParser.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019, 2024 Adrien Hopkins
+ * Copyright (C) 2019, 2021, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -31,7 +31,7 @@ import java.util.function.UnaryOperator;
 
 /**
  * An object that can parse expressions with unary or binary operators.
- * 
+ *
  * @author Adrien Hopkins
  * @param <T> type of object that exists in parsed expressions
  * @since 2019-03-14
@@ -40,7 +40,7 @@ import java.util.function.UnaryOperator;
 public final class ExpressionParser<T> {
 	/**
 	 * A builder that can create {@code ExpressionParser<T>} instances.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @param <T> type of object that exists in parsed expressions
 	 * @since 2019-03-17
@@ -51,7 +51,7 @@ public final class ExpressionParser<T> {
 		 * A function that obtains a parseable object from a string. For example,
 		 * an integer {@code ExpressionParser} would use
 		 * {@code Integer::parseInt}.
-		 * 
+		 *
 		 * @since 2019-03-14
 		 * @since v0.2.0
 		 */
@@ -59,7 +59,7 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * The function of the space as an operator (like 3 x y)
-		 * 
+		 *
 		 * @since 2019-03-22
 		 * @since v0.2.0
 		 */
@@ -68,7 +68,7 @@ public final class ExpressionParser<T> {
 		/**
 		 * A map mapping operator strings to operator functions, for unary
 		 * operators.
-		 * 
+		 *
 		 * @since 2019-03-14
 		 * @since v0.2.0
 		 */
@@ -77,7 +77,7 @@ public final class ExpressionParser<T> {
 		/**
 		 * A map mapping operator strings to operator functions, for binary
 		 * operators.
-		 * 
+		 *
 		 * @since 2019-03-14
 		 * @since v0.2.0
 		 */
@@ -85,14 +85,15 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * A map mapping operator strings to numeric functions.
-		 * 
+		 *
 		 * @since 2024-03-23
+		 * @since v0.5.0
 		 */
 		private final Map<String, PriorityBiFunction<T, UncertainDouble, T>> numericOperators;
 
 		/**
 		 * Creates the {@code Builder}.
-		 * 
+		 *
 		 * @param objectObtainer a function that can turn strings into objects of
 		 *                       the type handled by the parser.
 		 * @throws NullPointerException if {@code objectObtainer} is null
@@ -109,7 +110,7 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Adds a binary operator to the builder.
-		 * 
+		 *
 		 * @param text     text used to reference the operator, like '+'
 		 * @param operator operator to add
 		 * @param priority operator's priority, which determines which operators
@@ -142,7 +143,7 @@ public final class ExpressionParser<T> {
 		/**
 		 * Adds a two-argument operator where the second operator is a number.
 		 * This is used for operations like vector scaling and exponentation.
-		 * 
+		 *
 		 * @param text     text used to reference the operator, like '^'
 		 * @param operator operator to add
 		 * @param priority operator's priority, which determines which operators
@@ -172,7 +173,7 @@ public final class ExpressionParser<T> {
 		/**
 		 * Adds a function for spaces. You must use the text of an existing binary
 		 * operator.
-		 * 
+		 *
 		 * @param operator text of operator to use
 		 * @return this builder
 		 * @since 2019-03-22
@@ -191,7 +192,7 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Adds a unary operator to the builder.
-		 * 
+		 *
 		 * @param text     text used to reference the operator, like '-'
 		 * @param operator operator to add
 		 * @param priority operator's priority, which determines which operators
@@ -235,18 +236,18 @@ public final class ExpressionParser<T> {
 	/**
 	 * A binary operator with a priority field that determines which operators
 	 * apply first.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @param <T> type of operand and result
 	 * @since 2019-03-17
 	 * @since v0.2.0
 	 */
-	private static abstract class PriorityBinaryOperator<T>
-			implements BinaryOperator<T>, Comparable<PriorityBinaryOperator<T>> {
+	private static abstract class PriorityBiFunction<T, U, R> implements
+			BiFunction<T, U, R>, Comparable<PriorityBiFunction<T, U, R>> {
 		/**
 		 * The operator's priority. Higher-priority operators are applied before
 		 * lower-priority operators
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
@@ -254,33 +255,32 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Creates the {@code PriorityBinaryOperator}.
-		 * 
+		 *
 		 * @param priority operator's priority
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
-		public PriorityBinaryOperator(final int priority) {
+		public PriorityBiFunction(final int priority) {
 			this.priority = priority;
 		}
 
 		/**
 		 * Compares this object to another by priority.
-		 * 
+		 *
 		 * <p>
 		 * {@inheritDoc}
 		 * </p>
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
 		@Override
-		public int compareTo(final PriorityBinaryOperator<T> o) {
+		public int compareTo(final PriorityBiFunction<T, U, R> o) {
 			if (this.priority < o.priority)
 				return -1;
-			else if (this.priority > o.priority)
+			if (this.priority > o.priority)
 				return 1;
-			else
-				return 0;
+			return 0;
 		}
 
 		/**
@@ -296,18 +296,18 @@ public final class ExpressionParser<T> {
 	/**
 	 * A binary operator with a priority field that determines which operators
 	 * apply first.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @param <T> type of operand and result
 	 * @since 2019-03-17
 	 * @since v0.2.0
 	 */
-	private static abstract class PriorityBiFunction<T, U, R> implements
-			BiFunction<T, U, R>, Comparable<PriorityBiFunction<T, U, R>> {
+	private static abstract class PriorityBinaryOperator<T>
+			implements BinaryOperator<T>, Comparable<PriorityBinaryOperator<T>> {
 		/**
 		 * The operator's priority. Higher-priority operators are applied before
 		 * lower-priority operators
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
@@ -315,33 +315,32 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Creates the {@code PriorityBinaryOperator}.
-		 * 
+		 *
 		 * @param priority operator's priority
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
-		public PriorityBiFunction(final int priority) {
+		public PriorityBinaryOperator(final int priority) {
 			this.priority = priority;
 		}
 
 		/**
 		 * Compares this object to another by priority.
-		 * 
+		 *
 		 * <p>
 		 * {@inheritDoc}
 		 * </p>
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
 		@Override
-		public int compareTo(final PriorityBiFunction<T, U, R> o) {
+		public int compareTo(final PriorityBinaryOperator<T> o) {
 			if (this.priority < o.priority)
 				return -1;
-			else if (this.priority > o.priority)
+			if (this.priority > o.priority)
 				return 1;
-			else
-				return 0;
+			return 0;
 		}
 
 		/**
@@ -357,7 +356,7 @@ public final class ExpressionParser<T> {
 	/**
 	 * A unary operator with a priority field that determines which operators
 	 * apply first.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @param <T> type of operand and result
 	 * @since 2019-03-17
@@ -368,7 +367,7 @@ public final class ExpressionParser<T> {
 		/**
 		 * The operator's priority. Higher-priority operators are applied before
 		 * lower-priority operators
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
@@ -376,7 +375,7 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Creates the {@code PriorityUnaryOperator}.
-		 * 
+		 *
 		 * @param priority operator's priority
 		 * @since 2019-03-17
 		 * @since v0.2.0
@@ -387,11 +386,11 @@ public final class ExpressionParser<T> {
 
 		/**
 		 * Compares this object to another by priority.
-		 * 
+		 *
 		 * <p>
 		 * {@inheritDoc}
 		 * </p>
-		 * 
+		 *
 		 * @since 2019-03-17
 		 * @since v0.2.0
 		 */
@@ -399,10 +398,9 @@ public final class ExpressionParser<T> {
 		public int compareTo(final PriorityUnaryOperator<T> o) {
 			if (this.priority < o.priority)
 				return -1;
-			else if (this.priority > o.priority)
+			if (this.priority > o.priority)
 				return 1;
-			else
-				return 0;
+			return 0;
 		}
 
 		/**
@@ -417,18 +415,18 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * The types of tokens that are available.
-	 * 
+	 *
 	 * @author Adrien Hopkins
 	 * @since 2019-03-14
 	 * @since v0.2.0
 	 */
-	private static enum TokenType {
+	private enum TokenType {
 		OBJECT, UNARY_OPERATOR, BINARY_OPERATOR, NUMERIC_OPERATOR;
 	}
 
 	/**
 	 * The opening bracket.
-	 * 
+	 *
 	 * @since 2019-03-22
 	 * @since v0.2.0
 	 */
@@ -436,7 +434,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * The closing bracket.
-	 * 
+	 *
 	 * @since 2019-03-22
 	 * @since v0.2.0
 	 */
@@ -444,7 +442,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * Finds the other bracket in a pair of brackets, given the position of one.
-	 * 
+	 *
 	 * @param string          string that contains brackets
 	 * @param bracketPosition position of first bracket
 	 * @return position of matching bracket
@@ -456,7 +454,7 @@ public final class ExpressionParser<T> {
 			final int bracketPosition) {
 		Objects.requireNonNull(string, "string must not be null.");
 
-		final char openingBracket = string.charAt(bracketPosition);
+		final var openingBracket = string.charAt(bracketPosition);
 
 		// figure out what closing bracket to look for
 		final char closingBracket;
@@ -477,12 +475,12 @@ public final class ExpressionParser<T> {
 
 		// level of brackets. every opening bracket increments this; every closing
 		// bracket decrements it
-		int bracketLevel = 0;
+		var bracketLevel = 0;
 
 		// iterate over the string to find the closing bracket
-		for (int currentPosition = bracketPosition; currentPosition < string
+		for (var currentPosition = bracketPosition; currentPosition < string
 				.length(); currentPosition++) {
-			final char currentCharacter = string.charAt(currentPosition);
+			final var currentCharacter = string.charAt(currentPosition);
 
 			if (currentCharacter == openingBracket) {
 				bracketLevel++;
@@ -499,7 +497,7 @@ public final class ExpressionParser<T> {
 	/**
 	 * A function that obtains a parseable object from a string. For example, an
 	 * integer {@code ExpressionParser} would use {@code Integer::parseInt}.
-	 * 
+	 *
 	 * @since 2019-03-14
 	 * @since v0.2.0
 	 */
@@ -507,7 +505,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * A map mapping operator strings to operator functions, for unary operators.
-	 * 
+	 *
 	 * @since 2019-03-14
 	 * @since v0.2.0
 	 */
@@ -516,7 +514,7 @@ public final class ExpressionParser<T> {
 	/**
 	 * A map mapping operator strings to operator functions, for binary
 	 * operators.
-	 * 
+	 *
 	 * @since 2019-03-14
 	 * @since v0.2.0
 	 */
@@ -524,14 +522,15 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * A map mapping operator strings to numeric functions.
-	 * 
+	 *
 	 * @since 2024-03-23
+	 * @since v0.5.0
 	 */
 	private final Map<String, PriorityBiFunction<T, UncertainDouble, T>> numericOperators;
 
 	/**
 	 * The operator for space, or null if spaces have no function.
-	 * 
+	 *
 	 * @since 2019-03-22
 	 * @since v0.2.0
 	 */
@@ -539,7 +538,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * Creates the {@code ExpressionParser}.
-	 * 
+	 *
 	 * @param objectObtainer   function to get objects from strings
 	 * @param unaryOperators   unary operators available to the parser
 	 * @param binaryOperators  binary operators available to the parser
@@ -568,7 +567,7 @@ public final class ExpressionParser<T> {
 	 * {@code 2 * (3 + 4)}<br>
 	 * becomes<br>
 	 * {@code 2 3 4 + *}.
-	 * 
+	 *
 	 * @param expression expression
 	 * @return expression in RPN
 	 * @throws IllegalArgumentException if expression is invalid (e.g.
@@ -582,13 +581,13 @@ public final class ExpressionParser<T> {
 		final List<String> components = new ArrayList<>();
 
 		// the part of the expression remaining to parse
-		String partialExpression = expression;
+		var partialExpression = expression;
 
 		// find and deal with brackets
 		while (partialExpression.indexOf(OPENING_BRACKET) != -1) {
-			final int openingBracketPosition = partialExpression
+			final var openingBracketPosition = partialExpression
 					.indexOf(OPENING_BRACKET);
-			final int closingBracketPosition = findBracketPair(partialExpression,
+			final var closingBracketPosition = findBracketPair(partialExpression,
 					openingBracketPosition);
 
 			// check for function
@@ -596,7 +595,7 @@ public final class ExpressionParser<T> {
 					&& partialExpression.charAt(openingBracketPosition - 1) != ' ') {
 				// function like sin(2) or tempF(32)
 				// find the position of the last space
-				int spacePosition = openingBracketPosition;
+				var spacePosition = openingBracketPosition;
 				while (spacePosition >= 0
 						&& partialExpression.charAt(spacePosition) != ' ') {
 					spacePosition--;
@@ -607,8 +606,6 @@ public final class ExpressionParser<T> {
 						.substring(0, spacePosition + 1).split(" ")));
 				components.add(partialExpression.substring(spacePosition + 1,
 						closingBracketPosition + 1));
-				partialExpression = partialExpression
-						.substring(closingBracketPosition + 1);
 			} else {
 				// normal brackets like (1 + 2) * (3 / 5)
 				components.addAll(Arrays.asList(partialExpression
@@ -616,9 +613,9 @@ public final class ExpressionParser<T> {
 				components.add(this.convertExpressionToReversePolish(
 						partialExpression.substring(openingBracketPosition + 1,
 								closingBracketPosition)));
-				partialExpression = partialExpression
-						.substring(closingBracketPosition + 1);
 			}
+			partialExpression = partialExpression
+					.substring(closingBracketPosition + 1);
 		}
 
 		// add everything else
@@ -631,7 +628,7 @@ public final class ExpressionParser<T> {
 
 		// deal with space multiplication (x y)
 		if (this.spaceOperator != null) {
-			for (int i = 0; i < components.size() - 1; i++) {
+			for (var i = 0; i < components.size() - 1; i++) {
 				if (this.getTokenType(components.get(i)) == TokenType.OBJECT && this
 						.getTokenType(components.get(i + 1)) == TokenType.OBJECT) {
 					components.add(++i, this.spaceOperator);
@@ -641,7 +638,7 @@ public final class ExpressionParser<T> {
 
 		// turn the expression into reverse Polish
 		while (true) {
-			final int highestPriorityOperatorPosition = this
+			final var highestPriorityOperatorPosition = this
 					.findHighestPriorityOperatorPosition(components);
 			if (highestPriorityOperatorPosition == -1) {
 				break;
@@ -656,9 +653,9 @@ public final class ExpressionParser<T> {
 				if (components.size() < 2)
 					throw new IllegalArgumentException(
 							"Invalid expression \"" + expression + "\"");
-				final String unaryOperator = components
+				final var unaryOperator = components
 						.remove(highestPriorityOperatorPosition);
-				final String operand = components
+				final var operand = components
 						.remove(highestPriorityOperatorPosition);
 				components.add(highestPriorityOperatorPosition,
 						operand + " " + unaryOperator);
@@ -668,14 +665,14 @@ public final class ExpressionParser<T> {
 				if (components.size() < 3)
 					throw new IllegalArgumentException(
 							"Invalid expression \"" + expression + "\"");
-				final String binaryOperator = components
+				final var binaryOperator = components
 						.remove(highestPriorityOperatorPosition);
-				final String operand1 = components
+				final var operand1 = components
 						.remove(highestPriorityOperatorPosition - 1);
-				final String operand2 = components
+				final var operand2 = components
 						.remove(highestPriorityOperatorPosition - 1);
 				components.add(highestPriorityOperatorPosition - 1,
-						operand2 + " " + operand1 + " " + binaryOperator);
+						operand1 + " " + operand2 + " " + binaryOperator);
 				break;
 			default:
 				throw new AssertionError("Expected operator, found non-operator.");
@@ -684,20 +681,15 @@ public final class ExpressionParser<T> {
 
 		// join all of the components together, then ensure there is only one
 		// space in a row
-		String expressionRPN = String.join(" ", components).replaceAll(" +", " ");
-
-		while (expressionRPN.charAt(0) == ' ') {
-			expressionRPN = expressionRPN.substring(1);
-		}
-		while (expressionRPN.charAt(expressionRPN.length() - 1) == ' ') {
-			expressionRPN = expressionRPN.substring(0, expressionRPN.length() - 1);
-		}
-		return expressionRPN;
+		if (components.size() != 1)
+			throw new IllegalArgumentException(
+					"Invalid expression \"" + expression + "\".");
+		return components.get(0).replaceAll(" +", " ").trim();
 	}
 
 	/**
 	 * Finds the position of the highest-priority operator in a list
-	 * 
+	 *
 	 * @param components components to test
 	 * @param blacklist  positions of operators that should be ignored
 	 * @return position of highest priority, or -1 if the list contains no
@@ -710,19 +702,19 @@ public final class ExpressionParser<T> {
 			final List<String> components) {
 		Objects.requireNonNull(components, "components must not be null.");
 		// find highest priority
-		int maxPriority = Integer.MIN_VALUE;
-		int maxPriorityPosition = -1;
+		var maxPriority = Integer.MIN_VALUE;
+		var maxPriorityPosition = -1;
 
 		// go over components one by one
 		// if it is an operator, test its priority to see if it's max
 		// if it is, update maxPriority and maxPriorityPosition
-		for (int i = 0; i < components.size(); i++) {
+		for (var i = 0; i < components.size(); i++) {
 
 			switch (this.getTokenType(components.get(i))) {
 			case UNARY_OPERATOR:
-				final PriorityUnaryOperator<T> unaryOperator = this.unaryOperators
+				final var unaryOperator = this.unaryOperators
 						.get(components.get(i));
-				final int unaryPriority = unaryOperator.getPriority();
+				final var unaryPriority = unaryOperator.getPriority();
 
 				if (unaryPriority > maxPriority) {
 					maxPriority = unaryPriority;
@@ -730,9 +722,9 @@ public final class ExpressionParser<T> {
 				}
 				break;
 			case BINARY_OPERATOR:
-				final PriorityBinaryOperator<T> binaryOperator = this.binaryOperators
+				final var binaryOperator = this.binaryOperators
 						.get(components.get(i));
-				final int binaryPriority = binaryOperator.getPriority();
+				final var binaryPriority = binaryOperator.getPriority();
 
 				if (binaryPriority > maxPriority) {
 					maxPriority = binaryPriority;
@@ -740,9 +732,9 @@ public final class ExpressionParser<T> {
 				}
 				break;
 			case NUMERIC_OPERATOR:
-				final PriorityBiFunction<T, UncertainDouble, T> numericOperator = this.numericOperators
+				final var numericOperator = this.numericOperators
 						.get(components.get(i));
-				final int numericPriority = numericOperator.getPriority();
+				final var numericPriority = numericOperator.getPriority();
 
 				if (numericPriority > maxPriority) {
 					maxPriority = numericPriority;
@@ -760,7 +752,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * Determines whether an inputted string is an object or an operator
-	 * 
+	 *
 	 * @param token string to input
 	 * @return type of token it is
 	 * @throws NullPointerException if {@code expression} is null
@@ -772,17 +764,16 @@ public final class ExpressionParser<T> {
 
 		if (this.unaryOperators.containsKey(token))
 			return TokenType.UNARY_OPERATOR;
-		else if (this.binaryOperators.containsKey(token))
+		if (this.binaryOperators.containsKey(token))
 			return TokenType.BINARY_OPERATOR;
-		else if (this.numericOperators.containsKey(token))
+		if (this.numericOperators.containsKey(token))
 			return TokenType.NUMERIC_OPERATOR;
-		else
-			return TokenType.OBJECT;
+		return TokenType.OBJECT;
 	}
 
 	/**
 	 * Parses an expression.
-	 * 
+	 *
 	 * @param expression expression to parse
 	 * @return result
 	 * @throws NullPointerException if {@code expression} is null
@@ -796,7 +787,7 @@ public final class ExpressionParser<T> {
 
 	/**
 	 * Parses an expression expressed in reverse Polish notation.
-	 * 
+	 *
 	 * @param expression expression to parse
 	 * @return result
 	 * @throws NullPointerException if {@code expression} is null
@@ -821,12 +812,12 @@ public final class ExpressionParser<T> {
 							item, stack.size()));
 
 				// get two arguments and operator, then apply!
-				final T o1 = stack.pop();
-				final T o2 = stack.pop();
+				final var o1 = stack.pop();
+				final var o2 = stack.pop();
 				final BinaryOperator<T> binaryOperator = this.binaryOperators
 						.get(item);
 
-				stack.push(binaryOperator.apply(o1, o2));
+				stack.push(binaryOperator.apply(o2, o1));
 				break;
 
 			case NUMERIC_OPERATOR:
@@ -835,8 +826,8 @@ public final class ExpressionParser<T> {
 							"Attempted to call binary operator %s with insufficient arguments.",
 							item));
 
-				final T ot = stack.pop();
-				final UncertainDouble on = doubleStack.pop();
+				final var ot = stack.pop();
+				final var on = doubleStack.pop();
 				final BiFunction<T, UncertainDouble, T> op = this.numericOperators
 						.get(item);
 				stack.push(op.apply(ot, on));
@@ -850,14 +841,14 @@ public final class ExpressionParser<T> {
 				// that's the only way to tell if an expression is a number or not.
 				try {
 					stack.push(this.objectObtainer.apply(item));
-				} catch (Exception e) {
+				} catch (final Exception e) {
 					try {
 						doubleStack.push(UncertainDouble.fromString(item));
-					} catch (IllegalArgumentException e2) {
+					} catch (final IllegalArgumentException e2) {
 						try {
 							doubleStack.push(
 									UncertainDouble.of(Double.parseDouble(item), 0));
-						} catch (NumberFormatException e3) {
+						} catch (final NumberFormatException e3) {
 							throw e;
 						}
 					}
@@ -871,7 +862,7 @@ public final class ExpressionParser<T> {
 							item, stack.size()));
 
 				// get one argument and operator, then apply!
-				final T o = stack.pop();
+				final var o = stack.pop();
 				final UnaryOperator<T> unaryOperator = this.unaryOperators
 						.get(item);
 
@@ -889,7 +880,7 @@ public final class ExpressionParser<T> {
 		if (stack.size() > 1)
 			throw new IllegalStateException(
 					"Computation ended up with more than one answer.");
-		else if (stack.size() == 0)
+		if (stack.size() == 0)
 			throw new IllegalStateException(
 					"Computation ended up without an answer.");
 		return stack.pop();
diff --git a/src/main/java/sevenUnits/utils/NameSymbol.java b/src/main/java/sevenUnits/utils/NameSymbol.java
index 49c44fa..089978b 100644
--- a/src/main/java/sevenUnits/utils/NameSymbol.java
+++ b/src/main/java/sevenUnits/utils/NameSymbol.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2019 Adrien Hopkins
+ * Copyright (C) 2019, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -19,34 +19,35 @@ package sevenUnits.utils;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 
 /**
  * A class that can be used to specify names and a symbol for a unit.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-10-21
+ * @since v0.3.0
  */
 public final class NameSymbol {
+	/** The {@code NameSymbol} with all fields empty. */
 	public static final NameSymbol EMPTY = new NameSymbol(Optional.empty(),
 			Optional.empty(), new HashSet<>());
 
 	/**
 	 * Creates a {@code NameSymbol}, ensuring that if primaryName is null and
 	 * otherNames is not empty, one name is moved from otherNames to primaryName
-	 * 
+	 *
 	 * Ensure that otherNames is not a copy of the inputted argument.
 	 */
-	private static final NameSymbol create(final String name,
-			final String symbol, final Set<String> otherNames) {
+	private static NameSymbol create(final String name, final String symbol,
+			final Set<String> otherNames) {
 		final Optional<String> primaryName;
 
 		if (name == null && !otherNames.isEmpty()) {
 			// get primary name and remove it from savedNames
-			final Iterator<String> it = otherNames.iterator();
+			final var it = otherNames.iterator();
 			assert it.hasNext();
 			primaryName = Optional.of(it.next());
 			otherNames.remove(primaryName.get());
@@ -61,14 +62,15 @@ public final class NameSymbol {
 	/**
 	 * Gets a {@code NameSymbol} with a primary name, a symbol and no other
 	 * names.
-	 * 
+	 *
 	 * @param name   name to use
 	 * @param symbol symbol to use
 	 * @return NameSymbol instance
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if name or symbol is null
 	 */
-	public static final NameSymbol of(final String name, final String symbol) {
+	public static NameSymbol of(final String name, final String symbol) {
 		return new NameSymbol(Optional.of(name), Optional.of(symbol),
 				new HashSet<>());
 	}
@@ -76,15 +78,16 @@ public final class NameSymbol {
 	/**
 	 * Gets a {@code NameSymbol} with a primary name, a symbol and additional
 	 * names.
-	 * 
+	 *
 	 * @param name       name to use
 	 * @param symbol     symbol to use
 	 * @param otherNames other names to use
 	 * @return NameSymbol instance
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if any argument is null
 	 */
-	public static final NameSymbol of(final String name, final String symbol,
+	public static NameSymbol of(final String name, final String symbol,
 			final Set<String> otherNames) {
 		return new NameSymbol(Optional.of(name), Optional.of(symbol),
 				new HashSet<>(Objects.requireNonNull(otherNames,
@@ -94,12 +97,13 @@ public final class NameSymbol {
 	/**
 	 * h * Gets a {@code NameSymbol} with a primary name, a symbol and additional
 	 * names.
-	 * 
+	 *
 	 * @param name       name to use
 	 * @param symbol     symbol to use
 	 * @param otherNames other names to use
 	 * @return NameSymbol instance
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if any argument is null
 	 */
 	public static final NameSymbol of(final String name, final String symbol,
@@ -112,13 +116,14 @@ public final class NameSymbol {
 	/**
 	 * Gets a {@code NameSymbol} with a primary name, no symbol, and no other
 	 * names.
-	 * 
+	 *
 	 * @param name name to use
 	 * @return NameSymbol instance
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if name is null
 	 */
-	public static final NameSymbol ofName(final String name) {
+	public static NameSymbol ofName(final String name) {
 		return new NameSymbol(Optional.of(name), Optional.empty(),
 				new HashSet<>());
 	}
@@ -133,15 +138,16 @@ public final class NameSymbol {
 	 * If {@code name} is null and {@code otherNames} is not empty, a primary
 	 * name will be picked from {@code otherNames}. This name will not appear in
 	 * getOtherNames().
-	 * 
+	 *
 	 * @param name       name to use
 	 * @param symbol     symbol to use
 	 * @param otherNames other names to use
 	 * @return NameSymbol instance
 	 * @since 2019-11-26
+	 * @since v0.3.0
 	 */
-	public static final NameSymbol ofNullable(final String name,
-			final String symbol, final Set<String> otherNames) {
+	public static NameSymbol ofNullable(final String name, final String symbol,
+			final Set<String> otherNames) {
 		return NameSymbol.create(name, symbol,
 				otherNames == null ? new HashSet<>() : new HashSet<>(otherNames));
 	}
@@ -156,12 +162,13 @@ public final class NameSymbol {
 	 * If {@code name} is null and {@code otherNames} is not empty, a primary
 	 * name will be picked from {@code otherNames}. This name will not appear in
 	 * getOtherNames().
-	 * 
+	 *
 	 * @param name       name to use
 	 * @param symbol     symbol to use
 	 * @param otherNames other names to use
 	 * @return NameSymbol instance
 	 * @since 2019-11-26
+	 * @since v0.3.0
 	 */
 	public static final NameSymbol ofNullable(final String name,
 			final String symbol, final String... otherNames) {
@@ -171,13 +178,14 @@ public final class NameSymbol {
 
 	/**
 	 * Gets a {@code NameSymbol} with a symbol and no names.
-	 * 
+	 *
 	 * @param symbol symbol to use
 	 * @return NameSymbol instance
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 * @throws NullPointerException if symbol is null
 	 */
-	public static final NameSymbol ofSymbol(final String symbol) {
+	public static NameSymbol ofSymbol(final String symbol) {
 		return new NameSymbol(Optional.empty(), Optional.of(symbol),
 				new HashSet<>());
 	}
@@ -189,21 +197,26 @@ public final class NameSymbol {
 
 	/**
 	 * Creates the {@code NameSymbol}.
-	 * 
+	 *
 	 * @param primaryName primary name of unit
 	 * @param symbol      symbol used to represent unit
 	 * @param otherNames  other names and/or spellings, should be a mutable copy
 	 *                    of the argument
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 */
-	private NameSymbol(final Optional<String> primaryName,
-			final Optional<String> symbol, final Set<String> otherNames) {
+	NameSymbol(final Optional<String> primaryName, final Optional<String> symbol,
+			final Set<String> otherNames) {
 		this.primaryName = primaryName;
 		this.symbol = symbol;
-		otherNames.remove(null);
-		this.otherNames = Collections.unmodifiableSet(otherNames);
+		if (otherNames != null) {
+			otherNames.remove(null);
+			this.otherNames = Collections.unmodifiableSet(otherNames);
+		} else {
+			this.otherNames = Set.of();
+		}
 
-		if (this.primaryName.isEmpty()) {
+		if (this.primaryName == null || this.primaryName.isEmpty()) {
 			assert this.otherNames.isEmpty();
 		}
 	}
@@ -214,7 +227,7 @@ public final class NameSymbol {
 			return true;
 		if (!(obj instanceof NameSymbol))
 			return false;
-		final NameSymbol other = (NameSymbol) obj;
+		final var other = (NameSymbol) obj;
 		if (this.otherNames == null) {
 			if (other.otherNames != null)
 				return false;
@@ -236,31 +249,34 @@ public final class NameSymbol {
 	/**
 	 * @return otherNames
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 */
-	public final Set<String> getOtherNames() {
+	public Set<String> getOtherNames() {
 		return this.otherNames;
 	}
 
 	/**
 	 * @return primaryName
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 */
-	public final Optional<String> getPrimaryName() {
+	public Optional<String> getPrimaryName() {
 		return this.primaryName;
 	}
 
 	/**
 	 * @return symbol
 	 * @since 2019-10-21
+	 * @since v0.3.0
 	 */
-	public final Optional<String> getSymbol() {
+	public Optional<String> getSymbol() {
 		return this.symbol;
 	}
 
 	@Override
 	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
+		final var prime = 31;
+		var result = 1;
 		result = prime * result
 				+ (this.otherNames == null ? 0 : this.otherNames.hashCode());
 		result = prime * result
@@ -270,10 +286,8 @@ public final class NameSymbol {
 		return result;
 	}
 
-	/**
-	 * @return true iff this {@code NameSymbol} contains no names or symbols.
-	 */
-	public final boolean isEmpty() {
+	/** @return true iff this {@code NameSymbol} contains no names or symbols. */
+	public boolean isEmpty() {
 		// if primaryName is empty, otherNames must also be empty
 		return this.primaryName.isEmpty() && this.symbol.isEmpty();
 	}
@@ -282,11 +296,10 @@ public final class NameSymbol {
 	public String toString() {
 		if (this.isEmpty())
 			return "NameSymbol.EMPTY";
-		else if (this.primaryName.isPresent() && this.symbol.isPresent())
+		if (this.primaryName.isPresent() && this.symbol.isPresent())
 			return this.primaryName.orElseThrow() + " ("
 					+ this.symbol.orElseThrow() + ")";
-		else
-			return this.primaryName.orElseGet(this.symbol::orElseThrow);
+		return this.primaryName.orElseGet(this.symbol::orElseThrow);
 	}
 
 	/**
@@ -294,16 +307,19 @@ public final class NameSymbol {
 	 * extra name. If this {@code NameSymbol} has a primary name, the provided
 	 * name will become an other name, otherwise it will become the primary name.
 	 *
-	 * @since v0.4.0
+	 * @param name additional name to add
+	 * @return copy of this NameSymbol with the additional name
+	 *
 	 * @since 2022-04-19
+	 * @since v0.4.0
 	 */
-	public final NameSymbol withExtraName(String name) {
+	public NameSymbol withExtraName(String name) {
 		if (this.primaryName.isPresent()) {
 			final var otherNames = new HashSet<>(this.otherNames);
 			otherNames.add(name);
 			return NameSymbol.ofNullable(this.primaryName.orElse(null),
 					this.symbol.orElse(null), otherNames);
-		} else
-			return NameSymbol.ofNullable(name, this.symbol.orElse(null));
+		}
+		return NameSymbol.ofNullable(name, this.symbol.orElse(null));
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/sevenUnits/utils/Nameable.java b/src/main/java/sevenUnits/utils/Nameable.java
index 3959a64..166de55 100644
--- a/src/main/java/sevenUnits/utils/Nameable.java
+++ b/src/main/java/sevenUnits/utils/Nameable.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2020 Adrien Hopkins
+ * Copyright (C) 2020, 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -24,15 +24,17 @@ import java.util.Set;
  * and symbol data should be immutable.
  *
  * @since 2020-09-07
+ * @since v0.3.0
  */
 public interface Nameable {
 	/**
 	 * @return a name for the object - if there's a primary name, it's that,
 	 *         otherwise the symbol, otherwise "Unnamed"
 	 * @since 2022-02-26
+	 * @since v0.4.0
 	 */
 	default String getName() {
-		final NameSymbol ns = this.getNameSymbol();
+		final var ns = this.getNameSymbol();
 		return ns.getPrimaryName().or(ns::getSymbol).orElse("Unnamed");
 	}
 
@@ -40,12 +42,14 @@ public interface Nameable {
 	 * @return a {@code NameSymbol} that contains this object's primary name,
 	 *         symbol and other names
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	NameSymbol getNameSymbol();
 
 	/**
 	 * @return set of alternate names
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	default Set<String> getOtherNames() {
 		return this.getNameSymbol().getOtherNames();
@@ -54,6 +58,7 @@ public interface Nameable {
 	/**
 	 * @return preferred name of object
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	default Optional<String> getPrimaryName() {
 		return this.getNameSymbol().getPrimaryName();
@@ -63,15 +68,17 @@ public interface Nameable {
 	 * @return a short name for the object - if there's a symbol, it's that,
 	 *         otherwise the symbol, otherwise "Unnamed"
 	 * @since 2022-02-26
+	 * @since v0.4.0
 	 */
 	default String getShortName() {
-		final NameSymbol ns = this.getNameSymbol();
+		final var ns = this.getNameSymbol();
 		return ns.getSymbol().or(ns::getPrimaryName).orElse("Unnamed");
 	}
 
 	/**
 	 * @return short symbol representing object
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	default Optional<String> getSymbol() {
 		return this.getNameSymbol().getSymbol();
diff --git a/src/main/java/sevenUnits/utils/ObjectProduct.java b/src/main/java/sevenUnits/utils/ObjectProduct.java
index 5a29d79..23fe41c 100644
--- a/src/main/java/sevenUnits/utils/ObjectProduct.java
+++ b/src/main/java/sevenUnits/utils/ObjectProduct.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2018 Adrien Hopkins
+ * Copyright (C) 2018, 2021, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -29,17 +29,26 @@ import java.util.function.Function;
 /**
  * An immutable product of multiple objects of a type, such as base units. The
  * objects can be multiplied and exponentiated.
- * 
+ *
  * @author Adrien Hopkins
+ * @param <T> type of object that is being multiplied
  * @since 2019-10-16
+ * @since v0.3.0
  */
 public class ObjectProduct<T> implements Nameable {
 	/**
+	 * If {@link #toExponentRounded}'s rounding changes exponents by more than
+	 * this value, a warning will be printed to standard error.
+	 */
+	private static final double ROUND_WARN_THRESHOLD = 1e-12;
+
+	/**
 	 * Returns an empty ObjectProduct of a certain type
-	 * 
+	 *
 	 * @param <T> type of objects that can be multiplied
 	 * @return empty product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public static final <T> ObjectProduct<T> empty() {
 		return new ObjectProduct<>(new HashMap<>());
@@ -47,11 +56,12 @@ public class ObjectProduct<T> implements Nameable {
 
 	/**
 	 * Gets an {@code ObjectProduct} from an object-to-integer mapping
-	 * 
+	 *
 	 * @param <T> type of object in product
 	 * @param map map mapping objects to exponents
 	 * @return object product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public static final <T> ObjectProduct<T> fromExponentMapping(
 			final Map<T, Integer> map) {
@@ -61,10 +71,12 @@ public class ObjectProduct<T> implements Nameable {
 	/**
 	 * Gets an ObjectProduct that has one of the inputted argument, and nothing
 	 * else.
-	 * 
+	 *
 	 * @param object object that will be in the product
+	 * @param <T>    type of object contained in returned ObjectProduct
 	 * @return product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if object is null
 	 */
 	public static final <T> ObjectProduct<T> oneOf(final T object) {
@@ -77,21 +89,21 @@ public class ObjectProduct<T> implements Nameable {
 	/**
 	 * The objects that make up the product, mapped to their exponents. This map
 	 * treats zero as null, and is immutable.
-	 * 
+	 *
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	final Map<T, Integer> exponents;
 
-	/**
-	 * The object's name and symbol
-	 */
+	/** The object's name and symbol */
 	private final NameSymbol nameSymbol;
 
 	/**
 	 * Creates a {@code ObjectProduct} without a name/symbol.
-	 * 
+	 *
 	 * @param exponents objects that make up this product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	ObjectProduct(final Map<T, Integer> exponents) {
 		this(exponents, NameSymbol.EMPTY);
@@ -99,10 +111,11 @@ public class ObjectProduct<T> implements Nameable {
 
 	/**
 	 * Creates the {@code ObjectProduct}.
-	 * 
+	 *
 	 * @param exponents  objects that make up this product
 	 * @param nameSymbol name and symbol of object product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	ObjectProduct(final Map<T, Integer> exponents, NameSymbol nameSymbol) {
 		this.exponents = Collections.unmodifiableMap(
@@ -117,6 +130,7 @@ public class ObjectProduct<T> implements Nameable {
 	 * @param other other product
 	 * @return quotient of two products
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if other is null
 	 */
 	public ObjectProduct<T> dividedBy(final ObjectProduct<T> other) {
@@ -150,6 +164,7 @@ public class ObjectProduct<T> implements Nameable {
 	/**
 	 * @return immutable map mapping objects to exponents
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public Map<T, Integer> exponentMap() {
 		return this.exponents;
@@ -177,7 +192,7 @@ public class ObjectProduct<T> implements Nameable {
 
 	/**
 	 * Gets the exponent for a specific dimension.
-	 * 
+	 *
 	 * @param dimension dimension to check
 	 * @return exponent for that dimension
 	 * @since 2018-12-12
@@ -201,10 +216,11 @@ public class ObjectProduct<T> implements Nameable {
 	 * @return true if this product is a single object, i.e. it has one exponent
 	 *         of one and no other nonzero exponents
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public boolean isSingleObject() {
-		int oneCount = 0;
-		boolean twoOrMore = false; // has exponents of 2 or more
+		var oneCount = 0;
+		var twoOrMore = false; // has exponents of 2 or more
 		for (final T b : this.getBaseSet()) {
 			if (this.getExponent(b) == 1) {
 				oneCount++;
@@ -221,6 +237,7 @@ public class ObjectProduct<T> implements Nameable {
 	 * @param other other product
 	 * @return product of two products
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 * @throws NullPointerException if other is null
 	 */
 	public ObjectProduct<T> times(final ObjectProduct<T> other) {
@@ -242,10 +259,11 @@ public class ObjectProduct<T> implements Nameable {
 
 	/**
 	 * Returns this product, but to an exponent
-	 * 
+	 *
 	 * @param exponent exponent
 	 * @return result of exponentiation
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public ObjectProduct<T> toExponent(final int exponent) {
 		final Map<T, Integer> map = new HashMap<>(this.exponents);
@@ -256,12 +274,41 @@ public class ObjectProduct<T> implements Nameable {
 	}
 
 	/**
+	 * Returns this product to an exponent, where every dimension is rounded to
+	 * the nearest integer.
+	 *
+	 * This function will send a warning (via standard error) if the rounding
+	 * significantly changes the value.
+	 *
+	 * @param exponent exponent to raise this product to
+	 * @return result of exponentiation
+	 *
+	 * @since 2024-08-22
+	 * @since v0.3.0
+	 */
+	public ObjectProduct<T> toExponentRounded(final double exponent) {
+		final Map<T, Integer> map = new HashMap<>(this.exponents);
+		for (final T key : this.exponents.keySet()) {
+			final var newExponent = this.getExponent(key) * exponent;
+			if (Math.abs(
+					newExponent - Math.round(newExponent)) > ROUND_WARN_THRESHOLD) {
+				System.err.printf(
+						"Exponent Rounding Warning: Dimension exponents must be integers, so %d ^ %g = %g was rounded to %d.\n",
+						this.getExponent(key), exponent, newExponent,
+						Math.round(newExponent));
+			}
+			map.put(key, (int) Math.round(newExponent));
+		}
+		return new ObjectProduct<>(map);
+	}
+
+	/**
 	 * Converts this product to a string using the objects'
 	 * {@link Object#toString()} method (or {@link Nameable#getShortName} if
 	 * available). If objects have a long toString representation, it is
 	 * recommended to use {@link #toString(Function)} instead to shorten the
 	 * returned string.
-	 * 
+	 *
 	 * <p>
 	 * {@inheritDoc}
 	 */
@@ -275,10 +322,11 @@ public class ObjectProduct<T> implements Nameable {
 	/**
 	 * Converts this product to a string. The objects that make up this product
 	 * are represented by {@code objectToString}
-	 * 
+	 *
 	 * @param objectToString function to convert objects to strings
 	 * @return string representation of product
 	 * @since 2019-10-16
+	 * @since v0.3.0
 	 */
 	public String toString(final Function<T, String> objectToString) {
 		final List<String> positiveStringComponents = new ArrayList<>();
@@ -298,18 +346,20 @@ public class ObjectProduct<T> implements Nameable {
 			}
 		}
 
-		final String positiveString = positiveStringComponents.isEmpty() ? "1"
+		final var positiveString = positiveStringComponents.isEmpty() ? "1"
 				: String.join(" * ", positiveStringComponents);
-		final String negativeString = negativeStringComponents.isEmpty() ? ""
+		final var negativeString = negativeStringComponents.isEmpty() ? ""
 				: " / " + String.join(" * ", negativeStringComponents);
 
 		return positiveString + negativeString;
 	}
 
 	/**
+	 * @param nameSymbol name to add to this product
 	 * @return named version of this {@code ObjectProduct}, using data from
 	 *         {@code nameSymbol}
 	 * @since 2021-12-15
+	 * @since v0.3.0
 	 */
 	public ObjectProduct<T> withName(NameSymbol nameSymbol) {
 		return new ObjectProduct<>(this.exponents, nameSymbol);
diff --git a/src/main/java/sevenUnits/utils/SemanticVersionNumber.java b/src/main/java/sevenUnits/utils/SemanticVersionNumber.java
index fc47baa..4bb7ce5 100644
--- a/src/main/java/sevenUnits/utils/SemanticVersionNumber.java
+++ b/src/main/java/sevenUnits/utils/SemanticVersionNumber.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2022 Adrien Hopkins
+ * Copyright (C) 2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -22,7 +22,6 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -39,8 +38,8 @@ import java.util.regex.Pattern;
  * are made
  * </ol>
  *
- * @since v0.4.0
  * @since 2022-02-19
+ * @since v0.4.0
  */
 public final class SemanticVersionNumber
 		implements Comparable<SemanticVersionNumber> {
@@ -52,8 +51,8 @@ public final class SemanticVersionNumber
 	 * throw NullPointerExceptions, everything else throws
 	 * IllegalArgumentException.
 	 *
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public static final class Builder {
 		private final int major;
@@ -69,8 +68,8 @@ public final class SemanticVersionNumber
 		 * @param major major version number of final version
 		 * @param minor minor version number of final version
 		 * @param patch patch version number of final version
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		private Builder(int major, int minor, int patch) {
 			this.major = major;
@@ -82,8 +81,8 @@ public final class SemanticVersionNumber
 
 		/**
 		 * @return version number created by this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public SemanticVersionNumber build() {
 			return new SemanticVersionNumber(this.major, this.minor, this.patch,
@@ -95,8 +94,8 @@ public final class SemanticVersionNumber
 		 *
 		 * @param identifiers build metadata
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder buildMetadata(List<String> identifiers) {
 			Objects.requireNonNull(identifiers, "identifiers may not be null");
@@ -115,8 +114,8 @@ public final class SemanticVersionNumber
 		 *
 		 * @param identifiers build metadata
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder buildMetadata(String... identifiers) {
 			Objects.requireNonNull(identifiers, "identifiers may not be null");
@@ -136,7 +135,7 @@ public final class SemanticVersionNumber
 				return true;
 			if (!(obj instanceof Builder))
 				return false;
-			final Builder other = (Builder) obj;
+			final var other = (Builder) obj;
 			return Objects.equals(this.buildMetadata, other.buildMetadata)
 					&& this.major == other.major && this.minor == other.minor
 					&& this.patch == other.patch && Objects.equals(
@@ -154,8 +153,8 @@ public final class SemanticVersionNumber
 		 *
 		 * @param identifiers pre-release identifier(s) to add
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder preRelease(int... identifiers) {
 			Objects.requireNonNull(identifiers, "identifiers may not be null");
@@ -173,8 +172,8 @@ public final class SemanticVersionNumber
 		 *
 		 * @param identifiers pre-release identifier(s) to add
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder preRelease(List<String> identifiers) {
 			Objects.requireNonNull(identifiers, "identifiers may not be null");
@@ -193,8 +192,8 @@ public final class SemanticVersionNumber
 		 *
 		 * @param identifiers pre-release identifier(s) to add
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder preRelease(String... identifiers) {
 			Objects.requireNonNull(identifiers, "identifiers may not be null");
@@ -214,8 +213,8 @@ public final class SemanticVersionNumber
 		 * @param identifier1 first identifier
 		 * @param identifier2 second identifier
 		 * @return this builder
-		 * @since v0.4.0
 		 * @since 2022-02-19
+		 * @since v0.4.0
 		 */
 		public Builder preRelease(String identifier1, int identifier2) {
 			Objects.requireNonNull(identifier1, "identifier1 may not be null");
@@ -249,12 +248,11 @@ public final class SemanticVersionNumber
 		public int compare(SemanticVersionNumber o1, SemanticVersionNumber o2) {
 			Objects.requireNonNull(o1, "o1 may not be null");
 			Objects.requireNonNull(o2, "o2 may not be null");
-			final int naturalComparison = o1.compareTo(o2);
+			final var naturalComparison = o1.compareTo(o2);
 			if (naturalComparison == 0)
 				return SemanticVersionNumber.compareIdentifiers(o1.buildMetadata,
 						o2.buildMetadata);
-			else
-				return naturalComparison;
+			return naturalComparison;
 		};
 	};
 
@@ -280,11 +278,11 @@ public final class SemanticVersionNumber
 	 * @param patch patch version number of final version
 	 * @return version number builder
 	 * @throws IllegalArgumentException if any argument is negative
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
-	public static final SemanticVersionNumber.Builder builder(int major,
-			int minor, int patch) {
+	public static SemanticVersionNumber.Builder builder(int major, int minor,
+			int patch) {
 		if (major < 0)
 			throw new IllegalArgumentException(
 					"Major version must be non-negative.");
@@ -304,60 +302,57 @@ public final class SemanticVersionNumber
 	 * @param b second list
 	 * @return result of comparison as in a comparator
 	 * @see Comparator
-	 * @since v0.4.0
 	 * @since 2022-02-20
+	 * @since v0.4.0
 	 */
-	private static final int compareIdentifiers(List<String> a, List<String> b) {
+	private static int compareIdentifiers(List<String> a, List<String> b) {
 		// test pre-release size
-		final int aSize = a.size();
-		final int bSize = b.size();
+		final var aSize = a.size();
+		final var bSize = b.size();
 
 		// no identifiers is greater than any identifiers
 		if (aSize != 0 && bSize == 0)
 			return -1;
-		else if (aSize == 0 && bSize != 0)
+		if (aSize == 0 && bSize != 0)
 			return 1;
 
 		// test identifiers one by one
-		for (int i = 0; i < Math.min(aSize, bSize); i++) {
-			final String aElement = a.get(i);
-			final String bElement = b.get(i);
+		for (var i = 0; i < Math.min(aSize, bSize); i++) {
+			final var aElement = a.get(i);
+			final var bElement = b.get(i);
 
 			if (NUMERIC_IDENTIFER.matcher(aElement).matches()) {
-				if (NUMERIC_IDENTIFER.matcher(bElement).matches()) {
-					// both are numbers, compare them
-					final int aNumber = Integer.parseInt(aElement);
-					final int bNumber = Integer.parseInt(bElement);
-
-					if (aNumber < bNumber)
-						return -1;
-					else if (aNumber > bNumber)
-						return 1;
-				} else
+				if (!NUMERIC_IDENTIFER.matcher(bElement).matches())
 					// aElement is a number and bElement is not a number
 					// by the rules, a goes before b
 					return -1;
-			} else {
-				if (NUMERIC_IDENTIFER.matcher(bElement).matches())
-					// aElement is not a number but bElement is
-					// by the rules, a goes after b
+				// both are numbers, compare them
+				final var aNumber = Integer.parseInt(aElement);
+				final var bNumber = Integer.parseInt(bElement);
+
+				if (aNumber < bNumber)
+					return -1;
+				if (aNumber > bNumber)
 					return 1;
-				else {
-					// both are not numbers, compare them
-					final int comparison = aElement.compareTo(bElement);
-					if (comparison != 0)
-						return comparison;
-				}
+			} else if (NUMERIC_IDENTIFER.matcher(bElement).matches())
+				// aElement is not a number but bElement is
+				// by the rules, a goes after b
+				return 1;
+			else {
+				// both are not numbers, compare them
+				final var comparison = aElement.compareTo(bElement);
+				if (comparison != 0)
+					return comparison;
 			}
 		}
-
-		// we just tested the stuff that's in common, maybe someone has more
 		if (aSize < bSize)
 			return -1;
-		else if (aSize > bSize)
+		if (aSize > bSize)
 			return 1;
-		else
-			return 0;
+		return 0;
+
+		// we just tested the stuff that's in common, maybe someone has more
+
 	}
 
 	/**
@@ -365,23 +360,23 @@ public final class SemanticVersionNumber
 	 *
 	 * @param versionString string to parse
 	 * @return {@code SemanticVersionNumber} instance
-	 * @since v0.4.0
 	 * @since 2022-02-19
-	 * @see {@link #toString}
+	 * @since v0.4.0
+	 * @see #toString
 	 */
-	public static final SemanticVersionNumber fromString(String versionString) {
+	public static SemanticVersionNumber fromString(String versionString) {
 		// parse & validate version string
 		Objects.requireNonNull(versionString, "versionString may not be null");
-		final Matcher m = VERSION_NUMBER.matcher(versionString);
+		final var m = VERSION_NUMBER.matcher(versionString);
 		if (!m.matches())
 			throw new IllegalArgumentException(
 					String.format("Provided string \"%s\" is not a version number",
 							versionString));
 
 		// main parts
-		final int major = Integer.parseInt(m.group(1));
-		final int minor = Integer.parseInt(m.group(2));
-		final int patch = Integer.parseInt(m.group(3));
+		final var major = Integer.parseInt(m.group(1));
+		final var minor = Integer.parseInt(m.group(2));
+		final var patch = Integer.parseInt(m.group(3));
 
 		// pre release
 		final List<String> preRelease;
@@ -406,13 +401,13 @@ public final class SemanticVersionNumber
 
 	/**
 	 * Tests whether a string is a valid Semantic Version string
-	 * 
+	 *
 	 * @param versionString string to test
 	 * @return true iff string is valid
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
-	public static final boolean isValidVersionString(String versionString) {
+	public static boolean isValidVersionString(String versionString) {
 		return VERSION_NUMBER.matcher(versionString).matches();
 	}
 
@@ -429,10 +424,10 @@ public final class SemanticVersionNumber
 	 * @throws IllegalArgumentException if any argument is negative or if the
 	 *                                  preReleaseType is null, empty or not
 	 *                                  alphanumeric (0-9, A-Z, a-z, - only)
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
-	public static final SemanticVersionNumber preRelease(int major, int minor,
+	public static SemanticVersionNumber preRelease(int major, int minor,
 			int patch, String preReleaseType, int preReleaseNumber) {
 		if (major < 0)
 			throw new IllegalArgumentException(
@@ -467,10 +462,10 @@ public final class SemanticVersionNumber
 	 * @param patch patch version number
 	 * @return {@code SemanticVersionNumber} instance
 	 * @throws IllegalArgumentException if any argument is negative
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
-	public static final SemanticVersionNumber stableVersion(int major, int minor,
+	public static SemanticVersionNumber stableVersion(int major, int minor,
 			int patch) {
 		if (major < 0)
 			throw new IllegalArgumentException(
@@ -500,8 +495,8 @@ public final class SemanticVersionNumber
 	 * @param patch                 patch version number
 	 * @param preReleaseIdentifiers pre-release version data
 	 * @param buildMetadata         build metadata
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	private SemanticVersionNumber(int major, int minor, int patch,
 			List<String> preReleaseIdentifiers, List<String> buildMetadata) {
@@ -514,8 +509,8 @@ public final class SemanticVersionNumber
 
 	/**
 	 * @return build metadata (empty if there is none)
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public List<String> buildMetadata() {
 		return Collections.unmodifiableList(this.buildMetadata);
@@ -536,17 +531,17 @@ public final class SemanticVersionNumber
 		// test the three big numbers in order first
 		if (this.major < o.major)
 			return -1;
-		else if (this.major > o.major)
+		if (this.major > o.major)
 			return 1;
 
 		if (this.minor < o.minor)
 			return -1;
-		else if (this.minor > o.minor)
+		if (this.minor > o.minor)
 			return 1;
 
 		if (this.patch < o.patch)
 			return -1;
-		else if (this.patch > o.patch)
+		if (this.patch > o.patch)
 			return 1;
 
 		// now we just compare pre-release identifiers
@@ -569,7 +564,7 @@ public final class SemanticVersionNumber
 	 * </ul>
 	 * If this function returns <b>false</b>, you may have to change your code to
 	 * upgrade it to {@code other}
-	 * 
+	 *
 	 * <p>
 	 * Two version numbers that are identical (ignoring build metadata) are
 	 * always compatible. Different version numbers are compatible as long as:
@@ -585,8 +580,8 @@ public final class SemanticVersionNumber
 	 * @param other version to compare with
 	 * @return true if you can definitely upgrade to {@code other} without
 	 *         changing code
-	 * @since v0.4.0
 	 * @since 2022-02-20
+	 * @since v0.4.0
 	 */
 	public boolean compatibleWith(SemanticVersionNumber other) {
 		Objects.requireNonNull(other, "other may not be null");
@@ -601,17 +596,14 @@ public final class SemanticVersionNumber
 			return true;
 		if (!(obj instanceof SemanticVersionNumber))
 			return false;
-		final SemanticVersionNumber other = (SemanticVersionNumber) obj;
+		final var other = (SemanticVersionNumber) obj;
 		if (this.buildMetadata == null) {
 			if (other.buildMetadata != null)
 				return false;
 		} else if (!this.buildMetadata.equals(other.buildMetadata))
 			return false;
-		if (this.major != other.major)
-			return false;
-		if (this.minor != other.minor)
-			return false;
-		if (this.patch != other.patch)
+		if ((this.major != other.major) || (this.minor != other.minor)
+				|| (this.patch != other.patch))
 			return false;
 		if (this.preReleaseIdentifiers == null) {
 			if (other.preReleaseIdentifiers != null)
@@ -624,8 +616,8 @@ public final class SemanticVersionNumber
 
 	@Override
 	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
+		final var prime = 31;
+		var result = 1;
 		result = prime * result
 				+ (this.buildMetadata == null ? 0 : this.buildMetadata.hashCode());
 		result = prime * result + this.major;
@@ -639,8 +631,8 @@ public final class SemanticVersionNumber
 	/**
 	 * @return true iff this version is stable (major version > 0 and not a
 	 *         pre-release)
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public boolean isStable() {
 		return this.major > 0 && this.preReleaseIdentifiers.isEmpty();
@@ -649,8 +641,8 @@ public final class SemanticVersionNumber
 	/**
 	 * @return the MAJOR version number, incremented when you make backwards
 	 *         incompatible API changes
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public int majorVersion() {
 		return this.major;
@@ -659,8 +651,8 @@ public final class SemanticVersionNumber
 	/**
 	 * @return the MINOR version number, incremented when you add backwards
 	 *         compatible functionality
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public int minorVersion() {
 		return this.minor;
@@ -669,8 +661,8 @@ public final class SemanticVersionNumber
 	/**
 	 * @return the PATCH version number, incremented when you make backwards
 	 *         compatible bug fixes
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public int patchVersion() {
 		return this.patch;
@@ -679,8 +671,8 @@ public final class SemanticVersionNumber
 	/**
 	 * @return identifiers describing this pre-release (empty if not a
 	 *         pre-release)
-	 * @since v0.4.0
 	 * @since 2022-02-19
+	 * @since v0.4.0
 	 */
 	public List<String> preReleaseIdentifiers() {
 		return Collections.unmodifiableList(this.preReleaseIdentifiers);
@@ -697,13 +689,13 @@ public final class SemanticVersionNumber
 	 * For example, the version with major number 3, minor number 2, patch number
 	 * 1, pre-release identifiers "alpha" and "1" and build metadata "2022-02-19"
 	 * has a string representation "3.2.1-alpha.1+2022-02-19".
-	 * 
+	 *
 	 * @since v0.4.0
 	 * @see <a href="https://semver.org">The official SemVer specification</a>
 	 */
 	@Override
 	public String toString() {
-		String versionString = String.format("%d.%d.%d", this.major, this.minor,
+		var versionString = String.format("%d.%d.%d", this.major, this.minor,
 				this.patch);
 		if (!this.preReleaseIdentifiers.isEmpty()) {
 			versionString += "-" + String.join(".", this.preReleaseIdentifiers);
diff --git a/src/main/java/sevenUnits/utils/UncertainDouble.java b/src/main/java/sevenUnits/utils/UncertainDouble.java
index 66d8103..24ada20 100644
--- a/src/main/java/sevenUnits/utils/UncertainDouble.java
+++ b/src/main/java/sevenUnits/utils/UncertainDouble.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2020 Adrien Hopkins
+ * Copyright (C) 2020-2022, 2024, 2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -19,7 +19,6 @@ package sevenUnits.utils;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.Objects;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -29,56 +28,59 @@ import java.util.regex.Pattern;
  * arguments is null.
  *
  * @since 2020-09-07
+ * @since v0.3.0
  */
 public final class UncertainDouble implements Comparable<UncertainDouble> {
-	/**
-	 * The exact value 0
-	 */
+	/** The exact value 0 */
 	public static final UncertainDouble ZERO = UncertainDouble.of(0, 0);
 
 	static final String NUMBER_REGEX = "(\\d+(?:[\\.,]\\d+))";
 
-	/**
-	 * A regular expression that can recognize toString forms
-	 */
+	/** A regular expression that can recognize toString forms */
 	static final Pattern TO_STRING = Pattern.compile(NUMBER_REGEX
-			// optional "� [number]"
-			+ "(?:\\s*(?:�|\\+-)\\s*" + NUMBER_REGEX + ")?");
+			// optional "± [number]"
+			+ "(?:\\s*(?:±|\\+-)\\s*" + NUMBER_REGEX + ")?");
 
 	/**
 	 * Gets an UncertainDouble from a double string. The uncertainty of the
 	 * double will be one of the lowest decimal place of the number. For example,
-	 * "12345.678" will become 12345.678 � 0.001.
-	 * 
+	 * "12345.678" will become 12345.678 ± 0.001.
+	 *
+	 * @param s string to parse
+	 * @return parsed {@code UncertainDouble}
+	 *
 	 * @throws NumberFormatException if the argument is not a number
 	 *
 	 * @since 2022-04-18
+	 * @since v0.4.0
 	 */
-	public static final UncertainDouble fromRoundedString(String s) {
-		final BigDecimal value = new BigDecimal(s);
-		final double uncertainty = Math.pow(10, -value.scale());
+	public static UncertainDouble fromRoundedString(String s) {
+		final var value = new BigDecimal(s);
+		final var uncertainty = Math.pow(10, -value.scale());
 		return UncertainDouble.of(value.doubleValue(), uncertainty);
 	}
 
 	/**
-	 * Parses a string in the form of {@link UncertainDouble#toString(boolean)}
-	 * and returns the corresponding {@code UncertainDouble} instance.
+	 * Parses a string in the form of
+	 * {@link UncertainDouble#toString(boolean, RoundingMode)} and returns the
+	 * corresponding {@code UncertainDouble} instance.
 	 * <p>
 	 * This method allows some alternative forms of the string representation,
-	 * such as using "+-" instead of "�".
-	 * 
+	 * such as using "+-" instead of "±".
+	 *
 	 * @param s string to parse
 	 * @return {@code UncertainDouble} instance
 	 * @throws IllegalArgumentException if the string is invalid
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public static final UncertainDouble fromString(String s) {
+	public static UncertainDouble fromString(String s) {
 		Objects.requireNonNull(s, "s may not be null");
-		final Matcher matcher = TO_STRING.matcher(s);
+		final var matcher = TO_STRING.matcher(s);
 
 		if (!matcher.matches())
 			throw new IllegalArgumentException(
-					"Could not parse stirng \"" + s + "\".");
+					"Could not parse string \"" + s + "\".");
 
 		double value, uncertainty;
 		try {
@@ -88,7 +90,7 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 					"String " + s + " not in correct format.");
 		}
 
-		final String uncertaintyString = matcher.group(2);
+		final var uncertaintyString = matcher.group(2);
 		if (uncertaintyString == null) {
 			uncertainty = 0;
 		} else {
@@ -106,20 +108,32 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	/**
 	 * Gets an {@code UncertainDouble} from its value and <b>absolute</b>
 	 * uncertainty.
-	 * 
+	 *
+	 * @param value       double's value
+	 * @param uncertainty double's uncertainty (non-negative)
+	 * @return {@code UncertainDouble} instance with these parameters
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public static final UncertainDouble of(double value, double uncertainty) {
+	public static UncertainDouble of(double value, double uncertainty) {
 		return new UncertainDouble(value, uncertainty);
 	}
 
 	/**
 	 * Gets an {@code UncertainDouble} from its value and <b>relative</b>
 	 * uncertainty.
-	 * 
+	 *
+	 * @param value               double's value
+	 * @param relativeUncertainty double's uncertainty (non-negative); the
+	 *                            absolute uncertainty is equal to this value
+	 *                            multiplied by {@code relativeUncertainty}
+	 * @return {@code UncertainDouble} instance with these parameters
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public static final UncertainDouble ofRelative(double value,
+	public static UncertainDouble ofRelative(double value,
 			double relativeUncertainty) {
 		return new UncertainDouble(value, value * relativeUncertainty);
 	}
@@ -132,6 +146,7 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	 * @param value
 	 * @param uncertainty
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	private UncertainDouble(double value, double uncertainty) {
 		this.value = value;
@@ -153,16 +168,20 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	 * {@code false}.
 	 */
 	@Override
-	public final int compareTo(UncertainDouble o) {
+	public int compareTo(UncertainDouble o) {
 		return Double.compare(this.value, o.value);
 	}
 
 	/**
 	 * Returns the quotient of {@code this} and {@code other}.
-	 * 
+	 *
+	 * @param other number to divide by
+	 * @return quotient
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble dividedBy(UncertainDouble other) {
+	public UncertainDouble dividedBy(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 		return UncertainDouble.ofRelative(this.value / other.value, Math
 				.hypot(this.relativeUncertainty(), other.relativeUncertainty()));
@@ -170,23 +189,26 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * Returns the quotient of {@code this} and the exact value {@code other}.
-	 * 
+	 *
+	 * @param other number to divide by
+	 * @return quotient
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble dividedByExact(double other) {
+	public UncertainDouble dividedByExact(double other) {
 		return UncertainDouble.of(this.value / other, this.uncertainty / other);
 	}
 
 	@Override
-	public final boolean equals(Object obj) {
+	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (!(obj instanceof UncertainDouble))
 			return false;
-		final UncertainDouble other = (UncertainDouble) obj;
-		if (Double.compare(this.value, other.value) != 0)
-			return false;
-		if (Double.compare(this.uncertainty, other.uncertainty) != 0)
+		final var other = (UncertainDouble) obj;
+		if ((Double.compare(this.value, other.value) != 0)
+				|| (Double.compare(this.uncertainty, other.uncertainty) != 0))
 			return false;
 		return true;
 	}
@@ -196,8 +218,9 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	 * @return true iff this and {@code other} are within each other's
 	 *         uncertainty range.
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final boolean equivalent(UncertainDouble other) {
+	public boolean equivalent(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 		return Math.abs(this.value - other.value) <= Math.min(this.uncertainty,
 				other.uncertainty);
@@ -205,10 +228,11 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * Gets the preferred scale for rounding a value for toString.
-	 * 
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	private final int getDisplayScale() {
+	private int getDisplayScale() {
 		// round based on uncertainty
 		// if uncertainty starts with 1 (ignoring zeroes and the decimal
 		// point), rounds
@@ -216,24 +240,23 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 		// otherwise, rounds so that uncertainty has 1 significant digits.
 		// the value is rounded to the same number of decimal places as the
 		// uncertainty.
-		final BigDecimal bigUncertainty = BigDecimal.valueOf(this.uncertainty);
+		final var bigUncertainty = BigDecimal.valueOf(this.uncertainty);
 
 		// the scale that will give the uncertainty two decimal places
-		final int twoDecimalPlacesScale = bigUncertainty.scale()
+		final var twoDecimalPlacesScale = bigUncertainty.scale()
 				- bigUncertainty.precision() + 2;
-		final BigDecimal roundedUncertainty = bigUncertainty
+		final var roundedUncertainty = bigUncertainty
 				.setScale(twoDecimalPlacesScale, RoundingMode.HALF_EVEN);
 
 		if (roundedUncertainty.unscaledValue().intValue() >= 20)
 			return twoDecimalPlacesScale - 1; // one decimal place
-		else
-			return twoDecimalPlacesScale;
+		return twoDecimalPlacesScale;
 	}
 
 	@Override
-	public final int hashCode() {
-		final int prime = 31;
-		int result = 1;
+	public int hashCode() {
+		final var prime = 31;
+		var result = 1;
 		result = prime * result + Double.hashCode(this.value);
 		result = prime * result + Double.hashCode(this.uncertainty);
 		return result;
@@ -241,19 +264,24 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * @return true iff the value has no uncertainty
-	 * 
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final boolean isExact() {
+	public boolean isExact() {
 		return this.uncertainty == 0;
 	}
 
 	/**
 	 * Returns the difference of {@code this} and {@code other}.
-	 * 
+	 *
+	 * @param other number to subtract
+	 * @return result of subtraction
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble minus(UncertainDouble other) {
+	public UncertainDouble minus(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 		return UncertainDouble.of(this.value - other.value,
 				Math.hypot(this.uncertainty, other.uncertainty));
@@ -261,19 +289,27 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * Returns the difference of {@code this} and the exact value {@code other}.
-	 * 
+	 *
+	 * @param other number to subtract
+	 * @return result of subtraction
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble minusExact(double other) {
+	public UncertainDouble minusExact(double other) {
 		return UncertainDouble.of(this.value - other, this.uncertainty);
 	}
 
 	/**
 	 * Returns the sum of {@code this} and {@code other}.
-	 * 
+	 *
+	 * @param other number to add
+	 * @return result of addition
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble plus(UncertainDouble other) {
+	public UncertainDouble plus(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 		return UncertainDouble.of(this.value + other.value,
 				Math.hypot(this.uncertainty, other.uncertainty));
@@ -281,27 +317,36 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * Returns the sum of {@code this} and the exact value {@code other}.
-	 * 
+	 *
+	 * @param other number to add
+	 * @return result of addition
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble plusExact(double other) {
+	public UncertainDouble plusExact(double other) {
 		return UncertainDouble.of(this.value + other, this.uncertainty);
 	}
 
 	/**
 	 * @return relative uncertainty
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final double relativeUncertainty() {
+	public double relativeUncertainty() {
 		return this.uncertainty / this.value;
 	}
 
 	/**
 	 * Returns the product of {@code this} and {@code other}.
-	 * 
+	 *
+	 * @param other number to multiply
+	 * @return product
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble times(UncertainDouble other) {
+	public UncertainDouble times(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 		return UncertainDouble.ofRelative(this.value * other.value, Math
 				.hypot(this.relativeUncertainty(), other.relativeUncertainty()));
@@ -309,23 +354,31 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 	/**
 	 * Returns the product of {@code this} and the exact value {@code other}.
-	 * 
+	 *
+	 * @param other number to multiply
+	 * @return product
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble timesExact(double other) {
+	public UncertainDouble timesExact(double other) {
 		return UncertainDouble.of(this.value * other, this.uncertainty * other);
 	}
 
 	/**
 	 * Returns the result of {@code this} raised to the exponent {@code other}.
-	 * 
+	 *
+	 * @param other exponent
+	 * @return result of exponentation
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble toExponent(UncertainDouble other) {
+	public UncertainDouble toExponent(UncertainDouble other) {
 		Objects.requireNonNull(other, "other may not be null");
 
-		final double result = Math.pow(this.value, other.value);
-		final double relativeUncertainty = Math.hypot(
+		final var result = Math.pow(this.value, other.value);
+		final var relativeUncertainty = Math.hypot(
 				other.value * this.relativeUncertainty(),
 				Math.log(this.value) * other.uncertainty);
 
@@ -335,10 +388,14 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	/**
 	 * Returns the result of {@code this} raised the exact exponent
 	 * {@code other}.
-	 * 
+	 *
+	 * @param other exponent
+	 * @return result of exponentation
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final UncertainDouble toExponentExact(double other) {
+	public UncertainDouble toExponentExact(double other) {
 		return UncertainDouble.ofRelative(Math.pow(this.value, other),
 				this.relativeUncertainty() * other);
 	}
@@ -346,23 +403,24 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	/**
 	 * Returns a string representation of this {@code UncertainDouble}.
 	 * <p>
-	 * This method returns the same value as {@link #toString(boolean)}, but
-	 * {@code showUncertainty} is true if and only if the uncertainty is
-	 * non-zero.
-	 * 
+	 * This method returns the same value as
+	 * {@link #toString(boolean, RoundingMode)}, but {@code showUncertainty} is
+	 * true if and only if the uncertainty is non-zero.
+	 *
 	 * <p>
 	 * Examples:
-	 * 
+	 *
 	 * <pre>
 	 * UncertainDouble.of(3.27, 0.22).toString() = "3.3 � 0.2"
 	 * UncertainDouble.of(3.27, 0.13).toString() = "3.27 � 0.13"
 	 * UncertainDouble.of(-5.01, 0).toString() = "-5.01"
 	 * </pre>
-	 * 
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
 	@Override
-	public final String toString() {
+	public String toString() {
 		return this.toString(!this.isExact(), RoundingMode.HALF_EVEN);
 	}
 
@@ -370,7 +428,7 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	 * Returns a string representation of this {@code UncertainDouble}.
 	 * <p>
 	 * If {@code showUncertainty} is true, the string will be of the form "VALUE
-	 * � UNCERTAINTY", and if it is false the string will be of the form "VALUE"
+	 * ± UNCERTAINTY", and if it is false the string will be of the form "VALUE"
 	 * <p>
 	 * VALUE represents a string representation of this {@code UncertainDouble}'s
 	 * value. If the uncertainty is non-zero, the string will be rounded to the
@@ -382,20 +440,24 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 	 * digits otherwise it will be rounded to one significant digit.
 	 * <p>
 	 * Examples:
-	 * 
+	 *
 	 * <pre>
 	 * UncertainDouble.of(3.27, 0.22).toString(false) = "3.3"
-	 * UncertainDouble.of(3.27, 0.22).toString(true) = "3.3 � 0.2"
+	 * UncertainDouble.of(3.27, 0.22).toString(true) = "3.3 ± 0.2"
 	 * UncertainDouble.of(3.27, 0.13).toString(false) = "3.27"
-	 * UncertainDouble.of(3.27, 0.13).toString(true) = "3.27 � 0.13"
+	 * UncertainDouble.of(3.27, 0.13).toString(true) = "3.27 ± 0.13"
 	 * UncertainDouble.of(-5.01, 0).toString(false) = "-5.01"
-	 * UncertainDouble.of(-5.01, 0).toString(true) = "-5.01 � 0.0"
+	 * UncertainDouble.of(-5.01, 0).toString(true) = "-5.01 ± 0.0"
 	 * </pre>
-	 * 
+	 *
+	 * @param showUncertainty uncertainty is only shown if this parameter is true
+	 * @param roundingMode    how to round values
+	 * @return string representation of this {@code UncertainDouble}
+	 *
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final String toString(boolean showUncertainty,
-			RoundingMode roundingMode) {
+	public String toString(boolean showUncertainty, RoundingMode roundingMode) {
 		String valueString, uncertaintyString;
 
 		// generate the string representation of value and uncertainty
@@ -405,36 +467,37 @@ public final class UncertainDouble implements Comparable<UncertainDouble> {
 
 		} else {
 			// round the value and uncertainty according to getDisplayScale()
-			final BigDecimal bigValue = BigDecimal.valueOf(this.value);
-			final BigDecimal bigUncertainty = BigDecimal.valueOf(this.uncertainty);
+			final var bigValue = BigDecimal.valueOf(this.value);
+			final var bigUncertainty = BigDecimal.valueOf(this.uncertainty);
 
-			final int displayScale = this.getDisplayScale();
-			final BigDecimal roundedUncertainty = bigUncertainty
-					.setScale(displayScale, roundingMode);
-			final BigDecimal roundedValue = bigValue.setScale(displayScale,
+			final var displayScale = this.getDisplayScale();
+			final var roundedUncertainty = bigUncertainty.setScale(displayScale,
 					roundingMode);
+			final var roundedValue = bigValue.setScale(displayScale, roundingMode);
 
 			valueString = roundedValue.toString();
 			uncertaintyString = roundedUncertainty.toString();
 		}
 
-		// return "value" or "value � uncertainty" depending on showUncertainty
-		return valueString + (showUncertainty ? " � " + uncertaintyString : "");
+		// return "value" or "value ± uncertainty" depending on showUncertainty
+		return valueString + (showUncertainty ? " ± " + uncertaintyString : "");
 	}
 
 	/**
 	 * @return absolute uncertainty
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final double uncertainty() {
+	public double uncertainty() {
 		return this.uncertainty;
 	}
 
 	/**
 	 * @return value without uncertainty
 	 * @since 2020-09-07
+	 * @since v0.3.0
 	 */
-	public final double value() {
+	public double value() {
 		return this.value;
 	}
 }
diff --git a/src/main/java/sevenUnits/utils/package-info.java b/src/main/java/sevenUnits/utils/package-info.java
index 350c62d..b600c17 100644
--- a/src/main/java/sevenUnits/utils/package-info.java
+++ b/src/main/java/sevenUnits/utils/package-info.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2018-2020 Adrien Hopkins
+ * Copyright (C) 2018-2025 Adrien Hopkins
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -17,7 +17,7 @@
 /**
  * Supplementary classes that are not related to units, but are necessary for
  * their function.
- * 
+ *
  * @author Adrien Hopkins
  * @since 2019-03-14
  * @since v0.2.0