Measure.java

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.units;
 
import static org.wpilib.units.Units.Value;
 
import org.wpilib.units.measure.Acceleration;
import org.wpilib.units.measure.Angle;
import org.wpilib.units.measure.AngularAcceleration;
import org.wpilib.units.measure.AngularMomentum;
import org.wpilib.units.measure.AngularVelocity;
import org.wpilib.units.measure.Current;
import org.wpilib.units.measure.Dimensionless;
import org.wpilib.units.measure.Distance;
import org.wpilib.units.measure.Energy;
import org.wpilib.units.measure.Force;
import org.wpilib.units.measure.Frequency;
import org.wpilib.units.measure.LinearAcceleration;
import org.wpilib.units.measure.LinearMomentum;
import org.wpilib.units.measure.LinearVelocity;
import org.wpilib.units.measure.Mass;
import org.wpilib.units.measure.MomentOfInertia;
import org.wpilib.units.measure.Mult;
import org.wpilib.units.measure.Per;
import org.wpilib.units.measure.Power;
import org.wpilib.units.measure.Resistance;
import org.wpilib.units.measure.Temperature;
import org.wpilib.units.measure.Time;
import org.wpilib.units.measure.Torque;
import org.wpilib.units.measure.Velocity;
import org.wpilib.units.measure.Voltage;

public interface Measure<U extends Unit> extends Comparable<Measure<U>> {
  double EQUIVALENCE_THRESHOLD = 1e-12;

  double magnitude();

  double baseUnitMagnitude();

  U unit();

  default double in(U unit) {
    if (this.unit().equals(unit)) {
      return magnitude();
    } else {
      return unit.fromBaseUnits(baseUnitMagnitude());
    }
  }

  @SuppressWarnings("unchecked")
  default U baseUnit() {
    return (U) unit().getBaseUnit();
  }

  default double abs(U unit) {
    return Math.abs(this.in(unit));
  }

  default double copySign(Measure<U> other, U unit) {
    return Math.copySign(this.in(unit), other.in(unit));
  }

  Measure<U> unaryMinus();

  Measure<U> plus(Measure<? extends U> other);

  Measure<U> minus(Measure<? extends U> other);

  Measure<U> times(double multiplier);

  Measure<U> times(Dimensionless multiplier);

  default Measure<?> times(Measure<?> multiplier) {
    final double baseUnitResult = baseUnitMagnitude() * multiplier.baseUnitMagnitude();
 
    // First try to eliminate any common units
    if (unit() instanceof PerUnit<?, ?> ratio
        && multiplier.baseUnit().equals(ratio.denominator().getBaseUnit())) {
      // Per<N, D> * D -> yield N
      // Case 1: denominator of the Per cancels out, return with just the units of the numerator
      return ratio.numerator().ofBaseUnits(baseUnitResult);
    } else if (multiplier.baseUnit() instanceof PerUnit<?, ?> ratio
        && baseUnit().equals(ratio.denominator().getBaseUnit())) {
      // D * Per<N, D) -> yield N
      // Case 2: Same as Case 1, just flipped between this and the multiplier
      return ratio.numerator().ofBaseUnits(baseUnitResult);
    } else if (unit() instanceof PerUnit<?, ?> per
        && multiplier.unit() instanceof PerUnit<?, ?> otherPer
        && per.denominator().getBaseUnit().equals(otherPer.numerator().getBaseUnit())
        && per.numerator().getBaseUnit().equals(otherPer.denominator().getBaseUnit())) {
      // multiplying eg meters per second * milliseconds per foot
      // return a scalar
      return Value.of(baseUnitResult);
    }
 
    // No common units to eliminate, is one of them dimensionless?
    // Note that this must come *after* the multiplier cases, otherwise
    // Per<U, Dimensionless> * Dimensionless will not return a U
    if (multiplier.unit() instanceof DimensionlessUnit) {
      // scalar multiplication of this
      return times(multiplier.baseUnitMagnitude());
    } else if (unit() instanceof DimensionlessUnit) {
      // scalar multiplication of multiplier
      return multiplier.times(baseUnitMagnitude());
    }
 
    return switch (multiplier) {
      case Acceleration<?> acceleration -> times(acceleration);
      case Angle angle -> times(angle);
      case AngularAcceleration angularAcceleration -> times(angularAcceleration);
      case AngularMomentum angularMomentum -> times(angularMomentum);
      case AngularVelocity angularVelocity -> times(angularVelocity);
      case Current current -> times(current);
      // n.b. this case should already be covered
      case Dimensionless dimensionless -> times(dimensionless);
      case Distance distance -> times(distance);
      case Energy energy -> times(energy);
      case Force force -> times(force);
      case Frequency frequency -> times(frequency);
      case LinearAcceleration linearAcceleration -> times(linearAcceleration);
      case LinearVelocity linearVelocity -> times(linearVelocity);
      case Mass mass -> times(mass);
      case MomentOfInertia momentOfInertia -> times(momentOfInertia);
      case Mult<?, ?> mult -> times(mult);
      case Per<?, ?> per -> times(per);
      case Power power -> times(power);
      case Temperature temperature -> times(temperature);
      case Time time -> times(time);
      case Torque torque -> times(torque);
      case Velocity<?> velocity -> times(velocity);
      case Voltage voltage -> times(voltage);
      case Resistance resistance -> times(resistance);
      // Dimensional analysis fallthrough or a generic input measure type
      // Do a basic unit multiplication
      default -> MultUnit.combine(unit(), multiplier.unit()).ofBaseUnits(baseUnitResult);
    };
  }

