From 72eed55d9f834de8302564fbe6dfa3d1d446afb4 Mon Sep 17 00:00:00 2001 From: Adrien Hopkins Date: Sat, 7 Aug 2021 15:25:54 -0500 Subject: Renamed sevenUnits.math to sevenUnits.utils --- src/main/java/sevenUnits/unit/FunctionalUnit.java | 2 +- src/main/java/sevenUnits/unit/FunctionalUnitlike.java | 2 +- src/main/java/sevenUnits/unit/LinearUnit.java | 6 +++--- src/main/java/sevenUnits/unit/LinearUnitValue.java | 4 ++-- src/main/java/sevenUnits/unit/MultiUnit.java | 2 +- src/main/java/sevenUnits/unit/SI.java | 2 +- src/main/java/sevenUnits/unit/Unit.java | 4 ++-- src/main/java/sevenUnits/unit/UnitDatabase.java | 10 +++++----- src/main/java/sevenUnits/unit/UnitPrefix.java | 2 +- src/main/java/sevenUnits/unit/Unitlike.java | 2 +- 10 files changed, 18 insertions(+), 18 deletions(-) (limited to 'src/main/java/sevenUnits/unit') diff --git a/src/main/java/sevenUnits/unit/FunctionalUnit.java b/src/main/java/sevenUnits/unit/FunctionalUnit.java index 7bacc9d..df457e4 100644 --- a/src/main/java/sevenUnits/unit/FunctionalUnit.java +++ b/src/main/java/sevenUnits/unit/FunctionalUnit.java @@ -19,7 +19,7 @@ package sevenUnits.unit; import java.util.Objects; import java.util.function.DoubleUnaryOperator; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.ObjectProduct; /** * A unit that uses functional objects to convert to and from its base. diff --git a/src/main/java/sevenUnits/unit/FunctionalUnitlike.java b/src/main/java/sevenUnits/unit/FunctionalUnitlike.java index 61503e8..2ee9e19 100644 --- a/src/main/java/sevenUnits/unit/FunctionalUnitlike.java +++ b/src/main/java/sevenUnits/unit/FunctionalUnitlike.java @@ -19,7 +19,7 @@ package sevenUnits.unit; import java.util.function.DoubleFunction; import java.util.function.ToDoubleFunction; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.ObjectProduct; /** * A unitlike form that converts using two conversion functions. diff --git a/src/main/java/sevenUnits/unit/LinearUnit.java b/src/main/java/sevenUnits/unit/LinearUnit.java index 7c46443..25c2e2e 100644 --- a/src/main/java/sevenUnits/unit/LinearUnit.java +++ b/src/main/java/sevenUnits/unit/LinearUnit.java @@ -18,9 +18,9 @@ package sevenUnits.unit; import java.util.Objects; -import sevenUnits.math.DecimalComparison; -import sevenUnits.math.ObjectProduct; -import sevenUnits.math.UncertainDouble; +import sevenUnits.utils.DecimalComparison; +import sevenUnits.utils.ObjectProduct; +import sevenUnits.utils.UncertainDouble; /** * A unit that can be expressed as a product of its base and a number. For diff --git a/src/main/java/sevenUnits/unit/LinearUnitValue.java b/src/main/java/sevenUnits/unit/LinearUnitValue.java index 687a8b4..ffb9271 100644 --- a/src/main/java/sevenUnits/unit/LinearUnitValue.java +++ b/src/main/java/sevenUnits/unit/LinearUnitValue.java @@ -19,8 +19,8 @@ package sevenUnits.unit; import java.util.Objects; import java.util.Optional; -import sevenUnits.math.DecimalComparison; -import sevenUnits.math.UncertainDouble; +import sevenUnits.utils.DecimalComparison; +import sevenUnits.utils.UncertainDouble; /** * A possibly uncertain value expressed in a linear unit. diff --git a/src/main/java/sevenUnits/unit/MultiUnit.java b/src/main/java/sevenUnits/unit/MultiUnit.java index 014e055..83cdb03 100644 --- a/src/main/java/sevenUnits/unit/MultiUnit.java +++ b/src/main/java/sevenUnits/unit/MultiUnit.java @@ -20,7 +20,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.ObjectProduct; /** * A combination of units, like "5 foot + 7 inch". All but the last units should diff --git a/src/main/java/sevenUnits/unit/SI.java b/src/main/java/sevenUnits/unit/SI.java index e0e5a54..278fb5e 100644 --- a/src/main/java/sevenUnits/unit/SI.java +++ b/src/main/java/sevenUnits/unit/SI.java @@ -18,7 +18,7 @@ package sevenUnits.unit; import java.util.Set; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.ObjectProduct; /** * All of the units, prefixes and dimensions that are used by the SI, as well as diff --git a/src/main/java/sevenUnits/unit/Unit.java b/src/main/java/sevenUnits/unit/Unit.java index 1e875af..8fcacb8 100644 --- a/src/main/java/sevenUnits/unit/Unit.java +++ b/src/main/java/sevenUnits/unit/Unit.java @@ -23,8 +23,8 @@ import java.util.Objects; import java.util.Set; import java.util.function.DoubleUnaryOperator; -import sevenUnits.math.DecimalComparison; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.DecimalComparison; +import sevenUnits.utils.ObjectProduct; /** * A unit that is composed of base units. diff --git a/src/main/java/sevenUnits/unit/UnitDatabase.java b/src/main/java/sevenUnits/unit/UnitDatabase.java index 1960229..a40f000 100644 --- a/src/main/java/sevenUnits/unit/UnitDatabase.java +++ b/src/main/java/sevenUnits/unit/UnitDatabase.java @@ -44,11 +44,11 @@ import java.util.function.Predicate; import java.util.regex.Matcher; import java.util.regex.Pattern; -import sevenUnits.math.ConditionalExistenceCollections; -import sevenUnits.math.DecimalComparison; -import sevenUnits.math.ExpressionParser; -import sevenUnits.math.ObjectProduct; -import sevenUnits.math.UncertainDouble; +import sevenUnits.utils.ConditionalExistenceCollections; +import sevenUnits.utils.DecimalComparison; +import sevenUnits.utils.ExpressionParser; +import sevenUnits.utils.ObjectProduct; +import sevenUnits.utils.UncertainDouble; /** * A database of units, prefixes and dimensions, and their names. diff --git a/src/main/java/sevenUnits/unit/UnitPrefix.java b/src/main/java/sevenUnits/unit/UnitPrefix.java index e4a27bd..308f4b0 100644 --- a/src/main/java/sevenUnits/unit/UnitPrefix.java +++ b/src/main/java/sevenUnits/unit/UnitPrefix.java @@ -20,7 +20,7 @@ import java.util.Objects; import java.util.Optional; import java.util.Set; -import sevenUnits.math.DecimalComparison; +import sevenUnits.utils.DecimalComparison; /** * A prefix that can be applied to a {@code LinearUnit} to multiply it by some value diff --git a/src/main/java/sevenUnits/unit/Unitlike.java b/src/main/java/sevenUnits/unit/Unitlike.java index fd361b6..d2dcbbb 100644 --- a/src/main/java/sevenUnits/unit/Unitlike.java +++ b/src/main/java/sevenUnits/unit/Unitlike.java @@ -22,7 +22,7 @@ import java.util.Objects; import java.util.function.DoubleFunction; import java.util.function.ToDoubleFunction; -import sevenUnits.math.ObjectProduct; +import sevenUnits.utils.ObjectProduct; /** * An object that can convert a value between multiple forms (instances of the -- cgit v1.2.3 From 1cb69cfdcb18bbafdbc792174697732e7cf359e7 Mon Sep 17 00:00:00 2001 From: Adrien Hopkins Date: Thu, 26 Aug 2021 07:52:45 -0500 Subject: Added units and dimensions to the design document --- docs/design.org | 23 + .../converterGUI/DefaultPrefixRepetitionRule.java | 12 +- .../sevenUnits/converterGUI/SevenUnitsGUI.java | 32 +- src/main/java/sevenUnits/unit/BritishImperial.java | 22 +- src/main/java/sevenUnits/unit/LinearUnitValue.java | 2 +- src/main/java/sevenUnits/unit/Metric.java | 479 +++++++++++++++++++++ src/main/java/sevenUnits/unit/SI.java | 479 --------------------- src/main/java/sevenUnits/unit/USCustomary.java | 8 +- src/main/java/sevenUnits/unit/Unit.java | 12 +- src/main/java/sevenUnits/unit/UnitDatabase.java | 8 +- src/test/java/sevenUnits/unit/MultiUnitTest.java | 6 +- .../java/sevenUnits/unit/UnitDatabaseTest.java | 16 +- src/test/java/sevenUnits/unit/UnitTest.java | 50 +-- .../java/sevenUnits/utils/ObjectProductTest.java | 22 +- 14 files changed, 597 insertions(+), 574 deletions(-) create mode 100644 src/main/java/sevenUnits/unit/Metric.java delete mode 100644 src/main/java/sevenUnits/unit/SI.java (limited to 'src/main/java/sevenUnits/unit') diff --git a/docs/design.org b/docs/design.org index 383a707..41713eb 100644 --- a/docs/design.org +++ b/docs/design.org @@ -11,8 +11,31 @@ * Unit System Design Any code related to the backend unit system is stored in the ~sevenUnits.unit~ package. ** Dimensions + Dimensions represent what a unit is measuring, such as length, time, or energy. Dimensions are represented as an [[*ObjectProduct][ObjectProduct]], where ~BaseDimension~ is a very simple class (its only properties are a name and a symbol) which represents the dimension of a base unit; these base dimensions can be multiplied to create all other Dimensions. ** Unit Classes + Units are internally represented by the abstract class ~Unit~. All units have an [[*ObjectProduct][ObjectProduct]] (referred to as the base) that they are based on, a dimension (ObjectProduct), one or more names and a symbol (these last two bits of data are contained in the ~NameSymbol~ class). The dimension is calculated from the base unit when needed; the variable is just a cache. It has two constructors: a package-private one used to make ~BaseUnit~ instances, and a protected one used to make general units (for other subclasses of ~Unit~). All unit classes are immutable. + + Units also have two conversion functions - one which converts from a value expressed in this unit to its base unit, and another which converts from a value expressed in the base unit to this unit. In ~Unit~, they are defined as two abstract methods. This allows you to convert from any unit to any other (as long as they have the same base, i.e. you aren't converting metres to pounds). To convert from A to B, first convert from A to its base, then convert from the base to B. + + ~BaseUnit~ represents a unit that all other units are defined by. All of the units used by this system are defined by seven SI ~BaseUnit~ instances (metre, second, kilogram, ampere, kelvin, mole, candela; this is what 7Units is named after) and two non-SI ~BaseUnit~ instances (US dollar and bit). Because base units are themselves units (and should be able to be used as units), ~BaseUnit~ is a subclass of ~Unit~, using its own package-private constructor. + + However, most units are instances of ~LinearUnit~, another subclass of ~Unit~. ~LinearUnit~ represents a unit that is /a product of a base unit and a constant called the *conversion factor*/. Most units you've ever used fall under this definition, the only common exceptions are degrees Celsius and Fahrenheit. This simplicity allows the ~LinearUnit~ to do many things: + - It can implement conversion to and from the base as multiplying and dividing respectively by the conversion factor + - You can easily create new units by multiplying or dividing a ~LinearUnit~ by a number (for example, kilometre = metre * 1000). This can be easily implemented as multiplying this unit's conversion factor by the multiplier and returning a new ~LinearUnit~ with that conversion factor factor. + - You can add or subtract two ~LinearUnit~ instances to create a third (as long as they have the same base) by adding or subtracting the conversion factor. + - You can multiply or divide any two ~LinearUnit~ instances to create a third by multiplying or dividing the bases and conversion factors. + - Note that any operations will return a unit without name(s) or a symbol. All unit classes have a ~withName~ method that returns a copy of them with different names and/or a different symbol (all of this info is contained in the ~NameSymbol~ class) + + There are a few more classes which play small roles in the unit system: + - Unitlike :: A class that is like a unit, but its "value" can be any class. The only use of this class right now is to implement ~MultiUnit~, a combination of units (like "foot + inch", commonly used in North America for measuring height); its "value" is a list of numbers. + - FunctionalUnit :: A convenience class that implements the two conversion functions of ~Unit~ using ~DoubleUnaryOperator~ instances. This is used internally to implement degrees Celsius and Fahrenheit. There is also a version of this for ~Unitlike~, ~FunctionalUnitlike~. + - UnitValue :: A value expressed as a certain unit (such as "7 inches"). This class is used by the simple unit converter to represent units. You can convert them between units. There are also versions of this for ~LinearUnit~ and ~Unitlike~. + - Metric :: A static utility class with instances of all of the SI named units, the 9 base dimensions, SI prefixes, some common prefixed units like the kilometre, and a few non-SI units used commonly with them. + - BritishImperial :: A static utility class with instances of common units in the British Imperial system (not to be confused with the US Customary system, which is also called "Imperial"; it has the same unit names but the values of a few units are different). This class and the US Customary is divided into static classes for each dimension, such as ~BritishImperial.Length~. + - USCustomary :: A static utility class with instances of common units in the US Customary system (not to be confused with the British Imperial system; it has the same unit names but the values of a few units are different). ** Prefixes + +** The Unit Database * Utility Classes 7Units has a few general "utility" classes. They aren't directly related to units, but are used in the units system. ** ObjectProduct diff --git a/src/main/java/sevenUnits/converterGUI/DefaultPrefixRepetitionRule.java b/src/main/java/sevenUnits/converterGUI/DefaultPrefixRepetitionRule.java index 835651e..6b6abf0 100644 --- a/src/main/java/sevenUnits/converterGUI/DefaultPrefixRepetitionRule.java +++ b/src/main/java/sevenUnits/converterGUI/DefaultPrefixRepetitionRule.java @@ -6,7 +6,7 @@ package sevenUnits.converterGUI; import java.util.List; import java.util.function.Predicate; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; import sevenUnits.unit.UnitPrefix; /** @@ -49,7 +49,7 @@ enum DefaultPrefixRepetitionRule implements Predicate> { // if the first prefix is non-metric (including binary prefixes), // assume we are using non-metric prefixes // non-metric prefixes are allowed, but can't be repeated. - if (!SI.DECIMAL_PREFIXES.contains(prefixes.get(0))) + if (!Metric.DECIMAL_PREFIXES.contains(prefixes.get(0))) return NO_REPETITION.test(prefixes); int part = 0; // 0=yotta/yoctos, 1=kilo-zetta/milli-zepto, @@ -58,7 +58,7 @@ enum DefaultPrefixRepetitionRule implements Predicate> { for (final UnitPrefix prefix : prefixes) { // check that the current prefix is metric and appropriately // magnifying/reducing - if (!SI.DECIMAL_PREFIXES.contains(prefix)) + if (!Metric.DECIMAL_PREFIXES.contains(prefix)) return false; if (magnifying != prefix.getMultiplier() > 1) return false; @@ -72,7 +72,7 @@ enum DefaultPrefixRepetitionRule implements Predicate> { break; case 1: // after a kilo-zetta, only deka/hecto are valid - if (SI.THOUSAND_PREFIXES.contains(prefix)) + if (Metric.THOUSAND_PREFIXES.contains(prefix)) return false; break; case 2: @@ -81,9 +81,9 @@ enum DefaultPrefixRepetitionRule implements Predicate> { } // set part - if (SI.YOTTA.equals(prefix) || SI.YOCTO.equals(prefix)) { + if (Metric.YOTTA.equals(prefix) || Metric.YOCTO.equals(prefix)) { part = 0; - } else if (SI.THOUSAND_PREFIXES.contains(prefix)) { + } else if (Metric.THOUSAND_PREFIXES.contains(prefix)) { part = 1; } else { part = 2; diff --git a/src/main/java/sevenUnits/converterGUI/SevenUnitsGUI.java b/src/main/java/sevenUnits/converterGUI/SevenUnitsGUI.java index e1eb2f4..bfd5974 100644 --- a/src/main/java/sevenUnits/converterGUI/SevenUnitsGUI.java +++ b/src/main/java/sevenUnits/converterGUI/SevenUnitsGUI.java @@ -70,7 +70,7 @@ import sevenUnits.unit.BritishImperial; import sevenUnits.unit.LinearUnit; import sevenUnits.unit.LinearUnitValue; import sevenUnits.unit.NameSymbol; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; import sevenUnits.unit.Unit; import sevenUnits.unit.UnitDatabase; import sevenUnits.unit.UnitPrefix; @@ -110,25 +110,25 @@ final class SevenUnitsGUI { * @since v0.2.0 */ private static void addDefaults(final UnitDatabase database) { - database.addUnit("metre", SI.METRE); - database.addUnit("kilogram", SI.KILOGRAM); - database.addUnit("gram", SI.KILOGRAM.dividedBy(1000)); - database.addUnit("second", SI.SECOND); - database.addUnit("ampere", SI.AMPERE); - database.addUnit("kelvin", SI.KELVIN); - database.addUnit("mole", SI.MOLE); - database.addUnit("candela", SI.CANDELA); - database.addUnit("bit", SI.BIT); - database.addUnit("unit", SI.ONE); + database.addUnit("metre", Metric.METRE); + database.addUnit("kilogram", Metric.KILOGRAM); + database.addUnit("gram", Metric.KILOGRAM.dividedBy(1000)); + database.addUnit("second", Metric.SECOND); + database.addUnit("ampere", Metric.AMPERE); + database.addUnit("kelvin", Metric.KELVIN); + database.addUnit("mole", Metric.MOLE); + database.addUnit("candela", Metric.CANDELA); + database.addUnit("bit", Metric.BIT); + database.addUnit("unit", Metric.ONE); // nonlinear units - must be loaded manually - database.addUnit("tempCelsius", SI.CELSIUS); + database.addUnit("tempCelsius", Metric.CELSIUS); database.addUnit("tempFahrenheit", BritishImperial.FAHRENHEIT); // load initial dimensions - database.addDimension("LENGTH", SI.Dimensions.LENGTH); - database.addDimension("MASS", SI.Dimensions.MASS); - database.addDimension("TIME", SI.Dimensions.TIME); - database.addDimension("TEMPERATURE", SI.Dimensions.TEMPERATURE); + database.addDimension("LENGTH", Metric.Dimensions.LENGTH); + database.addDimension("MASS", Metric.Dimensions.MASS); + database.addDimension("TIME", Metric.Dimensions.TIME); + database.addDimension("TEMPERATURE", Metric.Dimensions.TEMPERATURE); } /** diff --git a/src/main/java/sevenUnits/unit/BritishImperial.java b/src/main/java/sevenUnits/unit/BritishImperial.java index 63da7f0..81a3f2a 100644 --- a/src/main/java/sevenUnits/unit/BritishImperial.java +++ b/src/main/java/sevenUnits/unit/BritishImperial.java @@ -48,7 +48,7 @@ public final class BritishImperial { /** * According to the International Yard and Pound of 1959, a yard is defined as exactly 0.9144 metres. */ - public static final LinearUnit YARD = SI.METRE.times(0.9144); + public static final LinearUnit YARD = Metric.METRE.times(0.9144); public static final LinearUnit FOOT = YARD.dividedBy(3); public static final LinearUnit INCH = FOOT.dividedBy(12); public static final LinearUnit THOU = INCH.dividedBy(1000); @@ -57,7 +57,7 @@ public final class BritishImperial { public static final LinearUnit MILE = FURLONG.times(8); public static final LinearUnit LEAGUE = MILE.times(3); - public static final LinearUnit NAUTICAL_MILE = SI.METRE.times(1852); + 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); @@ -72,7 +72,7 @@ public final class BritishImperial { * @since 2019-11-08 */ public static final class Mass { - public static final LinearUnit POUND = SI.GRAM.times(453.59237); + public static final LinearUnit POUND = Metric.GRAM.times(453.59237); public static final LinearUnit OUNCE = POUND.dividedBy(16); public static final LinearUnit DRACHM = POUND.dividedBy(256); public static final LinearUnit GRAIN = POUND.dividedBy(7000); @@ -80,7 +80,7 @@ public final class BritishImperial { public static final LinearUnit QUARTER = STONE.times(2); public static final LinearUnit HUNDREDWEIGHT = QUARTER.times(4); public static final LinearUnit LONG_TON = HUNDREDWEIGHT.times(20); - public static final LinearUnit SLUG = SI.KILOGRAM.times(14.59390294); + public static final LinearUnit SLUG = Metric.KILOGRAM.times(14.59390294); } /** @@ -90,7 +90,7 @@ public final class BritishImperial { * @since 2019-11-08 */ public static final class Volume { - public static final LinearUnit FLUID_OUNCE = SI.LITRE.withPrefix(SI.MILLI).times(28.4130625); + public static final LinearUnit FLUID_OUNCE = Metric.LITRE.withPrefix(Metric.MILLI).times(28.4130625); public static final LinearUnit GILL = FLUID_OUNCE.times(5); public static final LinearUnit PINT = FLUID_OUNCE.times(20); public static final LinearUnit QUART = PINT.times(2); @@ -104,13 +104,13 @@ public final class BritishImperial { public static final LinearUnit ACRE_FOOT = Area.ACRE.times(Length.FOOT); } - public static final LinearUnit OUNCE_FORCE = Mass.OUNCE.times(SI.Constants.EARTH_GRAVITY); - public static final LinearUnit POUND_FORCE = Mass.POUND.times(SI.Constants.EARTH_GRAVITY); + public static final LinearUnit OUNCE_FORCE = Mass.OUNCE.times(Metric.Constants.EARTH_GRAVITY); + public static final LinearUnit POUND_FORCE = Mass.POUND.times(Metric.Constants.EARTH_GRAVITY); - public static final LinearUnit BRITISH_THERMAL_UNIT = SI.JOULE.times(1055.06); - public static final LinearUnit CALORIE = SI.JOULE.times(4.184); - public static final LinearUnit KILOCALORIE = SI.JOULE.times(4184); + public static final LinearUnit BRITISH_THERMAL_UNIT = Metric.JOULE.times(1055.06); + public static final LinearUnit CALORIE = Metric.JOULE.times(4.184); + public static final LinearUnit KILOCALORIE = Metric.JOULE.times(4184); - public static final Unit FAHRENHEIT = Unit.fromConversionFunctions(SI.KELVIN.getBase(), + public static final Unit FAHRENHEIT = Unit.fromConversionFunctions(Metric.KELVIN.getBase(), tempK -> tempK * 1.8 - 459.67, tempF -> (tempF + 459.67) / 1.8); } diff --git a/src/main/java/sevenUnits/unit/LinearUnitValue.java b/src/main/java/sevenUnits/unit/LinearUnitValue.java index ffb9271..a36d568 100644 --- a/src/main/java/sevenUnits/unit/LinearUnitValue.java +++ b/src/main/java/sevenUnits/unit/LinearUnitValue.java @@ -32,7 +32,7 @@ import sevenUnits.utils.UncertainDouble; * @since 2020-07-26 */ public final class LinearUnitValue { - public static final LinearUnitValue ONE = getExact(SI.ONE, 1); + public static final LinearUnitValue ONE = getExact(Metric.ONE, 1); /** * Gets an exact {@code LinearUnitValue} diff --git a/src/main/java/sevenUnits/unit/Metric.java b/src/main/java/sevenUnits/unit/Metric.java new file mode 100644 index 0000000..3c4d291 --- /dev/null +++ b/src/main/java/sevenUnits/unit/Metric.java @@ -0,0 +1,479 @@ +/** + * Copyright (C) 2018 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 . + */ +package sevenUnits.unit; + +import java.util.Set; + +import sevenUnits.utils.ObjectProduct; + +/** + * All of the units, prefixes and dimensions that are used by the SI, as well as + * some outside the SI. + * + *

