Addition and subtraction use correct result precision

Author: mongoose13

CHANGELOG.md

@@ -14,6 +14,7 @@ types you need to work with from the rest of your code.
 
 ### Changed
 
+- Addition and subtraction use correct result precision
 - Update toString methods for a few measurement types
 - Write Good suggestions for README
 

lib/src/measurement.dart

@@ -90,11 +90,11 @@ abstract class Measurement<T extends Measurement<T>> implements Comparable<T> {
 
   /// Returns a measurement equivalent to the sum of two others.
   T operator +(final T other) =>
-      _construct(si + other.si, Precision.add(_precision, other._precision));
+      _construct(si + other.si, Precision.addition(this, other));
 
   /// Returns a measurement equivalent to the difference between two others.
   T operator -(final T other) =>
-      _construct(si - other.si, Precision.add(_precision, other._precision));
+      _construct(si - other.si, Precision.addition(this, -other));
 
   /// Returns a measurement equivalent to a multiple of this.
   T operator *(final double multiplier) =>

lib/src/precision.dart

@@ -49,16 +49,57 @@ class Precision {
   Precision.combine(final Precision a, final Precision b)
       : this(math.min(a.precision, b.precision));
 
+  @Deprecated("Use 'addition()' instead")
+  Precision.add(final Precision a, final Precision b) : this._max();
+
   /// Combines two [Precision]s per the "addition rule".
   ///
   /// Use this when adding or subtracting two numbers to determine the correct
   /// output precision. See [Wikipedia on Precision Arithmetic](
   /// https://en.wikipedia.org/wiki/Significant_figures#Arithmetic)
   /// for details.
+  static Precision addition<T extends Measurement<T>>(
+      final Measurement<T> a, final Measurement<T> b) {
+    if (a.isInfinite || b.isInfinite) {
+      return Precision._max();
+    }
+    final precisionA = digitsAfterDecimal(a);
+    final precisionB = digitsAfterDecimal(b);
+    final beforeDecimal = digitsBeforeDecimal(a._preciseSI() + b._preciseSI());
+    return Precision(beforeDecimal + math.min(precisionA, precisionB));
+  }
+
+  /// Calculates the number of significant digits after the decimal point.
   ///
-  /// Note that currently the result will always have maximum precision (for the
-  /// time being - future versions will fix this).
-  Precision.add(final Precision a, final Precision b) : this._max();
+  /// This only considers digits that fall within the measurement's precision,
+  /// e.g.:
+  ///
+  /// ```dart
+  /// digitsAfterDecimal(meters(1.2345));                           // 4
+  /// digitsAfterDecimal(meters(1.2345, precision: Precision(3)));  // 2
+  /// ```
+  static int digitsAfterDecimal(final Measurement measurement) {
+    if (measurement.isInfinite || measurement.isNaN) {
+      return 0;
+    }
+    final string = measurement._preciseSI().toStringAsExponential();
+    final locationOfE = string.indexOf('e');
+    return math.max(
+        measurement.precision -
+            int.parse(string.substring(locationOfE + 1)) -
+            1,
+        0);
+  }
+
+  /// Calculates the number of digits (significant or not) before the decimal.
+  static int digitsBeforeDecimal(final double number) {
+    if (number.isInfinite || number.isNaN) {
+      return Precision.max.precision;
+    }
+    final string = number.toStringAsExponential();
+    return math.max(
+        int.parse(string.substring(string.indexOf('e') + 1)) + 1, 0);
+  }
 
   /// Interprets the specified number according to this Precision.
   double withPrecision(final double value) =>

lib/src/temperature.dart

@@ -74,6 +74,9 @@ class Temperature implements Comparable<Temperature> {
   /// Returns `true` if this is infinite.
   bool get isInfinite => _kelvin.isInfinite;
 
+  /// Returns the digits of precision this measurement has.
+  int get precision => _precision.precision;
+
   @override
   bool operator ==(final dynamic other) =>
       other is Temperature &&
@@ -108,7 +111,8 @@ class Temperature implements Comparable<Temperature> {
   /// ```
   Temperature operator +(final TemperatureChange change) =>
       Temperature.ofKelvin(_kelvin + change.si,
-          precision: Precision.add(_precision, change._precision));
+          precision: Precision.addition(
+              kelvin(_kelvin, precision: _precision), change));
 
   /// Creates a [Temperature] representing the application of a [Temperature]
   /// and the opposite of a [TemperatureChange].
@@ -120,15 +124,17 @@ class Temperature implements Comparable<Temperature> {
   /// ```
   Temperature operator -(final TemperatureChange change) =>
       Temperature.ofKelvin(_kelvin - change.si,
-          precision: Precision.add(_precision, change._precision));
+          precision: Precision.addition(
+              kelvin(_kelvin, precision: _precision), -change));
 
   /// Returns the difference between this and another [Temperature].
   ///
   /// The resulting [TemperatureChange] will be negative if this is smaller than
   /// the other [Temperature].
   TemperatureChange difference(final Temperature other) =>
       kelvin(_kelvin - other._kelvin,
-          precision: Precision.add(_precision, other._precision));
+          precision: Precision.addition(kelvin(_kelvin, precision: _precision),
+              kelvin(other._kelvin, precision: other._precision)));
 
   @override
   String toString() => '$asKelvin K';

test/measurement_test.dart

@@ -883,16 +883,16 @@ void main() {
       // then
       expect(result.si, double.negativeInfinity);
     });
-    test('precision is maxed', () {
+    test('precision is set correctly', () {
       // given
-      final unit1 = meters(2, precision: Precision(5));
-      final unit2 = meters(3, precision: Precision(5));
+      final unit1 = meters(97.101, precision: Precision(5));
+      final unit2 = meters(3.456789, precision: Precision(8));
 
       // when
       final result = unit1 + unit2;
 
       // then
-      expect(result.precision, Precision.max.precision);
+      expect(result.precision, 6);
     });
   });
 
@@ -952,16 +952,16 @@ void main() {
       // then
       expect(result.si, double.infinity);
     });
-    test('precision is maxed', () {
+    test('precision is set correctly', () {
       // given
-      final unit1 = meters(2, precision: Precision(5));
-      final unit2 = meters(3, precision: Precision(5));
+      final unit1 = meters(3.45, precision: Precision(3));
+      final unit2 = meters(3.21, precision: Precision(5));
 
       // when
       final result = unit1 - unit2;
 
       // then
-      expect(result.precision, Precision.max.precision);
+      expect(result.precision, 2);
     });
   });