  default Measure<?> times(Acceleration<?> multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Angle multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(AngularAcceleration multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(AngularMomentum multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(AngularVelocity multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Current multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Distance multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Energy multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Force multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Frequency multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(LinearAcceleration multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(LinearMomentum multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(LinearVelocity multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Mass multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(MomentOfInertia multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Mult<?, ?> multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Power multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Per<?, ?> multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Temperature multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Time multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Torque multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Velocity<?> multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Voltage multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default Measure<?> times(Resistance multiplier) {
    return MultUnit.combine(unit(), multiplier.unit())
        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  @SuppressWarnings("unchecked")
  default <Other extends Unit, M extends Measure<Other>> M timesConversionFactor(
      Measure<? extends PerUnit<Other, U>> conversionFactor) {
    return (M)
        conversionFactor
            .unit()
            .getBaseUnit()
            .numerator()
            .ofBaseUnits(baseUnitMagnitude() * conversionFactor.baseUnitMagnitude());
  }

  default Dimensionless timesInverse(
      Measure<? extends PerUnit<DimensionlessUnit, ? extends U>> multiplier) {
    return Value.ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
  }

  default <Other extends Unit> Measure<Other> timesRatio(
      Measure<? extends PerUnit<? extends Other, U>> ratio) {
    return ImmutableMeasure.ofBaseUnits(
        baseUnitMagnitude() * ratio.baseUnitMagnitude(), ratio.unit().numerator());
  }

  Measure<U> div(double divisor);

  Measure<U> div(Dimensionless divisor);

  default Measure<?> div(Measure<?> divisor) {
    final double baseUnitResult = baseUnitMagnitude() / divisor.baseUnitMagnitude();
 
    if (unit().getBaseUnit().equals(divisor.unit().getBaseUnit())) {
      // These are the same unit, return a dimensionless
      return Value.ofBaseUnits(baseUnitResult);
    }
 
    if (divisor instanceof Dimensionless) {
      // Dividing by a dimensionless, do a scalar division
      return unit().ofBaseUnits(baseUnitResult);
    }
 
    // Numerator is a dimensionless
    if (unit() instanceof DimensionlessUnit && divisor.unit() instanceof PerUnit<?, ?> ratio) {
      // Dividing by a ratio, return its reciprocal scaled by this
      return ratio.reciprocal().ofBaseUnits(baseUnitResult);
    }
 
    if (divisor.unit() instanceof PerUnit<?, ?> ratio
        && ratio.numerator().getBaseUnit().equals(baseUnit())) {
      // Numerator of the ratio cancels out
      // N / (N / D) -> N * D / N -> D
      // Note: all Velocity and Acceleration units inherit from PerUnit
      return ratio.denominator().ofBaseUnits(baseUnitResult);
    }
 
    if (divisor.unit() instanceof TimeUnit time) {
      // Dividing by a time, return a Velocity
      return VelocityUnit.combine(unit(), time).ofBaseUnits(baseUnitResult);
    }
 
    return switch (divisor) {
      case Acceleration<?> acceleration -> div(acceleration);
      case Angle angle -> div(angle);
      case AngularAcceleration angularAcceleration -> div(angularAcceleration);
      case AngularMomentum angularMomentum -> div(angularMomentum);
      case AngularVelocity angularVelocity -> div(angularVelocity);
      case Current current -> div(current);
      // n.b. this case should already be covered
      case Dimensionless dimensionless -> div(dimensionless);
      case Distance distance -> div(distance);
      case Energy energy -> div(energy);
      case Force force -> div(force);
      case Frequency frequency -> div(frequency);
      case LinearAcceleration linearAcceleration -> div(linearAcceleration);
      case LinearVelocity linearVelocity -> div(linearVelocity);
      case Mass mass -> div(mass);
      case MomentOfInertia momentOfInertia -> div(momentOfInertia);
      case Mult<?, ?> mult -> div(mult);
      case Per<?, ?> per -> div(per);
      case Power power -> div(power);
      case Temperature temperature -> div(temperature);
      case Time time -> div(time);
      case Torque torque -> div(torque);
      case Velocity<?> velocity -> div(velocity);
      case Voltage voltage -> div(voltage);
      case Resistance resistance -> div(resistance);
      // Dimensional analysis fallthrough or a generic input measure type
      // Do a basic unit multiplication
      default -> PerUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitResult);
    };
  }

  default Measure<?> div(Acceleration<?> divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Angle divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(AngularAcceleration divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(AngularMomentum divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(AngularVelocity divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Current divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Distance divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Energy divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Force divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Frequency divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(LinearAcceleration divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(LinearMomentum divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(LinearVelocity divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Mass divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(MomentOfInertia divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Mult<?, ?> divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Power divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Per<?, ?> divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Temperature divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Time divisor) {
    return VelocityUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Torque divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Velocity<?> divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Voltage divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> div(Resistance divisor) {
    return PerUnit.combine(unit(), divisor.unit())
        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
  }

  default Measure<?> per(AccelerationUnit<?> divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(AngleUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(AngularAccelerationUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(AngularMomentumUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(AngularVelocityUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(CurrentUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(DistanceUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(EnergyUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(ForceUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(FrequencyUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(LinearAccelerationUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(LinearMomentumUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(LinearVelocityUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(MassUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(MomentOfInertiaUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(MultUnit<?, ?> divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(PowerUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(PerUnit<?, ?> divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(TemperatureUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(TimeUnit period) {
    return div(period.of(1));
  }

  default Measure<?> per(TorqueUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(VelocityUnit<?> divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(VoltageUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  default Measure<?> per(ResistanceUnit divisorUnit) {
    return div(divisorUnit.one());
  }

  // eg Dimensionless / (Dimensionless / Time) -> Time
  default <Other extends Unit> Measure<Other> divideRatio(
      Measure<? extends PerUnit<? extends U, Other>> divisor) {
    return ImmutableMeasure.ofBaseUnits(
        baseUnitMagnitude() / divisor.baseUnitMagnitude(), divisor.unit().denominator());
  }

  default boolean isNear(Measure<?> other, double varianceThreshold) {
    if (!this.unit().getBaseUnit().equivalent(other.unit().getBaseUnit())) {
      return false; // Disjoint units, not compatible
    }
 
    // abs so negative inputs are calculated correctly
    var tolerance = Math.abs(other.baseUnitMagnitude() * varianceThreshold);
 
    return Math.abs(this.baseUnitMagnitude() - other.baseUnitMagnitude()) <= tolerance;
  }

  default boolean isNear(Measure<U> other, Measure<U> tolerance) {
    return Math.abs(this.baseUnitMagnitude() - other.baseUnitMagnitude())
        <= Math.abs(tolerance.baseUnitMagnitude());
  }

  default boolean isEquivalent(Measure<?> other) {
    // Return false for disjoint units that aren't compatible
    return this.unit().getBaseUnit().equals(other.unit().getBaseUnit())
        && Math.abs(baseUnitMagnitude() - other.baseUnitMagnitude()) <= EQUIVALENCE_THRESHOLD;
  }

  @Override
  default int compareTo(Measure<U> o) {
    return Double.compare(this.baseUnitMagnitude(), o.baseUnitMagnitude());
  }

  default boolean gt(Measure<U> o) {
    return compareTo(o) > 0;
  }

  default boolean gte(Measure<U> o) {
    return compareTo(o) > 0 || isEquivalent(o);
  }

  default boolean lt(Measure<U> o) {
    return compareTo(o) < 0;
  }

  default boolean lte(Measure<U> o) {
    return compareTo(o) < 0 || isEquivalent(o);
  }

  @SafeVarargs
  static <U extends Unit, T extends Measure<U>> T max(T... measures) {
    if (measures.length == 0) {
      return null; // nothing to compare
    }
 
    T max = null;
    for (T measure : measures) {
      if (max == null || measure.gt(max)) {
        max = measure;
      }
    }
 
    return max;
  }

  @SafeVarargs
  static <U extends Unit, T extends Measure<U>> T min(T... measures) {
    if (measures.length == 0) {
      return null; // nothing to compare
    }
 
    T max = null;
    for (T measure : measures) {
      if (max == null || measure.lt(max)) {
        max = measure;
      }
    }
 
    return max;
  }

  default String toShortString() {
    // eg 1.234e+04 V/m (1234 Volt per Meter in long form)
    return String.format("%.3e %s", magnitude(), unit().symbol());
  }

  default String toLongString() {
    // eg 1234 Volt per Meter (1.234e+04 V/m in short form)
    return String.format("%s %s", magnitude(), unit().name());
  }
}