+ * This class does not include prefixed units. To obtain prefixed units, use + * {@link LinearUnit#withPrefix}: + * + * 

+ * LinearUnit KILOMETRE = SI.METRE.withPrefix(SI.KILO);
+ *
+ * + * + * @author Adrien Hopkins + * @since 2019-10-16 + */ +public final class Metric { + /// dimensions used by SI units + // base dimensions, as BaseDimensions + public static final class BaseDimensions { + public static final BaseDimension LENGTH = BaseDimension.valueOf("Length", + "L"); + public static final BaseDimension MASS = BaseDimension.valueOf("Mass", + "M"); + public static final BaseDimension TIME = BaseDimension.valueOf("Time", + "T"); + public static final BaseDimension ELECTRIC_CURRENT = BaseDimension + .valueOf("Electric Current", "I"); + public static final BaseDimension TEMPERATURE = BaseDimension + .valueOf("Temperature", "\u0398"); // theta symbol + public static final BaseDimension QUANTITY = BaseDimension + .valueOf("Quantity", "N"); + public static final BaseDimension LUMINOUS_INTENSITY = BaseDimension + .valueOf("Luminous Intensity", "J"); + public static final BaseDimension INFORMATION = BaseDimension + .valueOf("Information", "Info"); // non-SI + public static final BaseDimension CURRENCY = BaseDimension + .valueOf("Currency", "$$"); // non-SI + + // You may NOT get SI.BaseDimensions instances! + private BaseDimensions() { + throw new AssertionError(); + } + } + + /// base units of the SI + // suppressing warnings since these are the same object, but in a different + /// form (class) + @SuppressWarnings("hiding") + public static final class BaseUnits { + public static final BaseUnit METRE = BaseUnit + .valueOf(BaseDimensions.LENGTH, "metre", "m"); + public static final BaseUnit KILOGRAM = BaseUnit + .valueOf(BaseDimensions.MASS, "kilogram", "kg"); + public static final BaseUnit SECOND = BaseUnit + .valueOf(BaseDimensions.TIME, "second", "s"); + public static final BaseUnit AMPERE = BaseUnit + .valueOf(BaseDimensions.ELECTRIC_CURRENT, "ampere", "A"); + public static final BaseUnit KELVIN = BaseUnit + .valueOf(BaseDimensions.TEMPERATURE, "kelvin", "K"); + public static final BaseUnit MOLE = BaseUnit + .valueOf(BaseDimensions.QUANTITY, "mole", "mol"); + public static final BaseUnit CANDELA = BaseUnit + .valueOf(BaseDimensions.LUMINOUS_INTENSITY, "candela", "cd"); + public static final BaseUnit BIT = BaseUnit + .valueOf(BaseDimensions.INFORMATION, "bit", "b"); + public static final BaseUnit DOLLAR = BaseUnit + .valueOf(BaseDimensions.CURRENCY, "dollar", "$"); + + public static final Set BASE_UNITS = Set.of(METRE, KILOGRAM, + SECOND, AMPERE, KELVIN, MOLE, CANDELA, BIT); + + // You may NOT get SI.BaseUnits instances! + private BaseUnits() { + throw new AssertionError(); + } + } + + /** + * Constants that relate to the SI or other systems. + * + * @author Adrien Hopkins + * @since 2019-11-08 + */ + public static final class Constants { + public static final LinearUnit EARTH_GRAVITY = METRE.dividedBy(SECOND) + .dividedBy(SECOND).times(9.80665); + } + + // dimensions used in the SI, as ObjectProducts + public static final class Dimensions { + public static final ObjectProduct EMPTY = ObjectProduct + .empty(); + public static final ObjectProduct LENGTH = ObjectProduct + .oneOf(BaseDimensions.LENGTH); + public static final ObjectProduct MASS = ObjectProduct + .oneOf(BaseDimensions.MASS); + public static final ObjectProduct TIME = ObjectProduct + .oneOf(BaseDimensions.TIME); + public static final ObjectProduct ELECTRIC_CURRENT = ObjectProduct + .oneOf(BaseDimensions.ELECTRIC_CURRENT); + public static final ObjectProduct TEMPERATURE = ObjectProduct + .oneOf(BaseDimensions.TEMPERATURE); + public static final ObjectProduct QUANTITY = ObjectProduct + .oneOf(BaseDimensions.QUANTITY); + public static final ObjectProduct LUMINOUS_INTENSITY = ObjectProduct + .oneOf(BaseDimensions.LUMINOUS_INTENSITY); + public static final ObjectProduct INFORMATION = ObjectProduct + .oneOf(BaseDimensions.INFORMATION); + public static final ObjectProduct CURRENCY = ObjectProduct + .oneOf(BaseDimensions.CURRENCY); + + // derived dimensions without named SI units + public static final ObjectProduct AREA = LENGTH + .times(LENGTH); + public static final ObjectProduct VOLUME = AREA + .times(LENGTH); + public static final ObjectProduct VELOCITY = LENGTH + .dividedBy(TIME); + public static final ObjectProduct ACCELERATION = VELOCITY + .dividedBy(TIME); + public static final ObjectProduct WAVENUMBER = EMPTY + .dividedBy(LENGTH); + public static final ObjectProduct MASS_DENSITY = MASS + .dividedBy(VOLUME); + public static final ObjectProduct SURFACE_DENSITY = MASS + .dividedBy(AREA); + public static final ObjectProduct SPECIFIC_VOLUME = VOLUME + .dividedBy(MASS); + public static final ObjectProduct CURRENT_DENSITY = ELECTRIC_CURRENT + .dividedBy(AREA); + public static final ObjectProduct MAGNETIC_FIELD_STRENGTH = ELECTRIC_CURRENT + .dividedBy(LENGTH); + public static final ObjectProduct CONCENTRATION = QUANTITY + .dividedBy(VOLUME); + public static final ObjectProduct MASS_CONCENTRATION = CONCENTRATION + .times(MASS); + public static final ObjectProduct LUMINANCE = LUMINOUS_INTENSITY + .dividedBy(AREA); + public static final ObjectProduct REFRACTIVE_INDEX = VELOCITY + .dividedBy(VELOCITY); + public static final ObjectProduct REFRACTIVE_PERMEABILITY = EMPTY + .times(EMPTY); + public static final ObjectProduct ANGLE = LENGTH + .dividedBy(LENGTH); + public static final ObjectProduct SOLID_ANGLE = AREA + .dividedBy(AREA); + + // derived dimensions with named SI units + public static final ObjectProduct FREQUENCY = EMPTY + .dividedBy(TIME); + public static final ObjectProduct FORCE = MASS + .times(ACCELERATION); + public static final ObjectProduct ENERGY = FORCE + .times(LENGTH); + public static final ObjectProduct POWER = ENERGY + .dividedBy(TIME); + public static final ObjectProduct ELECTRIC_CHARGE = ELECTRIC_CURRENT + .times(TIME); + public static final ObjectProduct VOLTAGE = ENERGY + .dividedBy(ELECTRIC_CHARGE); + public static final ObjectProduct CAPACITANCE = ELECTRIC_CHARGE + .dividedBy(VOLTAGE); + public static final ObjectProduct ELECTRIC_RESISTANCE = VOLTAGE + .dividedBy(ELECTRIC_CURRENT); + public static final ObjectProduct ELECTRIC_CONDUCTANCE = ELECTRIC_CURRENT + .dividedBy(VOLTAGE); + public static final ObjectProduct MAGNETIC_FLUX = VOLTAGE + .times(TIME); + public static final ObjectProduct MAGNETIC_FLUX_DENSITY = MAGNETIC_FLUX + .dividedBy(AREA); + public static final ObjectProduct INDUCTANCE = MAGNETIC_FLUX + .dividedBy(ELECTRIC_CURRENT); + public static final ObjectProduct LUMINOUS_FLUX = LUMINOUS_INTENSITY + .times(SOLID_ANGLE); + public static final ObjectProduct ILLUMINANCE = LUMINOUS_FLUX + .dividedBy(AREA); + public static final ObjectProduct SPECIFIC_ENERGY = ENERGY + .dividedBy(MASS); + public static final ObjectProduct CATALYTIC_ACTIVITY = QUANTITY + .dividedBy(TIME); + + // You may NOT get SI.Dimension instances! + private Dimensions() { + throw new AssertionError(); + } + } + + /// The units of the SI + public static final LinearUnit ONE = LinearUnit + .valueOf(ObjectProduct.empty(), 1); + + public static final LinearUnit METRE = BaseUnits.METRE.asLinearUnit() + .withName(NameSymbol.of("metre", "m", "meter")); + public static final LinearUnit KILOGRAM = BaseUnits.KILOGRAM.asLinearUnit() + .withName(NameSymbol.of("kilogram", "kg")); + public static final LinearUnit SECOND = BaseUnits.SECOND.asLinearUnit() + .withName(NameSymbol.of("second", "s", "sec")); + public static final LinearUnit AMPERE = BaseUnits.AMPERE.asLinearUnit() + .withName(NameSymbol.of("ampere", "A")); + public static final LinearUnit KELVIN = BaseUnits.KELVIN.asLinearUnit() + .withName(NameSymbol.of("kelvin", "K")); + public static final LinearUnit MOLE = BaseUnits.MOLE.asLinearUnit() + .withName(NameSymbol.of("mole", "mol")); + public static final LinearUnit CANDELA = BaseUnits.CANDELA.asLinearUnit() + .withName(NameSymbol.of("candela", "cd")); + public static final LinearUnit BIT = BaseUnits.BIT.asLinearUnit() + .withName(NameSymbol.of("bit", "b")); + public static final LinearUnit DOLLAR = BaseUnits.DOLLAR.asLinearUnit() + .withName(NameSymbol.of("dollar", "$")); + // Non-base units + public static final LinearUnit RADIAN = METRE.dividedBy(METRE) + .withName(NameSymbol.of("radian", "rad")); + + public static final LinearUnit STERADIAN = RADIAN.times(RADIAN) + .withName(NameSymbol.of("steradian", "sr")); + public static final LinearUnit HERTZ = ONE.dividedBy(SECOND) + .withName(NameSymbol.of("hertz", "Hz")); + // for periodic phenomena + public static final LinearUnit NEWTON = KILOGRAM.times(METRE) + .dividedBy(SECOND.times(SECOND)) + .withName(NameSymbol.of("newton", "N")); + public static final LinearUnit PASCAL = NEWTON.dividedBy(METRE.times(METRE)) + .withName(NameSymbol.of("pascal", "Pa")); + public static final LinearUnit JOULE = NEWTON.times(METRE) + .withName(NameSymbol.of("joule", "J")); + public static final LinearUnit WATT = JOULE.dividedBy(SECOND) + .withName(NameSymbol.of("watt", "W")); + public static final LinearUnit COULOMB = AMPERE.times(SECOND) + .withName(NameSymbol.of("coulomb", "C")); + public static final LinearUnit VOLT = JOULE.dividedBy(COULOMB) + .withName(NameSymbol.of("volt", "V")); + public static final LinearUnit FARAD = COULOMB.dividedBy(VOLT) + .withName(NameSymbol.of("farad", "F")); + public static final LinearUnit OHM = VOLT.dividedBy(AMPERE) + .withName(NameSymbol.of("ohm", "\u03A9")); // omega + public static final LinearUnit SIEMENS = ONE.dividedBy(OHM) + .withName(NameSymbol.of("siemens", "S")); + public static final LinearUnit WEBER = VOLT.times(SECOND) + .withName(NameSymbol.of("weber", "Wb")); + public static final LinearUnit TESLA = WEBER.dividedBy(METRE.times(METRE)) + .withName(NameSymbol.of("tesla", "T")); + public static final LinearUnit HENRY = WEBER.dividedBy(AMPERE) + .withName(NameSymbol.of("henry", "H")); + public static final LinearUnit LUMEN = CANDELA.times(STERADIAN) + .withName(NameSymbol.of("lumen", "lm")); + public static final LinearUnit LUX = LUMEN.dividedBy(METRE.times(METRE)) + .withName(NameSymbol.of("lux", "lx")); + public static final LinearUnit BEQUEREL = ONE.dividedBy(SECOND) + .withName(NameSymbol.of("bequerel", "Bq")); + // for activity referred to a nucleotide + public static final LinearUnit GRAY = JOULE.dividedBy(KILOGRAM) + .withName(NameSymbol.of("grey", "Gy")); + // for absorbed dose + public static final LinearUnit SIEVERT = JOULE.dividedBy(KILOGRAM) + .withName(NameSymbol.of("sievert", "Sv")); + // for dose equivalent + public static final LinearUnit KATAL = MOLE.dividedBy(SECOND) + .withName(NameSymbol.of("katal", "kat")); + // common derived units included for convenience + public static final LinearUnit GRAM = KILOGRAM.dividedBy(1000) + .withName(NameSymbol.of("gram", "g")); + + public static final LinearUnit SQUARE_METRE = METRE.toExponent(2) + .withName(NameSymbol.of("square metre", "m^2", "square meter", + "metre squared", "meter squared")); + public static final LinearUnit CUBIC_METRE = METRE.toExponent(3) + .withName(NameSymbol.of("cubic metre", "m^3", "cubic meter", + "metre cubed", "meter cubed")); + public static final LinearUnit METRE_PER_SECOND = METRE.dividedBy(SECOND) + .withName( + NameSymbol.of("metre per second", "m/s", "meter per second")); + // Non-SI units included for convenience + public static final Unit CELSIUS = Unit + .fromConversionFunctions(KELVIN.getBase(), tempK -> tempK - 273.15, + tempC -> tempC + 273.15) + .withName(NameSymbol.of("degree Celsius", "\u00B0C")); + + public static final LinearUnit MINUTE = SECOND.times(60) + .withName(NameSymbol.of("minute", "min")); + public static final LinearUnit HOUR = MINUTE.times(60) + .withName(NameSymbol.of("hour", "h", "hr")); + public static final LinearUnit DAY = HOUR.times(60) + .withName(NameSymbol.of("day", "d")); + public static final LinearUnit KILOMETRE_PER_HOUR = METRE.times(1000) + .dividedBy(HOUR).withName(NameSymbol.of("kilometre per hour", "km/h", + "kilometer per hour")); + public static final LinearUnit DEGREE = RADIAN.times(360 / (2 * Math.PI)) + .withName(NameSymbol.of("degree", "\u00B0", "deg")); + public static final LinearUnit ARCMINUTE = DEGREE.dividedBy(60) + .withName(NameSymbol.of("arcminute", "arcmin")); + public static final LinearUnit ARCSECOND = ARCMINUTE.dividedBy(60) + .withName(NameSymbol.of("arcsecond", "arcsec")); + public static final LinearUnit ASTRONOMICAL_UNIT = METRE + .times(149597870700.0) + .withName(NameSymbol.of("astronomical unit", "au")); + public static final LinearUnit PARSEC = ASTRONOMICAL_UNIT + .dividedBy(ARCSECOND).withName(NameSymbol.of("parsec", "pc")); + public static final LinearUnit HECTARE = METRE.times(METRE).times(10000.0) + .withName(NameSymbol.of("hectare", "ha")); + public static final LinearUnit LITRE = METRE.times(METRE).times(METRE) + .dividedBy(1000.0).withName(NameSymbol.of("litre", "L", "l", "liter")); + public static final LinearUnit TONNE = KILOGRAM.times(1000.0) + .withName(NameSymbol.of("tonne", "t", "metric ton")); + public static final LinearUnit DALTON = KILOGRAM.times(1.660539040e-27) + .withName(NameSymbol.of("dalton", "Da", "atomic unit", "u")); // approximate + // value + public static final LinearUnit ELECTRONVOLT = JOULE.times(1.602176634e-19) + .withName(NameSymbol.of("electron volt", "eV")); + public static final LinearUnit BYTE = BIT.times(8) + .withName(NameSymbol.of("byte", "B")); + public static final Unit NEPER = Unit.fromConversionFunctions(ONE.getBase(), + 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)) + .withName(NameSymbol.of("bel", "B")); + public static final Unit DECIBEL = Unit + .fromConversionFunctions(ONE.getBase(), pr -> 10 * Math.log10(pr), + dB -> Math.pow(10, dB / 10)) + .withName(NameSymbol.of("decibel", "dB")); + + /// The prefixes of the SI + // expanding decimal prefixes + public static final UnitPrefix KILO = UnitPrefix.valueOf(1e3) + .withName(NameSymbol.of("kilo", "k", "K")); + public static final UnitPrefix MEGA = UnitPrefix.valueOf(1e6) + .withName(NameSymbol.of("mega", "M")); + public static final UnitPrefix GIGA = UnitPrefix.valueOf(1e9) + .withName(NameSymbol.of("giga", "G")); + public static final UnitPrefix TERA = UnitPrefix.valueOf(1e12) + .withName(NameSymbol.of("tera", "T")); + public static final UnitPrefix PETA = UnitPrefix.valueOf(1e15) + .withName(NameSymbol.of("peta", "P")); + public static final UnitPrefix EXA = UnitPrefix.valueOf(1e18) + .withName(NameSymbol.of("exa", "E")); + public static final UnitPrefix ZETTA = UnitPrefix.valueOf(1e21) + .withName(NameSymbol.of("zetta", "Z")); + public static final UnitPrefix YOTTA = UnitPrefix.valueOf(1e24) + .withName(NameSymbol.of("yotta", "Y")); + + // contracting decimal prefixes + public static final UnitPrefix MILLI = UnitPrefix.valueOf(1e-3) + .withName(NameSymbol.of("milli", "m")); + public static final UnitPrefix MICRO = UnitPrefix.valueOf(1e-6) + .withName(NameSymbol.of("micro", "\u03BC", "u")); // mu + public static final UnitPrefix NANO = UnitPrefix.valueOf(1e-9) + .withName(NameSymbol.of("nano", "n")); + public static final UnitPrefix PICO = UnitPrefix.valueOf(1e-12) + .withName(NameSymbol.of("pico", "p")); + public static final UnitPrefix FEMTO = UnitPrefix.valueOf(1e-15) + .withName(NameSymbol.of("femto", "f")); + public static final UnitPrefix ATTO = UnitPrefix.valueOf(1e-18) + .withName(NameSymbol.of("atto", "a")); + public static final UnitPrefix ZEPTO = UnitPrefix.valueOf(1e-21) + .withName(NameSymbol.of("zepto", "z")); + public static final UnitPrefix YOCTO = UnitPrefix.valueOf(1e-24) + .withName(NameSymbol.of("yocto", "y")); + + // prefixes that don't match the pattern of thousands + public static final UnitPrefix DEKA = UnitPrefix.valueOf(1e1) + .withName(NameSymbol.of("deka", "da", "deca", "D")); + public static final UnitPrefix HECTO = UnitPrefix.valueOf(1e2) + .withName(NameSymbol.of("hecto", "h", "H", "hekto")); + public static final UnitPrefix DECI = UnitPrefix.valueOf(1e-1) + .withName(NameSymbol.of("deci", "d")); + public static final UnitPrefix CENTI = UnitPrefix.valueOf(1e-2) + .withName(NameSymbol.of("centi", "c")); + public static final UnitPrefix KIBI = UnitPrefix.valueOf(1024) + .withName(NameSymbol.of("kibi", "Ki")); + public static final UnitPrefix MEBI = KIBI.times(1024) + .withName(NameSymbol.of("mebi", "Mi")); + public static final UnitPrefix GIBI = MEBI.times(1024) + .withName(NameSymbol.of("gibi", "Gi")); + public static final UnitPrefix TEBI = GIBI.times(1024) + .withName(NameSymbol.of("tebi", "Ti")); + public static final UnitPrefix PEBI = TEBI.times(1024) + .withName(NameSymbol.of("pebi", "Pi")); + public static final UnitPrefix EXBI = PEBI.times(1024) + .withName(NameSymbol.of("exbi", "Ei")); + + // a few prefixed units + public static final LinearUnit MICROMETRE = Metric.METRE.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIMETRE = Metric.METRE.withPrefix(Metric.MILLI); + public static final LinearUnit KILOMETRE = Metric.METRE.withPrefix(Metric.KILO); + public static final LinearUnit MEGAMETRE = Metric.METRE.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROLITRE = Metric.LITRE.withPrefix(Metric.MICRO); + public static final LinearUnit MILLILITRE = Metric.LITRE.withPrefix(Metric.MILLI); + public static final LinearUnit KILOLITRE = Metric.LITRE.withPrefix(Metric.KILO); + public static final LinearUnit MEGALITRE = Metric.LITRE.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROSECOND = Metric.SECOND.withPrefix(Metric.MICRO); + public static final LinearUnit MILLISECOND = Metric.SECOND.withPrefix(Metric.MILLI); + public static final LinearUnit KILOSECOND = Metric.SECOND.withPrefix(Metric.KILO); + public static final LinearUnit MEGASECOND = Metric.SECOND.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROGRAM = Metric.GRAM.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIGRAM = Metric.GRAM.withPrefix(Metric.MILLI); + public static final LinearUnit MEGAGRAM = Metric.GRAM.withPrefix(Metric.MEGA); + + public static final LinearUnit MICRONEWTON = Metric.NEWTON.withPrefix(Metric.MICRO); + public static final LinearUnit MILLINEWTON = Metric.NEWTON.withPrefix(Metric.MILLI); + public static final LinearUnit KILONEWTON = Metric.NEWTON.withPrefix(Metric.KILO); + public static final LinearUnit MEGANEWTON = Metric.NEWTON.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROJOULE = Metric.JOULE.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIJOULE = Metric.JOULE.withPrefix(Metric.MILLI); + public static final LinearUnit KILOJOULE = Metric.JOULE.withPrefix(Metric.KILO); + public static final LinearUnit MEGAJOULE = Metric.JOULE.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROWATT = Metric.WATT.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIWATT = Metric.WATT.withPrefix(Metric.MILLI); + public static final LinearUnit KILOWATT = Metric.WATT.withPrefix(Metric.KILO); + public static final LinearUnit MEGAWATT = Metric.WATT.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROCOULOMB = Metric.COULOMB + .withPrefix(Metric.MICRO); + public static final LinearUnit MILLICOULOMB = Metric.COULOMB + .withPrefix(Metric.MILLI); + public static final LinearUnit KILOCOULOMB = Metric.COULOMB.withPrefix(Metric.KILO); + public static final LinearUnit MEGACOULOMB = Metric.COULOMB.withPrefix(Metric.MEGA); + + public static final LinearUnit MICROAMPERE = Metric.AMPERE.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIAMPERE = Metric.AMPERE.withPrefix(Metric.MILLI); + + public static final LinearUnit MICROVOLT = Metric.VOLT.withPrefix(Metric.MICRO); + public static final LinearUnit MILLIVOLT = Metric.VOLT.withPrefix(Metric.MILLI); + public static final LinearUnit KILOVOLT = Metric.VOLT.withPrefix(Metric.KILO); + public static final LinearUnit MEGAVOLT = Metric.VOLT.withPrefix(Metric.MEGA); + + public static final LinearUnit KILOOHM = Metric.OHM.withPrefix(Metric.KILO); + public static final LinearUnit MEGAOHM = Metric.OHM.withPrefix(Metric.MEGA); + + // sets of prefixes + public static final Set ALL_PREFIXES = Set.of(DEKA, HECTO, KILO, + MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI, MICRO, + NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO, KIBI, MEBI, GIBI, TEBI, PEBI, + EXBI); + + public static final Set DECIMAL_PREFIXES = Set.of(DEKA, HECTO, + KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI, + MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO); + public static final Set THOUSAND_PREFIXES = Set.of(KILO, MEGA, + GIGA, TERA, PETA, EXA, ZETTA, YOTTA, MILLI, MICRO, NANO, PICO, FEMTO, + ATTO, ZEPTO, YOCTO); + public static final Set MAGNIFYING_PREFIXES = Set.of(DEKA, HECTO, + KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, KIBI, MEBI, GIBI, + TEBI, PEBI, EXBI); + public static final Set REDUCING_PREFIXES = Set.of(DECI, CENTI, + MILLI, MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO); + + // You may NOT get SI instances! + private Metric() { + throw new AssertionError(); + } +} diff --git a/src/main/java/sevenUnits/unit/SI.java b/src/main/java/sevenUnits/unit/SI.java deleted file mode 100644 index 278fb5e..0000000 --- a/src/main/java/sevenUnits/unit/SI.java +++ /dev/null @@ -1,479 +0,0 @@ -/** - * Copyright (C) 2018 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 . - */ -package sevenUnits.unit; - -import java.util.Set; - -import sevenUnits.utils.ObjectProduct; - -/** - * All of the units, prefixes and dimensions that are used by the SI, as well as - * some outside the SI. - * - *

- * This class does not include prefixed units. To obtain prefixed units, use - * {@link LinearUnit#withPrefix}: - * - * 

- * LinearUnit KILOMETRE = SI.METRE.withPrefix(SI.KILO);
- *
- * - * - * @author Adrien Hopkins - * @since 2019-10-16 - */ -public final class SI { - /// dimensions used by SI units - // base dimensions, as BaseDimensions - public static final class BaseDimensions { - public static final BaseDimension LENGTH = BaseDimension.valueOf("Length", - "L"); - public static final BaseDimension MASS = BaseDimension.valueOf("Mass", - "M"); - public static final BaseDimension TIME = BaseDimension.valueOf("Time", - "T"); - public static final BaseDimension ELECTRIC_CURRENT = BaseDimension - .valueOf("Electric Current", "I"); - public static final BaseDimension TEMPERATURE = BaseDimension - .valueOf("Temperature", "\u0398"); // theta symbol - public static final BaseDimension QUANTITY = BaseDimension - .valueOf("Quantity", "N"); - public static final BaseDimension LUMINOUS_INTENSITY = BaseDimension - .valueOf("Luminous Intensity", "J"); - public static final BaseDimension INFORMATION = BaseDimension - .valueOf("Information", "Info"); // non-SI - public static final BaseDimension CURRENCY = BaseDimension - .valueOf("Currency", "$$"); // non-SI - - // You may NOT get SI.BaseDimensions instances! - private BaseDimensions() { - throw new AssertionError(); - } - } - - /// base units of the SI - // suppressing warnings since these are the same object, but in a different - /// form (class) - @SuppressWarnings("hiding") - public static final class BaseUnits { - public static final BaseUnit METRE = BaseUnit - .valueOf(BaseDimensions.LENGTH, "metre", "m"); - public static final BaseUnit KILOGRAM = BaseUnit - .valueOf(BaseDimensions.MASS, "kilogram", "kg"); - public static final BaseUnit SECOND = BaseUnit - .valueOf(BaseDimensions.TIME, "second", "s"); - public static final BaseUnit AMPERE = BaseUnit - .valueOf(BaseDimensions.ELECTRIC_CURRENT, "ampere", "A"); - public static final BaseUnit KELVIN = BaseUnit - .valueOf(BaseDimensions.TEMPERATURE, "kelvin", "K"); - public static final BaseUnit MOLE = BaseUnit - .valueOf(BaseDimensions.QUANTITY, "mole", "mol"); - public static final BaseUnit CANDELA = BaseUnit - .valueOf(BaseDimensions.LUMINOUS_INTENSITY, "candela", "cd"); - public static final BaseUnit BIT = BaseUnit - .valueOf(BaseDimensions.INFORMATION, "bit", "b"); - public static final BaseUnit DOLLAR = BaseUnit - .valueOf(BaseDimensions.CURRENCY, "dollar", "$"); - - public static final Set BASE_UNITS = Set.of(METRE, KILOGRAM, - SECOND, AMPERE, KELVIN, MOLE, CANDELA, BIT); - - // You may NOT get SI.BaseUnits instances! - private BaseUnits() { - throw new AssertionError(); - } - } - - /** - * Constants that relate to the SI or other systems. - * - * @author Adrien Hopkins - * @since 2019-11-08 - */ - public static final class Constants { - public static final LinearUnit EARTH_GRAVITY = METRE.dividedBy(SECOND) - .dividedBy(SECOND).times(9.80665); - } - - // dimensions used in the SI, as ObjectProducts - public static final class Dimensions { - public static final ObjectProduct EMPTY = ObjectProduct - .empty(); - public static final ObjectProduct LENGTH = ObjectProduct - .oneOf(BaseDimensions.LENGTH); - public static final ObjectProduct MASS = ObjectProduct - .oneOf(BaseDimensions.MASS); - public static final ObjectProduct TIME = ObjectProduct - .oneOf(BaseDimensions.TIME); - public static final ObjectProduct ELECTRIC_CURRENT = ObjectProduct - .oneOf(BaseDimensions.ELECTRIC_CURRENT); - public static final ObjectProduct TEMPERATURE = ObjectProduct - .oneOf(BaseDimensions.TEMPERATURE); - public static final ObjectProduct QUANTITY = ObjectProduct - .oneOf(BaseDimensions.QUANTITY); - public static final ObjectProduct LUMINOUS_INTENSITY = ObjectProduct - .oneOf(BaseDimensions.LUMINOUS_INTENSITY); - public static final ObjectProduct INFORMATION = ObjectProduct - .oneOf(BaseDimensions.INFORMATION); - public static final ObjectProduct CURRENCY = ObjectProduct - .oneOf(BaseDimensions.CURRENCY); - - // derived dimensions without named SI units - public static final ObjectProduct AREA = LENGTH - .times(LENGTH); - public static final ObjectProduct VOLUME = AREA - .times(LENGTH); - public static final ObjectProduct VELOCITY = LENGTH - .dividedBy(TIME); - public static final ObjectProduct ACCELERATION = VELOCITY - .dividedBy(TIME); - public static final ObjectProduct WAVENUMBER = EMPTY - .dividedBy(LENGTH); - public static final ObjectProduct MASS_DENSITY = MASS - .dividedBy(VOLUME); - public static final ObjectProduct SURFACE_DENSITY = MASS - .dividedBy(AREA); - public static final ObjectProduct SPECIFIC_VOLUME = VOLUME - .dividedBy(MASS); - public static final ObjectProduct CURRENT_DENSITY = ELECTRIC_CURRENT - .dividedBy(AREA); - public static final ObjectProduct MAGNETIC_FIELD_STRENGTH = ELECTRIC_CURRENT - .dividedBy(LENGTH); - public static final ObjectProduct CONCENTRATION = QUANTITY - .dividedBy(VOLUME); - public static final ObjectProduct MASS_CONCENTRATION = CONCENTRATION - .times(MASS); - public static final ObjectProduct LUMINANCE = LUMINOUS_INTENSITY - .dividedBy(AREA); - public static final ObjectProduct REFRACTIVE_INDEX = VELOCITY - .dividedBy(VELOCITY); - public static final ObjectProduct REFRACTIVE_PERMEABILITY = EMPTY - .times(EMPTY); - public static final ObjectProduct ANGLE = LENGTH - .dividedBy(LENGTH); - public static final ObjectProduct SOLID_ANGLE = AREA - .dividedBy(AREA); - - // derived dimensions with named SI units - public static final ObjectProduct FREQUENCY = EMPTY - .dividedBy(TIME); - public static final ObjectProduct FORCE = MASS - .times(ACCELERATION); - public static final ObjectProduct ENERGY = FORCE - .times(LENGTH); - public static final ObjectProduct POWER = ENERGY - .dividedBy(TIME); - public static final ObjectProduct ELECTRIC_CHARGE = ELECTRIC_CURRENT - .times(TIME); - public static final ObjectProduct VOLTAGE = ENERGY - .dividedBy(ELECTRIC_CHARGE); - public static final ObjectProduct CAPACITANCE = ELECTRIC_CHARGE - .dividedBy(VOLTAGE); - public static final ObjectProduct ELECTRIC_RESISTANCE = VOLTAGE - .dividedBy(ELECTRIC_CURRENT); - public static final ObjectProduct ELECTRIC_CONDUCTANCE = ELECTRIC_CURRENT - .dividedBy(VOLTAGE); - public static final ObjectProduct MAGNETIC_FLUX = VOLTAGE - .times(TIME); - public static final ObjectProduct MAGNETIC_FLUX_DENSITY = MAGNETIC_FLUX - .dividedBy(AREA); - public static final ObjectProduct INDUCTANCE = MAGNETIC_FLUX - .dividedBy(ELECTRIC_CURRENT); - public static final ObjectProduct LUMINOUS_FLUX = LUMINOUS_INTENSITY - .times(SOLID_ANGLE); - public static final ObjectProduct ILLUMINANCE = LUMINOUS_FLUX - .dividedBy(AREA); - public static final ObjectProduct SPECIFIC_ENERGY = ENERGY - .dividedBy(MASS); - public static final ObjectProduct CATALYTIC_ACTIVITY = QUANTITY - .dividedBy(TIME); - - // You may NOT get SI.Dimension instances! - private Dimensions() { - throw new AssertionError(); - } - } - - /// The units of the SI - public static final LinearUnit ONE = LinearUnit - .valueOf(ObjectProduct.empty(), 1); - - public static final LinearUnit METRE = BaseUnits.METRE.asLinearUnit() - .withName(NameSymbol.of("metre", "m", "meter")); - public static final LinearUnit KILOGRAM = BaseUnits.KILOGRAM.asLinearUnit() - .withName(NameSymbol.of("kilogram", "kg")); - public static final LinearUnit SECOND = BaseUnits.SECOND.asLinearUnit() - .withName(NameSymbol.of("second", "s", "sec")); - public static final LinearUnit AMPERE = BaseUnits.AMPERE.asLinearUnit() - .withName(NameSymbol.of("ampere", "A")); - public static final LinearUnit KELVIN = BaseUnits.KELVIN.asLinearUnit() - .withName(NameSymbol.of("kelvin", "K")); - public static final LinearUnit MOLE = BaseUnits.MOLE.asLinearUnit() - .withName(NameSymbol.of("mole", "mol")); - public static final LinearUnit CANDELA = BaseUnits.CANDELA.asLinearUnit() - .withName(NameSymbol.of("candela", "cd")); - public static final LinearUnit BIT = BaseUnits.BIT.asLinearUnit() - .withName(NameSymbol.of("bit", "b")); - public static final LinearUnit DOLLAR = BaseUnits.DOLLAR.asLinearUnit() - .withName(NameSymbol.of("dollar", "$")); - // Non-base units - public static final LinearUnit RADIAN = METRE.dividedBy(METRE) - .withName(NameSymbol.of("radian", "rad")); - - public static final LinearUnit STERADIAN = RADIAN.times(RADIAN) - .withName(NameSymbol.of("steradian", "sr")); - public static final LinearUnit HERTZ = ONE.dividedBy(SECOND) - .withName(NameSymbol.of("hertz", "Hz")); - // for periodic phenomena - public static final LinearUnit NEWTON = KILOGRAM.times(METRE) - .dividedBy(SECOND.times(SECOND)) - .withName(NameSymbol.of("newton", "N")); - public static final LinearUnit PASCAL = NEWTON.dividedBy(METRE.times(METRE)) - .withName(NameSymbol.of("pascal", "Pa")); - public static final LinearUnit JOULE = NEWTON.times(METRE) - .withName(NameSymbol.of("joule", "J")); - public static final LinearUnit WATT = JOULE.dividedBy(SECOND) - .withName(NameSymbol.of("watt", "W")); - public static final LinearUnit COULOMB = AMPERE.times(SECOND) - .withName(NameSymbol.of("coulomb", "C")); - public static final LinearUnit VOLT = JOULE.dividedBy(COULOMB) - .withName(NameSymbol.of("volt", "V")); - public static final LinearUnit FARAD = COULOMB.dividedBy(VOLT) - .withName(NameSymbol.of("farad", "F")); - public static final LinearUnit OHM = VOLT.dividedBy(AMPERE) - .withName(NameSymbol.of("ohm", "\u03A9")); // omega - public static final LinearUnit SIEMENS = ONE.dividedBy(OHM) - .withName(NameSymbol.of("siemens", "S")); - public static final LinearUnit WEBER = VOLT.times(SECOND) - .withName(NameSymbol.of("weber", "Wb")); - public static final LinearUnit TESLA = WEBER.dividedBy(METRE.times(METRE)) - .withName(NameSymbol.of("tesla", "T")); - public static final LinearUnit HENRY = WEBER.dividedBy(AMPERE) - .withName(NameSymbol.of("henry", "H")); - public static final LinearUnit LUMEN = CANDELA.times(STERADIAN) - .withName(NameSymbol.of("lumen", "lm")); - public static final LinearUnit LUX = LUMEN.dividedBy(METRE.times(METRE)) - .withName(NameSymbol.of("lux", "lx")); - public static final LinearUnit BEQUEREL = ONE.dividedBy(SECOND) - .withName(NameSymbol.of("bequerel", "Bq")); - // for activity referred to a nucleotide - public static final LinearUnit GRAY = JOULE.dividedBy(KILOGRAM) - .withName(NameSymbol.of("grey", "Gy")); - // for absorbed dose - public static final LinearUnit SIEVERT = JOULE.dividedBy(KILOGRAM) - .withName(NameSymbol.of("sievert", "Sv")); - // for dose equivalent - public static final LinearUnit KATAL = MOLE.dividedBy(SECOND) - .withName(NameSymbol.of("katal", "kat")); - // common derived units included for convenience - public static final LinearUnit GRAM = KILOGRAM.dividedBy(1000) - .withName(NameSymbol.of("gram", "g")); - - public static final LinearUnit SQUARE_METRE = METRE.toExponent(2) - .withName(NameSymbol.of("square metre", "m^2", "square meter", - "metre squared", "meter squared")); - public static final LinearUnit CUBIC_METRE = METRE.toExponent(3) - .withName(NameSymbol.of("cubic metre", "m^3", "cubic meter", - "metre cubed", "meter cubed")); - public static final LinearUnit METRE_PER_SECOND = METRE.dividedBy(SECOND) - .withName( - NameSymbol.of("metre per second", "m/s", "meter per second")); - // Non-SI units included for convenience - public static final Unit CELSIUS = Unit - .fromConversionFunctions(KELVIN.getBase(), tempK -> tempK - 273.15, - tempC -> tempC + 273.15) - .withName(NameSymbol.of("degree Celsius", "\u00B0C")); - - public static final LinearUnit MINUTE = SECOND.times(60) - .withName(NameSymbol.of("minute", "min")); - public static final LinearUnit HOUR = MINUTE.times(60) - .withName(NameSymbol.of("hour", "h", "hr")); - public static final LinearUnit DAY = HOUR.times(60) - .withName(NameSymbol.of("day", "d")); - public static final LinearUnit KILOMETRE_PER_HOUR = METRE.times(1000) - .dividedBy(HOUR).withName(NameSymbol.of("kilometre per hour", "km/h", - "kilometer per hour")); - public static final LinearUnit DEGREE = RADIAN.times(360 / (2 * Math.PI)) - .withName(NameSymbol.of("degree", "\u00B0", "deg")); - public static final LinearUnit ARCMINUTE = DEGREE.dividedBy(60) - .withName(NameSymbol.of("arcminute", "arcmin")); - public static final LinearUnit ARCSECOND = ARCMINUTE.dividedBy(60) - .withName(NameSymbol.of("arcsecond", "arcsec")); - public static final LinearUnit ASTRONOMICAL_UNIT = METRE - .times(149597870700.0) - .withName(NameSymbol.of("astronomical unit", "au")); - public static final LinearUnit PARSEC = ASTRONOMICAL_UNIT - .dividedBy(ARCSECOND).withName(NameSymbol.of("parsec", "pc")); - public static final LinearUnit HECTARE = METRE.times(METRE).times(10000.0) - .withName(NameSymbol.of("hectare", "ha")); - public static final LinearUnit LITRE = METRE.times(METRE).times(METRE) - .dividedBy(1000.0).withName(NameSymbol.of("litre", "L", "l", "liter")); - public static final LinearUnit TONNE = KILOGRAM.times(1000.0) - .withName(NameSymbol.of("tonne", "t", "metric ton")); - public static final LinearUnit DALTON = KILOGRAM.times(1.660539040e-27) - .withName(NameSymbol.of("dalton", "Da", "atomic unit", "u")); // approximate - // value - public static final LinearUnit ELECTRONVOLT = JOULE.times(1.602176634e-19) - .withName(NameSymbol.of("electron volt", "eV")); - public static final LinearUnit BYTE = BIT.times(8) - .withName(NameSymbol.of("byte", "B")); - public static final Unit NEPER = Unit.fromConversionFunctions(ONE.getBase(), - 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)) - .withName(NameSymbol.of("bel", "B")); - public static final Unit DECIBEL = Unit - .fromConversionFunctions(ONE.getBase(), pr -> 10 * Math.log10(pr), - dB -> Math.pow(10, dB / 10)) - .withName(NameSymbol.of("decibel", "dB")); - - /// The prefixes of the SI - // expanding decimal prefixes - public static final UnitPrefix KILO = UnitPrefix.valueOf(1e3) - .withName(NameSymbol.of("kilo", "k", "K")); - public static final UnitPrefix MEGA = UnitPrefix.valueOf(1e6) - .withName(NameSymbol.of("mega", "M")); - public static final UnitPrefix GIGA = UnitPrefix.valueOf(1e9) - .withName(NameSymbol.of("giga", "G")); - public static final UnitPrefix TERA = UnitPrefix.valueOf(1e12) - .withName(NameSymbol.of("tera", "T")); - public static final UnitPrefix PETA = UnitPrefix.valueOf(1e15) - .withName(NameSymbol.of("peta", "P")); - public static final UnitPrefix EXA = UnitPrefix.valueOf(1e18) - .withName(NameSymbol.of("exa", "E")); - public static final UnitPrefix ZETTA = UnitPrefix.valueOf(1e21) - .withName(NameSymbol.of("zetta", "Z")); - public static final UnitPrefix YOTTA = UnitPrefix.valueOf(1e24) - .withName(NameSymbol.of("yotta", "Y")); - - // contracting decimal prefixes - public static final UnitPrefix MILLI = UnitPrefix.valueOf(1e-3) - .withName(NameSymbol.of("milli", "m")); - public static final UnitPrefix MICRO = UnitPrefix.valueOf(1e-6) - .withName(NameSymbol.of("micro", "\u03BC", "u")); // mu - public static final UnitPrefix NANO = UnitPrefix.valueOf(1e-9) - .withName(NameSymbol.of("nano", "n")); - public static final UnitPrefix PICO = UnitPrefix.valueOf(1e-12) - .withName(NameSymbol.of("pico", "p")); - public static final UnitPrefix FEMTO = UnitPrefix.valueOf(1e-15) - .withName(NameSymbol.of("femto", "f")); - public static final UnitPrefix ATTO = UnitPrefix.valueOf(1e-18) - .withName(NameSymbol.of("atto", "a")); - public static final UnitPrefix ZEPTO = UnitPrefix.valueOf(1e-21) - .withName(NameSymbol.of("zepto", "z")); - public static final UnitPrefix YOCTO = UnitPrefix.valueOf(1e-24) - .withName(NameSymbol.of("yocto", "y")); - - // prefixes that don't match the pattern of thousands - public static final UnitPrefix DEKA = UnitPrefix.valueOf(1e1) - .withName(NameSymbol.of("deka", "da", "deca", "D")); - public static final UnitPrefix HECTO = UnitPrefix.valueOf(1e2) - .withName(NameSymbol.of("hecto", "h", "H", "hekto")); - public static final UnitPrefix DECI = UnitPrefix.valueOf(1e-1) - .withName(NameSymbol.of("deci", "d")); - public static final UnitPrefix CENTI = UnitPrefix.valueOf(1e-2) - .withName(NameSymbol.of("centi", "c")); - public static final UnitPrefix KIBI = UnitPrefix.valueOf(1024) - .withName(NameSymbol.of("kibi", "Ki")); - public static final UnitPrefix MEBI = KIBI.times(1024) - .withName(NameSymbol.of("mebi", "Mi")); - public static final UnitPrefix GIBI = MEBI.times(1024) - .withName(NameSymbol.of("gibi", "Gi")); - public static final UnitPrefix TEBI = GIBI.times(1024) - .withName(NameSymbol.of("tebi", "Ti")); - public static final UnitPrefix PEBI = TEBI.times(1024) - .withName(NameSymbol.of("pebi", "Pi")); - public static final UnitPrefix EXBI = PEBI.times(1024) - .withName(NameSymbol.of("exbi", "Ei")); - - // a few prefixed units - public static final LinearUnit MICROMETRE = SI.METRE.withPrefix(SI.MICRO); - public static final LinearUnit MILLIMETRE = SI.METRE.withPrefix(SI.MILLI); - public static final LinearUnit KILOMETRE = SI.METRE.withPrefix(SI.KILO); - public static final LinearUnit MEGAMETRE = SI.METRE.withPrefix(SI.MEGA); - - public static final LinearUnit MICROLITRE = SI.LITRE.withPrefix(SI.MICRO); - public static final LinearUnit MILLILITRE = SI.LITRE.withPrefix(SI.MILLI); - public static final LinearUnit KILOLITRE = SI.LITRE.withPrefix(SI.KILO); - public static final LinearUnit MEGALITRE = SI.LITRE.withPrefix(SI.MEGA); - - public static final LinearUnit MICROSECOND = SI.SECOND.withPrefix(SI.MICRO); - public static final LinearUnit MILLISECOND = SI.SECOND.withPrefix(SI.MILLI); - public static final LinearUnit KILOSECOND = SI.SECOND.withPrefix(SI.KILO); - public static final LinearUnit MEGASECOND = SI.SECOND.withPrefix(SI.MEGA); - - public static final LinearUnit MICROGRAM = SI.GRAM.withPrefix(SI.MICRO); - public static final LinearUnit MILLIGRAM = SI.GRAM.withPrefix(SI.MILLI); - public static final LinearUnit MEGAGRAM = SI.GRAM.withPrefix(SI.MEGA); - - public static final LinearUnit MICRONEWTON = SI.NEWTON.withPrefix(SI.MICRO); - public static final LinearUnit MILLINEWTON = SI.NEWTON.withPrefix(SI.MILLI); - public static final LinearUnit KILONEWTON = SI.NEWTON.withPrefix(SI.KILO); - public static final LinearUnit MEGANEWTON = SI.NEWTON.withPrefix(SI.MEGA); - - public static final LinearUnit MICROJOULE = SI.JOULE.withPrefix(SI.MICRO); - public static final LinearUnit MILLIJOULE = SI.JOULE.withPrefix(SI.MILLI); - public static final LinearUnit KILOJOULE = SI.JOULE.withPrefix(SI.KILO); - public static final LinearUnit MEGAJOULE = SI.JOULE.withPrefix(SI.MEGA); - - public static final LinearUnit MICROWATT = SI.WATT.withPrefix(SI.MICRO); - public static final LinearUnit MILLIWATT = SI.WATT.withPrefix(SI.MILLI); - public static final LinearUnit KILOWATT = SI.WATT.withPrefix(SI.KILO); - public static final LinearUnit MEGAWATT = SI.WATT.withPrefix(SI.MEGA); - - public static final LinearUnit MICROCOULOMB = SI.COULOMB - .withPrefix(SI.MICRO); - public static final LinearUnit MILLICOULOMB = SI.COULOMB - .withPrefix(SI.MILLI); - public static final LinearUnit KILOCOULOMB = SI.COULOMB.withPrefix(SI.KILO); - public static final LinearUnit MEGACOULOMB = SI.COULOMB.withPrefix(SI.MEGA); - - public static final LinearUnit MICROAMPERE = SI.AMPERE.withPrefix(SI.MICRO); - public static final LinearUnit MILLIAMPERE = SI.AMPERE.withPrefix(SI.MILLI); - - public static final LinearUnit MICROVOLT = SI.VOLT.withPrefix(SI.MICRO); - public static final LinearUnit MILLIVOLT = SI.VOLT.withPrefix(SI.MILLI); - public static final LinearUnit KILOVOLT = SI.VOLT.withPrefix(SI.KILO); - public static final LinearUnit MEGAVOLT = SI.VOLT.withPrefix(SI.MEGA); - - public static final LinearUnit KILOOHM = SI.OHM.withPrefix(SI.KILO); - public static final LinearUnit MEGAOHM = SI.OHM.withPrefix(SI.MEGA); - - // sets of prefixes - public static final Set ALL_PREFIXES = Set.of(DEKA, HECTO, KILO, - MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI, MICRO, - NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO, KIBI, MEBI, GIBI, TEBI, PEBI, - EXBI); - - public static final Set DECIMAL_PREFIXES = Set.of(DEKA, HECTO, - KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, DECI, CENTI, MILLI, - MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO); - public static final Set THOUSAND_PREFIXES = Set.of(KILO, MEGA, - GIGA, TERA, PETA, EXA, ZETTA, YOTTA, MILLI, MICRO, NANO, PICO, FEMTO, - ATTO, ZEPTO, YOCTO); - public static final Set MAGNIFYING_PREFIXES = Set.of(DEKA, HECTO, - KILO, MEGA, GIGA, TERA, PETA, EXA, ZETTA, YOTTA, KIBI, MEBI, GIBI, - TEBI, PEBI, EXBI); - public static final Set REDUCING_PREFIXES = Set.of(DECI, CENTI, - MILLI, MICRO, NANO, PICO, FEMTO, ATTO, ZEPTO, YOCTO); - - // You may NOT get SI instances! - private SI() { - throw new AssertionError(); - } -} diff --git a/src/main/java/sevenUnits/unit/USCustomary.java b/src/main/java/sevenUnits/unit/USCustomary.java index 76356c0..459071f 100644 --- a/src/main/java/sevenUnits/unit/USCustomary.java +++ b/src/main/java/sevenUnits/unit/USCustomary.java @@ -52,7 +52,7 @@ public final class USCustomary { public static final LinearUnit YARD = BritishImperial.Length.YARD; public static final LinearUnit MILE = BritishImperial.Length.MILE; - public static final LinearUnit SURVEY_FOOT = SI.METRE.times(1200.0 / 3937.0); + public static final LinearUnit SURVEY_FOOT = Metric.METRE.times(1200.0 / 3937.0); public static final LinearUnit SURVEY_LINK = SURVEY_FOOT.times(33.0 / 50.0); public static final LinearUnit SURVEY_ROD = SURVEY_FOOT.times(16.5); public static final LinearUnit SURVEY_CHAIN = SURVEY_ROD.times(4); @@ -97,7 +97,7 @@ public final class USCustomary { public static final LinearUnit CUBIC_YARD = Length.YARD.toExponent(3); public static final LinearUnit ACRE_FOOT = Area.ACRE.times(Length.FOOT); - public static final LinearUnit MINIM = SI.LITRE.withPrefix(SI.MICRO).times(61.611519921875); + public static final LinearUnit MINIM = Metric.LITRE.withPrefix(Metric.MICRO).times(61.611519921875); public static final LinearUnit FLUID_DRAM = MINIM.times(60); public static final LinearUnit TEASPOON = MINIM.times(80); public static final LinearUnit TABLESPOON = TEASPOON.times(3); @@ -112,7 +112,7 @@ public final class USCustomary { public static final LinearUnit OIL_BARREL = GALLON.times(42); public static final LinearUnit HOGSHEAD = GALLON.times(63); - public static final LinearUnit DRY_PINT = SI.LITRE.times(0.5506104713575); + public static final LinearUnit DRY_PINT = Metric.LITRE.times(0.5506104713575); public static final LinearUnit DRY_QUART = DRY_PINT.times(2); public static final LinearUnit DRY_GALLON = DRY_QUART.times(4); public static final LinearUnit PECK = DRY_GALLON.times(2); @@ -128,7 +128,7 @@ public final class USCustomary { public static final LinearUnit KILOCALORIE = BritishImperial.KILOCALORIE; public static final LinearUnit FOOT_POUND = POUND_FORCE.times(Length.FOOT); - public static final LinearUnit HORSEPOWER = Length.FOOT.times(POUND_FORCE).dividedBy(SI.MINUTE).times(33000); + public static final LinearUnit HORSEPOWER = Length.FOOT.times(POUND_FORCE).dividedBy(Metric.MINUTE).times(33000); public static final LinearUnit POUND_PER_SQUARE_INCH = POUND_FORCE.dividedBy(Length.INCH.toExponent(2)); public static final Unit FAHRENHEIT = BritishImperial.FAHRENHEIT; diff --git a/src/main/java/sevenUnits/unit/Unit.java b/src/main/java/sevenUnits/unit/Unit.java index 8fcacb8..58b4e10 100644 --- a/src/main/java/sevenUnits/unit/Unit.java +++ b/src/main/java/sevenUnits/unit/Unit.java @@ -117,7 +117,7 @@ public abstract class Unit implements Nameable { * @since 2019-10-16 * @throws NullPointerException if unitBase or ns is null */ - Unit(ObjectProduct unitBase, NameSymbol ns) { + protected Unit(ObjectProduct unitBase, NameSymbol ns) { this.unitBase = Objects.requireNonNull(unitBase, "unitBase may not be null"); this.nameSymbol = Objects.requireNonNull(ns, "ns may not be null"); @@ -192,7 +192,7 @@ public abstract class Unit implements Nameable { * * @implSpec This method is used by {@link #convertTo}, and its behaviour * affects the behaviour of {@code convertTo}. - * + * * @param value value expressed in base unit * @return value expressed in this unit * @since 2018-12-22 @@ -208,7 +208,7 @@ public abstract class Unit implements Nameable { * {@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 @@ -235,7 +235,7 @@ public abstract class Unit implements Nameable { * {@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 type of value to convert to @@ -270,7 +270,7 @@ public abstract class Unit implements Nameable { * * @implSpec This method is used by {@link #convertTo}, and its behaviour * affects the behaviour of {@code convertTo}. - * + * * @param value value expressed in this unit * @return value expressed in base unit * @since 2018-12-22 @@ -342,7 +342,7 @@ public abstract class Unit implements Nameable { // second condition - check that for (final BaseUnit b : linear.getBase().getBaseSet()) { - if (!SI.BaseUnits.BASE_UNITS.contains(b)) + if (!Metric.BaseUnits.BASE_UNITS.contains(b)) return false; } diff --git a/src/main/java/sevenUnits/unit/UnitDatabase.java b/src/main/java/sevenUnits/unit/UnitDatabase.java index a40f000..b45d9cf 100644 --- a/src/main/java/sevenUnits/unit/UnitDatabase.java +++ b/src/main/java/sevenUnits/unit/UnitDatabase.java @@ -1116,7 +1116,7 @@ public final class UnitDatabase { private static final LinearUnit exponentiateUnits(final LinearUnit base, final LinearUnit exponentUnit) { // exponent function - first check if o2 is a number, - if (exponentUnit.getBase().equals(SI.ONE.getBase())) { + 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)) @@ -1142,7 +1142,7 @@ public final class UnitDatabase { private static final LinearUnitValue exponentiateUnitValues( final LinearUnitValue base, final LinearUnitValue exponentValue) { // exponent function - first check if o2 is a number, - if (exponentValue.canConvertTo(SI.ONE)) { + if (exponentValue.canConvertTo(Metric.ONE)) { // then check if it is an integer, final double exponent = exponentValue.getValueExact(); if (DecimalComparison.equals(exponent % 1, 0)) @@ -1676,7 +1676,7 @@ public final class UnitDatabase { final BigDecimal number = new BigDecimal(name); final double uncertainty = Math.pow(10, -number.scale()); - return LinearUnitValue.of(SI.ONE, + return LinearUnitValue.of(Metric.ONE, UncertainDouble.of(number.doubleValue(), uncertainty)); } catch (final NumberFormatException e) { return LinearUnitValue.getExact(this.getLinearUnit(name), 1); @@ -1786,7 +1786,7 @@ public final class UnitDatabase { public Unit getUnit(final String name) { try { final double value = Double.parseDouble(name); - return SI.ONE.times(value); + return Metric.ONE.times(value); } catch (final NumberFormatException e) { final Unit unit = this.units.get(name); if (unit == null) diff --git a/src/test/java/sevenUnits/unit/MultiUnitTest.java b/src/test/java/sevenUnits/unit/MultiUnitTest.java index 82722af..d632118 100644 --- a/src/test/java/sevenUnits/unit/MultiUnitTest.java +++ b/src/test/java/sevenUnits/unit/MultiUnitTest.java @@ -27,7 +27,7 @@ import org.junit.jupiter.api.Test; import sevenUnits.unit.BritishImperial; import sevenUnits.unit.MultiUnit; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; /** * Tests related to the {@code MultiUnit}. @@ -42,7 +42,7 @@ class MultiUnitTest { final MultiUnit footInch = MultiUnit.of(BritishImperial.Length.FOOT, BritishImperial.Length.INCH); - assertEquals(1702.0, footInch.convertTo(SI.METRE.withPrefix(SI.MILLI), + assertEquals(1702.0, footInch.convertTo(Metric.METRE.withPrefix(Metric.MILLI), Arrays.asList(5.0, 7.0)), 1.0); for (int i = 0; i < 1000; i++) { @@ -50,7 +50,7 @@ class MultiUnitTest { final double inches = rng.nextDouble() * 12; final double millimetres = feet * 304.8 + inches * 25.4; - final List feetAndInches = SI.METRE.withPrefix(SI.MILLI) + final List feetAndInches = Metric.METRE.withPrefix(Metric.MILLI) .convertTo(footInch, millimetres); assertEquals(feet, feetAndInches.get(0), 1e-10); assertEquals(inches, feetAndInches.get(1), 1e-10); diff --git a/src/test/java/sevenUnits/unit/UnitDatabaseTest.java b/src/test/java/sevenUnits/unit/UnitDatabaseTest.java index c706b5c..1d5e503 100644 --- a/src/test/java/sevenUnits/unit/UnitDatabaseTest.java +++ b/src/test/java/sevenUnits/unit/UnitDatabaseTest.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.Test; import sevenUnits.unit.LinearUnit; import sevenUnits.unit.NameSymbol; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; import sevenUnits.unit.Unit; import sevenUnits.unit.UnitDatabase; import sevenUnits.unit.UnitPrefix; @@ -48,18 +48,18 @@ import sevenUnits.unit.UnitPrefix; */ class UnitDatabaseTest { // some linear units and one nonlinear - private static final Unit U = SI.METRE; - private static final Unit V = SI.KILOGRAM; - private static final Unit W = SI.SECOND; + private static final Unit U = Metric.METRE; + private static final Unit V = Metric.KILOGRAM; + private static final Unit W = Metric.SECOND; // used for testing expressions // J = U^2 * V / W^2 - private static final LinearUnit J = SI.KILOGRAM.times(SI.METRE.toExponent(2)) - .dividedBy(SI.SECOND.toExponent(2)); - private static final LinearUnit K = SI.KELVIN; + private static final LinearUnit J = Metric.KILOGRAM.times(Metric.METRE.toExponent(2)) + .dividedBy(Metric.SECOND.toExponent(2)); + private static final LinearUnit K = Metric.KELVIN; private static final Unit NONLINEAR = Unit - .fromConversionFunctions(SI.METRE.getBase(), o -> o + 1, o -> o - 1); + .fromConversionFunctions(Metric.METRE.getBase(), o -> o + 1, o -> o - 1); // make the prefix values prime so I can tell which multiplications were made private static final UnitPrefix A = UnitPrefix.valueOf(2) diff --git a/src/test/java/sevenUnits/unit/UnitTest.java b/src/test/java/sevenUnits/unit/UnitTest.java index bad5a31..a980054 100644 --- a/src/test/java/sevenUnits/unit/UnitTest.java +++ b/src/test/java/sevenUnits/unit/UnitTest.java @@ -29,7 +29,7 @@ import org.junit.jupiter.api.Test; import sevenUnits.unit.LinearUnit; import sevenUnits.unit.LinearUnitValue; import sevenUnits.unit.NameSymbol; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; import sevenUnits.unit.Unit; import sevenUnits.unit.UnitValue; import sevenUnits.utils.DecimalComparison; @@ -48,19 +48,19 @@ class UnitTest { @Test public void testAdditionAndSubtraction() { - final LinearUnit inch = SI.METRE.times(0.0254) + final LinearUnit inch = Metric.METRE.times(0.0254) .withName(NameSymbol.of("inch", "in")); - final LinearUnit foot = SI.METRE.times(0.3048) + final LinearUnit foot = Metric.METRE.times(0.3048) .withName(NameSymbol.of("foot", "ft")); - assertEquals(inch.plus(foot), SI.METRE.times(0.3302)); - assertEquals(foot.minus(inch), SI.METRE.times(0.2794)); + assertEquals(inch.plus(foot), Metric.METRE.times(0.3302)); + assertEquals(foot.minus(inch), Metric.METRE.times(0.2794)); // test with LinearUnitValue - final LinearUnitValue value1 = LinearUnitValue.getExact(SI.METRE, 15); + final LinearUnitValue value1 = LinearUnitValue.getExact(Metric.METRE, 15); final LinearUnitValue value2 = LinearUnitValue.getExact(foot, 120); - final LinearUnitValue value3 = LinearUnitValue.getExact(SI.METRE, 0.5); - final LinearUnitValue value4 = LinearUnitValue.getExact(SI.KILOGRAM, 60); + final LinearUnitValue value3 = LinearUnitValue.getExact(Metric.METRE, 0.5); + final LinearUnitValue value4 = LinearUnitValue.getExact(Metric.KILOGRAM, 60); // make sure addition is done correctly assertEquals(51.576, value1.plus(value2).getValueExact(), 0.001); @@ -70,8 +70,8 @@ class UnitTest { // make sure addition uses the correct unit, and is still associative // (ignoring floating-point rounding errors) - assertEquals(SI.METRE, value1.plus(value2).getUnit()); - assertEquals(SI.METRE, value1.plus(value2).plus(value3).getUnit()); + assertEquals(Metric.METRE, value1.plus(value2).getUnit()); + assertEquals(Metric.METRE, value1.plus(value2).plus(value3).getUnit()); assertEquals(foot, value2.plus(value1).getUnit()); assertTrue(value1.plus(value2).equals(value2.plus(value1), true)); @@ -81,7 +81,7 @@ class UnitTest { @Test public void testConversion() { - final LinearUnit metre = SI.METRE; + final LinearUnit metre = Metric.METRE; final Unit inch = metre.times(0.0254); final UnitValue value = UnitValue.of(inch, 75); @@ -97,7 +97,7 @@ class UnitTest { final double expected = testValue * conversionFactor; // test - final Unit unit = SI.METRE.times(conversionFactor); + final Unit unit = Metric.METRE.times(conversionFactor); final double actual = unit.convertToBase(testValue); assertEquals(actual, expected, @@ -107,17 +107,17 @@ class UnitTest { @Test public void testEquals() { - final LinearUnit metre = SI.METRE; - final Unit meter = SI.BaseUnits.METRE.asLinearUnit(); + final LinearUnit metre = Metric.METRE; + final Unit meter = Metric.BaseUnits.METRE.asLinearUnit(); assertEquals(metre, meter); } @Test public void testIsMetric() { - final Unit metre = SI.METRE; - final Unit megasecond = SI.SECOND.withPrefix(SI.MEGA); - final Unit hour = SI.HOUR; + final Unit metre = Metric.METRE; + final Unit megasecond = Metric.SECOND.withPrefix(Metric.MEGA); + final Unit hour = Metric.HOUR; assertTrue(metre.isMetric()); assertTrue(megasecond.isMetric()); @@ -127,26 +127,26 @@ class UnitTest { @Test public void testMultiplicationAndDivision() { // test unit-times-unit multiplication - final LinearUnit generatedJoule = SI.KILOGRAM - .times(SI.METRE.toExponent(2)).dividedBy(SI.SECOND.toExponent(2)); - final LinearUnit actualJoule = SI.JOULE; + final LinearUnit generatedJoule = Metric.KILOGRAM + .times(Metric.METRE.toExponent(2)).dividedBy(Metric.SECOND.toExponent(2)); + final LinearUnit actualJoule = Metric.JOULE; assertEquals(generatedJoule, actualJoule); // test multiplication by conversion factors - final LinearUnit kilometre = SI.METRE.times(1000); - final LinearUnit hour = SI.SECOND.times(3600); + final LinearUnit kilometre = Metric.METRE.times(1000); + final LinearUnit hour = Metric.SECOND.times(3600); final LinearUnit generatedKPH = kilometre.dividedBy(hour); - final LinearUnit actualKPH = SI.METRE.dividedBy(SI.SECOND).dividedBy(3.6); + final LinearUnit actualKPH = Metric.METRE.dividedBy(Metric.SECOND).dividedBy(3.6); assertEquals(generatedKPH, actualKPH); } @Test public void testPrefixes() { - final LinearUnit generatedKilometre = SI.METRE.withPrefix(SI.KILO); - final LinearUnit actualKilometre = SI.METRE.times(1000); + final LinearUnit generatedKilometre = Metric.METRE.withPrefix(Metric.KILO); + final LinearUnit actualKilometre = Metric.METRE.times(1000); assertEquals(generatedKilometre, actualKilometre); } diff --git a/src/test/java/sevenUnits/utils/ObjectProductTest.java b/src/test/java/sevenUnits/utils/ObjectProductTest.java index 32a8c78..13fd7ec 100644 --- a/src/test/java/sevenUnits/utils/ObjectProductTest.java +++ b/src/test/java/sevenUnits/utils/ObjectProductTest.java @@ -18,18 +18,18 @@ package sevenUnits.utils; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; -import static sevenUnits.unit.SI.Dimensions.AREA; -import static sevenUnits.unit.SI.Dimensions.ENERGY; -import static sevenUnits.unit.SI.Dimensions.LENGTH; -import static sevenUnits.unit.SI.Dimensions.MASS; -import static sevenUnits.unit.SI.Dimensions.MASS_DENSITY; -import static sevenUnits.unit.SI.Dimensions.QUANTITY; -import static sevenUnits.unit.SI.Dimensions.TIME; -import static sevenUnits.unit.SI.Dimensions.VOLUME; +import static sevenUnits.unit.Metric.Dimensions.AREA; +import static sevenUnits.unit.Metric.Dimensions.ENERGY; +import static sevenUnits.unit.Metric.Dimensions.LENGTH; +import static sevenUnits.unit.Metric.Dimensions.MASS; +import static sevenUnits.unit.Metric.Dimensions.MASS_DENSITY; +import static sevenUnits.unit.Metric.Dimensions.QUANTITY; +import static sevenUnits.unit.Metric.Dimensions.TIME; +import static sevenUnits.unit.Metric.Dimensions.VOLUME; import org.junit.jupiter.api.Test; -import sevenUnits.unit.SI; +import sevenUnits.unit.Metric; import sevenUnits.utils.ObjectProduct; /** @@ -60,8 +60,8 @@ class ObjectProductTest { */ @Test public void testExponents() { - assertEquals(1, LENGTH.getExponent(SI.BaseDimensions.LENGTH)); - assertEquals(3, VOLUME.getExponent(SI.BaseDimensions.LENGTH)); + assertEquals(1, LENGTH.getExponent(Metric.BaseDimensions.LENGTH)); + assertEquals(3, VOLUME.getExponent(Metric.BaseDimensions.LENGTH)); } /** -- cgit v1.2.3 From 208c56b56940e58fae1253a8d38e9e56249eb0cb Mon Sep 17 00:00:00 2001 From: Adrien Hopkins Date: Thu, 26 Aug 2021 11:26:02 -0500 Subject: Finished initial draft of design document --- docs/design.org | 9 +++- docs/design.pdf | Bin 148366 -> 242954 bytes docs/design.tex | 44 ++++++++------- docs/diagrams/units-class-diagram.plantuml.png | Bin 0 -> 94248 bytes docs/diagrams/units-class-diagram.plantuml.txt | 72 +++++++++++++++++++++++++ src/main/java/sevenUnits/unit/BaseUnit.java | 2 +- src/main/java/sevenUnits/unit/Unit.java | 38 ++++++------- 7 files changed, 122 insertions(+), 43 deletions(-) create mode 100644 docs/diagrams/units-class-diagram.plantuml.png create mode 100644 docs/diagrams/units-class-diagram.plantuml.txt (limited to 'src/main/java/sevenUnits/unit') diff --git a/docs/design.org b/docs/design.org index 1453327..be345f2 100644 --- a/docs/design.org +++ b/docs/design.org @@ -11,6 +11,11 @@ The frontend code is currently subject to change, so it is not included in the current version of this document. * Unit System Design Any code related to the backend unit system is stored in the ~sevenUnits.unit~ package. + + Here is a class diagram of the system. Unimportant methods, methods inherited from Object, getters and setters have been omitted. + [[./diagrams/units-class-diagram.plantuml.png]] + #+CAPTION: Class diagram of sevenUnits.unit + #+LaTeX: \newpage ** Dimensions Dimensions represent what a unit is measuring, such as length, time, or energy. Dimensions are represented as an [[*ObjectProduct][ObjectProduct]], where ~BaseDimension~ is a very simple class (its only properties are a name and a symbol) which represents the dimension of a base unit; these base dimensions can be multiplied to create all other Dimensions. ** Unit Classes @@ -21,7 +26,7 @@ ~BaseUnit~ represents a unit that all other units are defined by. All of the units used by this system are defined by seven SI ~BaseUnit~ instances (metre, second, kilogram, ampere, kelvin, mole, candela; this is what 7Units is named after) and two non-SI ~BaseUnit~ instances (US dollar and bit). Because base units are themselves units (and should be able to be used as units), ~BaseUnit~ is a subclass of ~Unit~, using its own package-private constructor. However, most units are instances of ~LinearUnit~, another subclass of ~Unit~. ~LinearUnit~ represents a unit that is /a product of a base unit and a constant called the *conversion factor*/. Most units you've ever used fall under this definition, the only common exceptions are degrees Celsius and Fahrenheit. This simplicity allows the ~LinearUnit~ to do many things: - - It can implement conversion to and from the base as multiplying and dividing respectively by the conversion factor + - It can implement conversion to and from the base as multiplying and dividing by the conversion factor respectively - You can easily create new units by multiplying or dividing a ~LinearUnit~ by a number (for example, kilometre = metre * 1000). This can be easily implemented as multiplying this unit's conversion factor by the multiplier and returning a new ~LinearUnit~ with that conversion factor factor. - You can add or subtract two ~LinearUnit~ instances to create a third (as long as they have the same base) by adding or subtracting the conversion factor. - You can multiply or divide any two ~LinearUnit~ instances to create a third by multiplying or dividing the bases and conversion factors. @@ -71,7 +76,7 @@ After evaluating the last token, there should be one value left in the stack - the answer. If there isn't, the original expression was malformed. ** Math Classes There are two simple math classes in 7Units: - - ~UncertainDouble~ :: Like a ~double~, but with an uncertainty (e.g. \(2.0 \pm 0.4\)). The operations are like those of the regular Double, only they also calculate the uncertainty of the final value. They also have "exact" versions to help interoperation between ~double~ and ~UncertainDouble~. + - ~UncertainDouble~ :: Like a ~double~, but with an uncertainty (e.g. \(2.0 \pm 0.4\)). The operations are like those of the regular Double, only they also calculate the uncertainty of the final value. They also have "exact" versions to help interoperation between ~double~ and ~UncertainDouble~. It is used by the converter's Scientific Precision setting. - ~DecimalComparison~ :: A static utility class that contains a few alternate equals() methods for ~double~ and ~UncertainDouble~. These methods allow a slight (configurable) difference between values to still be considered equal, to fight roundoff error. ** Collection Classes The ~ConditionalExistenceCollections~ class contains wrapper implementations of ~Collection~, ~Iterator~, ~Map~ and ~Set~. These implementations ignore elements that do not pass a certain condition - if an element fails the condition, ~contains~ will return false, the iterator will skip past it, it won't be counted in ~size~, etc. even if it exists in the original collection. Effectively, any element of the original collection that fails the test does not exist. diff --git a/docs/design.pdf b/docs/design.pdf index c906158..fd1f2f1 100644 Binary files a/docs/design.pdf and b/docs/design.pdf differ diff --git a/docs/design.tex b/docs/design.tex index 05d2368..178a1c8 100644 --- a/docs/design.tex +++ b/docs/design.tex @@ -1,4 +1,4 @@ -% Created 2021-08-26 Thu 08:35 +% Created 2021-08-26 Thu 11:25 % Intended LaTeX compiler: pdflatex \documentclass[11pt]{article} \usepackage[utf8]{inputenc} @@ -34,19 +34,25 @@ \newpage \section{Introduction} -\label{sec:org9766985} +\label{sec:orgc81fddd} 7Units is a program that can convert between units. This document details the internal design of 7Units, intended to be used by current and future developers. The frontend code is currently subject to change, so it is not included in the current version of this document. \section{Unit System Design} -\label{sec:org9482112} +\label{sec:org9d0655d} Any code related to the backend unit system is stored in the \texttt{sevenUnits.unit} package. + +Here is a class diagram of the system. Unimportant methods, methods inherited from Object, getters and setters have been omitted. +\begin{center} +\includegraphics[width=.9\linewidth]{./diagrams/units-class-diagram.plantuml.png} +\end{center} +\newpage \subsection{Dimensions} -\label{sec:org29ea1a0} -Dimensions represent what a unit is measuring, such as length, time, or energy. Dimensions are represented as an \hyperref[sec:org22ea189]{ObjectProduct}, where \texttt{BaseDimension} is a very simple class (its only properties are a name and a symbol) which represents the dimension of a base unit; these base dimensions can be multiplied to create all other Dimensions. +\label{sec:org1e98dda} +Dimensions represent what a unit is measuring, such as length, time, or energy. Dimensions are represented as an \hyperref[sec:orgc7c5740]{ObjectProduct}, where \texttt{BaseDimension} is a very simple class (its only properties are a name and a symbol) which represents the dimension of a base unit; these base dimensions can be multiplied to create all other Dimensions. \subsection{Unit Classes} -\label{sec:org492fabc} -Units are internally represented by the abstract class \texttt{Unit}. All units have an \hyperref[sec:org22ea189]{ObjectProduct} (referred to as the base) that they are based on, a dimension (ObjectProduct), one or more names and a symbol (these last two bits of data are contained in the \texttt{NameSymbol} class). The dimension is calculated from the base unit when needed; the variable is just a cache. It has two constructors: a package-private one used to make \texttt{BaseUnit} instances, and a protected one used to make general units (for other subclasses of \texttt{Unit}). All unit classes are immutable. +\label{sec:orgd5ff0fb} +Units are internally represented by the abstract class \texttt{Unit}. All units have an \hyperref[sec:orgc7c5740]{ObjectProduct} (referred to as the base) that they are based on, a dimension (ObjectProduct), one or more names and a symbol (these last two bits of data are contained in the \texttt{NameSymbol} class). The dimension is calculated from the base unit when needed; the variable is just a cache. It has two constructors: a package-private one used to make \texttt{BaseUnit} instances, and a protected one used to make general units (for other subclasses of \texttt{Unit}). All unit classes are immutable. Units also have two conversion functions - one which converts from a value expressed in this unit to its base unit, and another which converts from a value expressed in the base unit to this unit. In \texttt{Unit}, they are defined as two abstract methods. This allows you to convert from any unit to any other (as long as they have the same base, i.e. you aren't converting metres to pounds). To convert from A to B, first convert from A to its base, then convert from the base to B. @@ -54,7 +60,7 @@ Units also have two conversion functions - one which converts from a value expre However, most units are instances of \texttt{LinearUnit}, another subclass of \texttt{Unit}. \texttt{LinearUnit} represents a unit that is \emph{a product of a base unit and a constant called the \textbf{conversion factor}}. Most units you've ever used fall under this definition, the only common exceptions are degrees Celsius and Fahrenheit. This simplicity allows the \texttt{LinearUnit} to do many things: \begin{itemize} -\item It can implement conversion to and from the base as multiplying and dividing respectively by the conversion factor +\item It can implement conversion to and from the base as multiplying and dividing by the conversion factor respectively \item You can easily create new units by multiplying or dividing a \texttt{LinearUnit} by a number (for example, kilometre = metre * 1000). This can be easily implemented as multiplying this unit's conversion factor by the multiplier and returning a new \texttt{LinearUnit} with that conversion factor factor. \item You can add or subtract two \texttt{LinearUnit} instances to create a third (as long as they have the same base) by adding or subtracting the conversion factor. \item You can multiply or divide any two \texttt{LinearUnit} instances to create a third by multiplying or dividing the bases and conversion factors. @@ -71,20 +77,20 @@ There are a few more classes which play small roles in the unit system: \item[{USCustomary}] A static utility class with instances of common units in the US Customary system (not to be confused with the British Imperial system; it has the same unit names but the values of a few units are different). \end{description} \subsection{Prefixes} -\label{sec:org96c3f4a} +\label{sec:org1aaa92c} A \texttt{UnitPrefix} is a simple object that can multiply a \texttt{LinearUnit} by a value. It can calculate a new name for the unit by combining its name and the unit's name (symbols are done similarly). It can do multiplication, division and exponentation with a number, as well as multiplication and division with another prefix; all of these work by changing the prefix's multiplier. \subsection{The Unit Database} -\label{sec:org96ca2c9} +\label{sec:org7c6cf6d} The \texttt{UnitDatabase} class stores all of the unit, prefix and dimension data used by this program. It is not a representation of an actual database, just a class that stores lots of data. Units are stored using a custom \texttt{Map} implementation (\texttt{PrefixedUnitMap}) which maps unit names to units. It is backed by two maps: one for units (without prefixes) and one for prefixes. It is programmed to include prefixes (so if units includes "metre" and prefixes includes "kilo", this map will include "kilometre", mapping it to a unit representing a kilometre). It is immutable, but you can modify the underlying maps, which is reflected in the \texttt{PrefixedUnitMap}. Other than that, it is a normal map implementation. Prefixes and dimensions are stored in normal maps. \subsubsection{Parsing Expressions} -\label{sec:orgbd5591a} -Each \texttt{UnitDatabase} instance has four \hyperref[sec:org616a257]{ExpressionParser} instances associated with it, for four types of expressions: unit, unit value, prefix and dimension. They are mostly similar, with operators corresponding to each operation of the corresponding class (\texttt{LinearUnit}, \texttt{LinearUnitValue}, \texttt{UnitPrefix}, \texttt{ObjectProduct}). Unit and unit value expressions use linear units; nonlinear units can be used with a special syntax (like "degC(20)") and are immediately converted to a linear unit representing their base (Kelvin in this case) before operating. +\label{sec:org8392990} +Each \texttt{UnitDatabase} instance has four \hyperref[sec:orgb091347]{ExpressionParser} instances associated with it, for four types of expressions: unit, unit value, prefix and dimension. They are mostly similar, with operators corresponding to each operation of the corresponding class (\texttt{LinearUnit}, \texttt{LinearUnitValue}, \texttt{UnitPrefix}, \texttt{ObjectProduct}). Unit and unit value expressions use linear units; nonlinear units can be used with a special syntax (like "degC(20)") and are immediately converted to a linear unit representing their base (Kelvin in this case) before operating. \subsubsection{Parsing Files} -\label{sec:org1627c0d} +\label{sec:orgd4ad341} There are two types of data files: unit and dimension. Unit files contain data about units and prefixes. Each line contains the name of a unit or prefix (prefixes end in a dash, units don't) followed by an expression which defines it, separated by one or more space characters (this behaviour is defined by the static regular expression \texttt{NAME\_EXPRESSION}). Unit files are parsed line by line, each line being run through the \texttt{addUnitOrPrefixFromLine} method, which splits a line into name and expression, determines whether it's a unit or a prefix, and parses the expression. Because all units are defined by others, base units need to be defined with a special expression "!"; \textbf{these units should be added to the database before parsing the file}. @@ -92,15 +98,15 @@ Unit files contain data about units and prefixes. Each line contains the name o Dimension files are similar, only for dimensions instead of units and prefixes. \newpage \section{Utility Classes} -\label{sec:org99dedb2} +\label{sec:org251cb6a} 7Units has a few general "utility" classes. They aren't directly related to units, but are used in the units system. \subsection{ObjectProduct} -\label{sec:org22ea189} +\label{sec:orgc7c5740} An \texttt{ObjectProduct} represents a "product" of elements of some type. The units system uses them to represent coherent units as a product of base units, and dimensions as a product of base dimensions. Internally, it is represented using a map mapping objects to their exponents in the product. For example, the unit "kg m\textsuperscript{2} / s\textsuperscript{2}" (i.e. a Joule) would be represented with a map like \texttt{[kg: 1, m: 2, s: -2]}. \subsection{ExpressionParser} -\label{sec:org616a257} +\label{sec:orgb091347} The \texttt{ExpressionParser} class is used to parse the unit, prefix and dimension expressions that are used throughout 7Units. An expression is something like "(2 m + 30 J / N) * 8 s)". Each instance represents a type of expression, containing a way to obtain values (such as numbers or units) from the text and operations that can be done on these values (such as addition, subtraction or multiplication). Each operation also has a priority, which controls the order of operations (i.e. multiplication gets a higher priority than addition). \texttt{ExpressionParser} has a parameterized type \texttt{T}, which represents the type of the value used in the expression. The expression parser currently only supports one type of value per expression; in the expressions used by 7Units numbers are treated as a kind of unit or prefix. Operators are represented by internal types; the system distinguishes between unary operators (those that take a single value, like negation) and binary operators (those that take 2 values, like +, -, * or /). @@ -117,13 +123,13 @@ Expressions are parsed in 2 steps: After evaluating the last token, there should be one value left in the stack - the answer. If there isn't, the original expression was malformed. \end{enumerate} \subsection{Math Classes} -\label{sec:orgd04995c} +\label{sec:orgb4a476a} There are two simple math classes in 7Units: \begin{description} -\item[{\texttt{UncertainDouble}}] Like a \texttt{double}, but with an uncertainty (e.g. \(2.0 \pm 0.4\)). The operations are like those of the regular Double, only they also calculate the uncertainty of the final value. They also have "exact" versions to help interoperation between \texttt{double} and \texttt{UncertainDouble}. +\item[{\texttt{UncertainDouble}}] Like a \texttt{double}, but with an uncertainty (e.g. \(2.0 \pm 0.4\)). The operations are like those of the regular Double, only they also calculate the uncertainty of the final value. They also have "exact" versions to help interoperation between \texttt{double} and \texttt{UncertainDouble}. It is used by the converter's Scientific Precision setting. \item[{\texttt{DecimalComparison}}] A static utility class that contains a few alternate equals() methods for \texttt{double} and \texttt{UncertainDouble}. These methods allow a slight (configurable) difference between values to still be considered equal, to fight roundoff error. \end{description} \subsection{Collection Classes} -\label{sec:org00dd440} +\label{sec:org4a3e6a1} The \texttt{ConditionalExistenceCollections} class contains wrapper implementations of \texttt{Collection}, \texttt{Iterator}, \texttt{Map} and \texttt{Set}. These implementations ignore elements that do not pass a certain condition - if an element fails the condition, \texttt{contains} will return false, the iterator will skip past it, it won't be counted in \texttt{size}, etc. even if it exists in the original collection. Effectively, any element of the original collection that fails the test does not exist. \end{document} diff --git a/docs/diagrams/units-class-diagram.plantuml.png b/docs/diagrams/units-class-diagram.plantuml.png new file mode 100644 index 0000000..7c68ab5 Binary files /dev/null and b/docs/diagrams/units-class-diagram.plantuml.png differ diff --git a/docs/diagrams/units-class-diagram.plantuml.txt b/docs/diagrams/units-class-diagram.plantuml.txt new file mode 100644 index 0000000..7baf168 --- /dev/null +++ b/docs/diagrams/units-class-diagram.plantuml.txt @@ -0,0 +1,72 @@ +@startuml +abstract class Unit { + -unitBase : ObjectProduct + -nameSymbol : NameSymbol + -dimension : ObjectProduct + +{static} fromConversionFunctions(ObjectProduct, DoubleUnaryOperator, DoubleUnaryOperator) : Unit + #Unit(ObjectProduct, NameSymbol) : Unit + ~Unit(NameSymbol) : Unit + +canConvertTo(Unit) : boolean + +convertTo(Unit, double) : double + #convertFromBase(double) : double + #convertToBase(double) : double + +isMetric() : boolean + +withName(NameSymbol) : Unit +} +class BaseUnit { + -dimension : BaseDimension + -BaseUnit(BaseDimension, String, String, Set, double) : LinearUnit + -LinearUnit(ObjectProduct, double, NameSymbol) : LinearUnit + +convertTo(LinearUnit, UncertainDouble) : UncertainDouble + +plus(LinearUnit) : LinearUnit + +minus(LinearUnit) : LinearUnit + +times(LinearUnit) : LinearUnit + +dividedBy(LinearUnit) : LinearUnit + +times(double) : LinearUnit + +dividedBy(double) : LinearUnit + +toExponent(int) : LinearUnit + +withPrefix(UnitPrefix) : LinearUnit + +withName(NameSymbol) : LinearUnit +} +class UnitPrefix { + -multiplier : double + +times(double) : UnitPrefix + +dividedBy(double) : UnitPrefix +} +class UnitDatabase { + -prefixlessUnits : Map + -units : Map + -prefixes : Map + -dimensions : Map> + -unitExpressionParser : ExpressionParser + +loadUnitsFile(Path) + -addUnitOrPrefixFromLine(String, long) + +addUnit(String, Unit) + +containsUnitName(String) : boolean + +evaluateUnitExpression(String) : LinearUnitValue + +getUnit(String) : Unit +} +class UnitValue { + -unit : Unit + -value : double + +canConvertTo(Unit) : boolean + +convertTo(Unit) : UnitValue + +convertToLinear(LinearUnit) : LinearUnitValue +} + +Unit <|-- BaseUnit +Unit --* BaseUnit +BaseDimension -o BaseUnit +Unit <|-- LinearUnit +Unit *- SI +UnitValue --o Unit +UnitDatabase --* Unit +UnitDatabase --* UnitPrefix +UnitDatabase --* BaseDimension +UnitDatabase -* "4" ExpressionParser +@enduml diff --git a/src/main/java/sevenUnits/unit/BaseUnit.java b/src/main/java/sevenUnits/unit/BaseUnit.java index b1e30fb..ee2c277 100644 --- a/src/main/java/sevenUnits/unit/BaseUnit.java +++ b/src/main/java/sevenUnits/unit/BaseUnit.java @@ -75,7 +75,7 @@ public final class BaseUnit extends Unit { */ private BaseUnit(final BaseDimension dimension, final String primaryName, final String symbol, final Set otherNames) { - super(primaryName, symbol, otherNames); + super(NameSymbol.of(primaryName, symbol, otherNames)); this.dimension = Objects.requireNonNull(dimension, "dimension must not be null."); } diff --git a/src/main/java/sevenUnits/unit/Unit.java b/src/main/java/sevenUnits/unit/Unit.java index 58b4e10..005b6f7 100644 --- a/src/main/java/sevenUnits/unit/Unit.java +++ b/src/main/java/sevenUnits/unit/Unit.java @@ -17,10 +17,8 @@ package sevenUnits.unit; import java.util.HashMap; -import java.util.HashSet; import java.util.Map; import java.util.Objects; -import java.util.Set; import java.util.function.DoubleUnaryOperator; import sevenUnits.utils.DecimalComparison; @@ -109,6 +107,19 @@ public abstract class Unit implements Nameable { */ private transient ObjectProduct dimension = null; + /** + * A constructor that constructs {@code BaseUnit} instances. + * + * @since 2019-10-16 + */ + Unit(final NameSymbol nameSymbol) { + if (this instanceof BaseUnit) { + this.unitBase = ObjectProduct.oneOf((BaseUnit) this); + } else + throw new AssertionError(); + this.nameSymbol = nameSymbol; + } + /** * Creates the {@code Unit}. * @@ -123,21 +134,6 @@ public abstract class Unit implements Nameable { this.nameSymbol = Objects.requireNonNull(ns, "ns may not be null"); } - /** - * A constructor that constructs {@code BaseUnit} instances. - * - * @since 2019-10-16 - */ - Unit(final String primaryName, final String symbol, - final Set otherNames) { - if (this instanceof BaseUnit) { - this.unitBase = ObjectProduct.oneOf((BaseUnit) this); - } else - throw new AssertionError(); - this.nameSymbol = NameSymbol.of(primaryName, symbol, - new HashSet<>(otherNames)); - } - /** * @return this unit as a {@link Unitlike} * @since 2020-09-07 @@ -192,7 +188,7 @@ public abstract class Unit implements Nameable { * * @implSpec This method is used by {@link #convertTo}, and its behaviour * affects the behaviour of {@code convertTo}. - * + * * @param value value expressed in base unit * @return value expressed in this unit * @since 2018-12-22 @@ -208,7 +204,7 @@ public abstract class Unit implements Nameable { * {@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 @@ -235,7 +231,7 @@ public abstract class Unit implements Nameable { * {@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 type of value to convert to @@ -270,7 +266,7 @@ public abstract class Unit implements Nameable { * * @implSpec This method is used by {@link #convertTo}, and its behaviour * affects the behaviour of {@code convertTo}. - * + * * @param value value expressed in this unit * @return value expressed in base unit * @since 2018-12-22 -- cgit v1.2.3