v0.6.0

Author: nebkat

CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.6.0
+  * Renamed `systems` to `units`
+  * Moved scalar units to `units/scalar.dart`
+  * Quantity.scaled() now accepts a `num` as well as a `Quantity`
+
 ### 0.5.1
   * Fixed prefixed unit scaling [2c393b1](https://github.com/nebkat/dart-physical/commit/2c393b1a9836ca5ea5aae435c866167feceda6b4)
   * Reorganized examples

README.md

@@ -28,7 +28,7 @@ dart pub add physical
 
 ```dart
 import 'package:physical/physical.dart';
-import 'package:physical/system/si.dart' as si;
+import 'package:physical/units/si.dart' as si;
 
 // ----- UNCHECKED -----
 
@@ -139,7 +139,7 @@ In addition to this, units hold information about their symbol and name for disp
 
 Many common units are already provided by the library:
 ```dart
-// Provided in 'package:physical/system/si.dart'
+// Provided in 'package:physical/units/si.dart'
 // Or in       'package:physical/units.dart'
 const second = SiNamedUnit(
   symbol: 's',

example/physical.dart

@@ -1,8 +1,8 @@
 import 'package:physical/core.dart';
 import 'package:physical/quantities.dart';
-import 'package:physical/system/si.dart' as si;
-import 'package:physical/system/international.dart' as intl;
-import 'package:physical/system/usc.dart' as usc;
+import 'package:physical/units/international.dart' as intl;
+import 'package:physical/units/si.dart' as si;
+import 'package:physical/units/usc.dart' as usc;
 
 void main() {
   construction();

lib/core.dart

@@ -5,4 +5,5 @@ library;
 export 'src/core/dimensions.dart';
 export 'src/core/exception.dart';
 export 'src/core/quantity.dart';
+export 'src/core/scalar.dart';
 export 'src/core/unit.dart';

lib/src/common/quantities.dart

@@ -1,181 +1,182 @@
 import '../core/quantity.dart';
 import '../core/unit.dart';
-import '../system/si.dart';
-import '../system/usc.dart';
+import '../units/si.dart' as si;
+import '../units/usc.dart' as usc show degreeFahrenheit, zerothDegreeFahrenheit;
 import 'dimensions.dart';
 
 extension type Angle._(Quantity q) implements DimensionedQuantity<Angle> {
   Angle(Quantity q) : q = angle.checked(q);
-  const Angle.zero() : q = const Quantity.of(0, radian);
+  const Angle.zero() : q = const Quantity.of(0, si.radian);
   Angle.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Angle.degrees(num value) : this._(Quantity.of(value, degree));
-  Angle.radians(num value) : this._(Quantity.of(value, radian));
+  Angle.degrees(num value) : this._(Quantity.of(value, si.degree));
+  Angle.radians(num value) : this._(Quantity.of(value, si.radian));
 }
 
 extension type Length._(Quantity q) implements DimensionedQuantity<Length> {
   Length(Quantity q) : q = length.checked(q);
-  const Length.zero() : q = const Quantity.of(0, metre);
+  const Length.zero() : q = const Quantity.of(0, si.metre);
   Length.of(num value, Unit unit) : this._(Quantity.of(value, unit));
-  Length.metres(num value) : this._(Quantity.of(value, metre));
+  Length.metres(num value) : this._(Quantity.of(value, si.metre));
 }
 
 extension type Mass._(Quantity q) implements DimensionedQuantity<Mass> {
   Mass(Quantity q) : q = mass.checked(q);
-  const Mass.zero() : q = const Quantity.of(0, kilogram);
+  const Mass.zero() : q = const Quantity.of(0, si.kilogram);
   Mass.of(num value, Unit unit) : this._(Quantity.of(value, unit));
-  Mass.grams(num value) : this._(Quantity.of(value, gram));
-  Mass.kilograms(num value) : this._(Quantity.of(value, kilogram));
+  Mass.grams(num value) : this._(Quantity.of(value, si.gram));
+  Mass.kilograms(num value) : this._(Quantity.of(value, si.kilogram));
 }
 
 extension type Area._(Quantity q) implements DimensionedQuantity<Area> {
   Area(Quantity q) : q = area.checked(q);
-  const Area.zero() : q = const Quantity.of(0, squareMetre);
+  const Area.zero() : q = const Quantity.of(0, si.squareMetre);
   Area.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Area.squareMetres(num value) : this._(Quantity.of(value, squareMetre));
-  Area.hectares(num value) : this._(Quantity.of(value, hectare));
+  Area.squareMetres(num value) : this._(Quantity.of(value, si.squareMetre));
+  Area.hectares(num value) : this._(Quantity.of(value, si.hectare));
 }
 
 extension type Volume._(Quantity q) implements DimensionedQuantity<Volume> {
   Volume(Quantity q) : q = volume.checked(q);
-  const Volume.zero() : q = const Quantity.of(0, cubicMetre);
+  const Volume.zero() : q = const Quantity.of(0, si.cubicMetre);
   Volume.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Volume.litres(num value) : this._(Quantity.of(value, litre));
-  Volume.cubicMetres(num value) : this._(Quantity.of(value, cubicMetre));
+  Volume.litres(num value) : this._(Quantity.of(value, si.litre));
+  Volume.cubicMetres(num value) : this._(Quantity.of(value, si.cubicMetre));
 }
 
 extension type MassPerVolume._(Quantity q) implements DimensionedQuantity<MassPerVolume> {
   MassPerVolume(Quantity q) : q = massPerVolume.checked(q);
-  const MassPerVolume.zero() : q = const Quantity.of(0, kilogramPerCubicMetre);
+  const MassPerVolume.zero() : q = const Quantity.of(0, si.kilogramPerCubicMetre);
   MassPerVolume.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  MassPerVolume.kilogramsPerCubicMetre(num value) : this._(Quantity.of(value, kilogram / cubicMetre));
-  MassPerVolume.gramsPerCubicCentimetre(num value) : this._(Quantity.of(value, gram / (metre.centi ^ 3)));
+  MassPerVolume.kilogramsPerCubicMetre(num value) : this._(Quantity.of(value, si.kilogram / si.cubicMetre));
+  MassPerVolume.gramsPerCubicCentimetre(num value) : this._(Quantity.of(value, si.gram / (si.metre.centi ^ 3)));
 }
 
 extension type VolumePerMass._(Quantity q) implements DimensionedQuantity<VolumePerMass> {
   VolumePerMass(Quantity q) : q = volumePerMass.checked(q);
-  const VolumePerMass.zero() : q = const Quantity.of(0, cubicMetrePerKilogram);
+  const VolumePerMass.zero() : q = const Quantity.of(0, si.cubicMetrePerKilogram);
   VolumePerMass.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  VolumePerMass.cubicMetresPerKilogram(num value) : this._(Quantity.of(value, cubicMetre / kilogram));
+  VolumePerMass.cubicMetresPerKilogram(num value) : this._(Quantity.of(value, si.cubicMetre / si.kilogram));
 }
 
 extension type Time._(Quantity q) implements DimensionedQuantity<Time> {
   Time(Quantity q) : q = time.checked(q);
-  const Time.zero() : q = const Quantity.of(0, second);
+  const Time.zero() : q = const Quantity.of(0, si.second);
   Time.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Time.microseconds(num value) : this._(Quantity.of(value, second.micro));
-  Time.milliseconds(num value) : this._(Quantity.of(value, second.milli));
-  Time.seconds(num value) : this._(Quantity.of(value, second));
-  Time.minutes(num value) : this._(Quantity.of(value, minute));
-  Time.hours(num value) : this._(Quantity.of(value, hour));
+  Time.microseconds(num value) : this._(Quantity.of(value, si.second.micro));
+  Time.milliseconds(num value) : this._(Quantity.of(value, si.second.milli));
+  Time.seconds(num value) : this._(Quantity.of(value, si.second));
+  Time.minutes(num value) : this._(Quantity.of(value, si.minute));
+  Time.hours(num value) : this._(Quantity.of(value, si.hour));
   Time.hms(int hours, int minutes, int seconds)
       : this(Time.hours(hours) + Time.minutes(minutes) + Time.seconds(seconds));
   Time.duration(Duration duration) : this.microseconds(duration.inMicroseconds);
 }
 
 extension type Temperature._(QuantityPoint qp) implements QuantityPoint {
   Temperature(this.qp) : assert(qp.quantity.dimensions == temperature, "${qp.quantity.dimensions} != $temperature");
-  const Temperature.absoluteZero() : qp = const QuantityPoint(Quantity.of(0, kelvin), absoluteZeroKelvin);
-  const Temperature.icePoint() : qp = const QuantityPoint(Quantity.of(0, degreeCelsius), zerothDegreeCelsius);
+  const Temperature.absoluteZero() : qp = const QuantityPoint(Quantity.of(0, si.kelvin), si.absoluteZeroKelvin);
+  const Temperature.icePoint() : qp = const QuantityPoint(Quantity.of(0, si.degreeCelsius), si.zerothDegreeCelsius);
   Temperature.of(num value, Unit unit, QuantityOrigin origin) : this(origin + Quantity.of(value, unit));
-  Temperature.kelvins(num value) : this._(absoluteZeroKelvin + Quantity.of(value, kelvin));
-  Temperature.degreesCelsius(num value) : this._(zerothDegreeCelsius + Quantity.of(value, degreeCelsius));
-  Temperature.degreesFahrenheit(num value) : this._(zerothDegreeFahrenheit + Quantity.of(value, degreeFahrenheit));
+  Temperature.kelvins(num value) : this._(si.absoluteZeroKelvin + Quantity.of(value, si.kelvin));
+  Temperature.degreesCelsius(num value) : this._(si.zerothDegreeCelsius + Quantity.of(value, si.degreeCelsius));
+  Temperature.degreesFahrenheit(num value)
+      : this._(usc.zerothDegreeFahrenheit + Quantity.of(value, usc.degreeFahrenheit));
 
   Temperature inDegreesCelsius() => Temperature(
-        qp.withOrigin(zerothDegreeCelsius).inUnits(degreeCelsius),
+        qp.withOrigin(si.zerothDegreeCelsius).inUnits(si.degreeCelsius),
       );
   Temperature inDegreesFahrenheit() => Temperature(
-        qp.withOrigin(zerothDegreeFahrenheit).inUnits(degreeFahrenheit),
+        qp.withOrigin(usc.zerothDegreeFahrenheit).inUnits(usc.degreeFahrenheit),
       );
 }
 
 extension type Speed._(Quantity q) implements DimensionedQuantity<Speed> {
   Speed(Quantity q) : q = speed.checked(q);
-  const Speed.zero() : q = const Quantity.of(0, metrePerSecond);
+  const Speed.zero() : q = const Quantity.of(0, si.metrePerSecond);
   Speed.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Speed.metresPerSecond(num value) : this._(Quantity.of(value, metrePerSecond));
+  Speed.metresPerSecond(num value) : this._(Quantity.of(value, si.metrePerSecond));
 }
 
 extension type Acceleration._(Quantity q) implements DimensionedQuantity<Acceleration> {
   Acceleration(Quantity q) : q = acceleration.checked(q);
-  const Acceleration.zero() : q = const Quantity.of(0, metrePerSecondSquared);
+  const Acceleration.zero() : q = const Quantity.of(0, si.metrePerSecondSquared);
   Acceleration.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Acceleration.metresPerSecondSquared(num value) : this._(Quantity.of(value, metrePerSecondSquared));
+  Acceleration.metresPerSecondSquared(num value) : this._(Quantity.of(value, si.metrePerSecondSquared));
 }
 
 extension type Capacitance._(Quantity q) implements DimensionedQuantity<Capacitance> {
   Capacitance(Quantity q) : q = capacitance.checked(q);
-  const Capacitance.zero() : q = const Quantity.of(0, farad);
+  const Capacitance.zero() : q = const Quantity.of(0, si.farad);
   Capacitance.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Capacitance.farads(num value) : this._(Quantity.of(value, farad));
+  Capacitance.farads(num value) : this._(Quantity.of(value, si.farad));
 }
 
 extension type Frequency._(Quantity q) implements DimensionedQuantity<Frequency> {
   Frequency(Quantity q) : q = frequency.checked(q);
-  const Frequency.zero() : q = const Quantity.of(0, hertz);
+  const Frequency.zero() : q = const Quantity.of(0, si.hertz);
   Frequency.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Frequency.hertz(num value) : this._(Quantity.of(value, hertz));
+  Frequency.hertz(num value) : this._(Quantity.of(value, si.hertz));
 }
 
 extension type Voltage._(Quantity q) implements DimensionedQuantity<Voltage> {
   Voltage(Quantity q) : q = voltage.checked(q);
-  const Voltage.zero() : q = const Quantity.of(0, volt);
+  const Voltage.zero() : q = const Quantity.of(0, si.volt);
   Voltage.of(num value, Unit unit) : this(Quantity.of(value, unit));
 }
 
 extension type Current._(Quantity q) implements DimensionedQuantity<Current> {
   Current(Quantity q) : q = electricCurrent.checked(q);
-  const Current.zero() : q = const Quantity.of(0, ampere);
+  const Current.zero() : q = const Quantity.of(0, si.ampere);
   Current.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Current.amperes(num value) : this._(Quantity.of(value, ampere));
+  Current.amperes(num value) : this._(Quantity.of(value, si.ampere));
 }
 
 extension type Resistance._(Quantity q) implements DimensionedQuantity<Resistance> {
   Resistance(Quantity q) : q = resistance.checked(q);
-  const Resistance.zero() : q = const Quantity.of(0, ohm);
+  const Resistance.zero() : q = const Quantity.of(0, si.ohm);
   Resistance.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Resistance.ohms(num value) : this._(Quantity.of(value, ohm));
+  Resistance.ohms(num value) : this._(Quantity.of(value, si.ohm));
 }
 
 extension type Power._(Quantity q) implements DimensionedQuantity<Power> {
   Power(Quantity q) : q = power.checked(q);
-  const Power.zero() : q = const Quantity.of(0, watt);
+  const Power.zero() : q = const Quantity.of(0, si.watt);
   Power.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Power.watts(num value) : this._(Quantity.of(value, watt));
+  Power.watts(num value) : this._(Quantity.of(value, si.watt));
 }
 
 extension type Energy._(Quantity q) implements DimensionedQuantity<Energy> {
   Energy(Quantity q) : q = energy.checked(q);
-  const Energy.zero() : q = const Quantity.of(0, joule);
+  const Energy.zero() : q = const Quantity.of(0, si.joule);
   Energy.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Energy.joules(num value) : this._(Quantity.of(value, joule));
-  Energy.wattHours(num value) : this._(Quantity.of(value, wattHour));
+  Energy.joules(num value) : this._(Quantity.of(value, si.joule));
+  Energy.wattHours(num value) : this._(Quantity.of(value, si.wattHour));
 }
 
 extension type MassPerTime._(Quantity q) implements DimensionedQuantity<MassPerTime> {
   MassPerTime(Quantity q) : q = massPerTime.checked(q);
-  const MassPerTime.zero() : q = const Quantity.of(0, kilogramPerSecond);
+  const MassPerTime.zero() : q = const Quantity.of(0, si.kilogramPerSecond);
   MassPerTime.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  MassPerTime.kilogramsPerSecond(num value) : this._(Quantity.of(value, kilogramPerSecond));
+  MassPerTime.kilogramsPerSecond(num value) : this._(Quantity.of(value, si.kilogramPerSecond));
 }
 
 extension type MassPerArea._(Quantity q) implements DimensionedQuantity<MassPerArea> {
   MassPerArea(Quantity q) : q = massPerArea.checked(q);
-  const MassPerArea.zero() : q = const Quantity.of(0, kilogramPerSquareMetre);
+  const MassPerArea.zero() : q = const Quantity.of(0, si.kilogramPerSquareMetre);
   MassPerArea.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  MassPerArea.kilogramsPerSquareMetre(num value) : this._(Quantity.of(value, kilogramPerSquareMetre));
+  MassPerArea.kilogramsPerSquareMetre(num value) : this._(Quantity.of(value, si.kilogramPerSquareMetre));
 }
 
 extension type VolumePerTime._(Quantity q) implements DimensionedQuantity<VolumePerTime> {
   VolumePerTime(Quantity q) : q = volumePerTime.checked(q);
-  const VolumePerTime.zero() : q = const Quantity.of(0, cubicMetrePerSecond);
+  const VolumePerTime.zero() : q = const Quantity.of(0, si.cubicMetrePerSecond);
   VolumePerTime.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  VolumePerTime.cubicMetresPerSecond(num value) : this._(Quantity.of(value, cubicMetrePerSecond));
+  VolumePerTime.cubicMetresPerSecond(num value) : this._(Quantity.of(value, si.cubicMetrePerSecond));
 }
 
 extension type VolumePerArea._(Quantity q) implements DimensionedQuantity<VolumePerArea> {
   VolumePerArea(Quantity q) : q = volumePerArea.checked(q);
-  const VolumePerArea.zero() : q = const Quantity.of(0, cubicMetrePerSquareMetre);
+  const VolumePerArea.zero() : q = const Quantity.of(0, si.cubicMetrePerSquareMetre);
   VolumePerArea.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  VolumePerArea.cubicMetresPerSquareMetre(num value) : this._(Quantity.of(value, cubicMetrePerSquareMetre));
+  VolumePerArea.cubicMetresPerSquareMetre(num value) : this._(Quantity.of(value, si.cubicMetrePerSquareMetre));
 }

lib/src/core/quantity.dart

@@ -1,8 +1,5 @@
 import 'dart:math' as math;
 
-import 'package:physical/src/system/si.dart';
-
-import '../common/units.dart';
 import 'dimensions.dart';
 import 'exception.dart';
 import 'unit.dart';
@@ -176,10 +173,12 @@ class Quantity implements Comparable<Quantity> {
   /// A ceiled copy of this quantity.
   Quantity ceil() => Quantity.of(value.ceil(), unit);
 
-  /// A copy of this quantity scaled by [other].
+  /// A copy of this quantity scaled by [scalar].
+  ///
+  /// [scalar] must be a scalar [Quantity] or a [num].
   ///
   /// See also [DimensionedQuantity.scaled].
-  Quantity scaled(Scalar other) => this * other;
+  Quantity scaled(Object scalar) => this * Dimensions.empty().checked(numToScalar(scalar));
 
   /// Whether this quantity is numerically smaller than [other] in common units.
   bool operator <(Quantity other) => compareTo(other) < 0;
@@ -420,64 +419,10 @@ extension type DimensionedQuantity<T>._(Quantity q) implements Quantity {
   T floor() => q.floor() as T;
   T ceil() => q.ceil() as T;
 
-  /// A copy of this quantity scaled by [other].
+  /// A copy of this quantity scaled by [scalar].
   ///
-  /// Unlike [operator *], this operation is guaranteed to return the same type [T].
-  T scaled(Scalar other) => q.scaled(other) as T;
-}
-
-/// A dimensionless scalar [Quantity].
-///
-/// Specialization of [Quantity] that provides stronger typing on many operations
-/// that are guaranteed to return a scalar result.
-///
-/// Allows interaction with raw [num] values in addition, subtraction and comparison.
-extension type Scalar._(Quantity q) implements DimensionedQuantity<Scalar> {
-  Scalar(Quantity q) : q = Dimensions.empty().checked(q);
-  const Scalar.zero() : q = const Quantity.of(0, Unit.one);
-  const Scalar.identity() : q = const Quantity.of(1, Unit.one);
-  Scalar.of(num value, Unit unit) : this(Quantity.of(value, unit));
-  Scalar.one(num value) : this._(qty(value, Unit.one));
-  Scalar.percent(num value) : this._(qty(value, percent));
-  Scalar.perMille(num value) : this._(qty(value, perMille));
-  Scalar.partsPerMillion(num value) : this._(qty(value, partsPerMillion));
-  Scalar.partsPerBillion(num value) : this._(qty(value, partsPerBillion));
-
-  /// Adds two scalars, converting the addend to the units of this scalar.
+  /// [scalar] must be a scalar [Quantity] or a [num].
   ///
-  /// [addend] may be a [Quantity] or a raw [num].
-  Scalar operator +(Object addend) => q + numToScalar(addend) as Scalar;
-
-  /// Subtracts two scalars, converting the subtrahend to the units of this scalar.
-  ///
-  /// [subtrahend] may be a [Quantity] or a raw [num].
-  Scalar operator -(Object subtrahend) => q - numToScalar(subtrahend) as Scalar;
-
-  Scalar operator ^(Object exponent) => q ^ exponent as Scalar;
-
-  Scalar inverse() => q.inverse() as Scalar;
-  Scalar squared() => this ^ 2;
-  Scalar cubed() => this ^ 3;
-  Scalar sqrt() => this ^ (0.5);
-  Scalar cbrt() => this ^ (1 / 3);
-
-  /// Whether this scalar is numerically smaller than [other] in common units.
-  ///
-  /// [other] may be a [Quantity] or a raw [num].
-  bool operator <(Object other) => q < numToScalar(other);
-
-  /// Whether this scalar is numerically smaller than or equal to [other] in common units.
-  ///
-  /// [other] may be a [Quantity] or a raw [num].
-  bool operator <=(Object other) => q <= numToScalar(other);
-
-  /// Whether this scalar is numerically larger than [other] in common units.
-  ///
-  /// [other] may be a [Quantity] or a raw [num].
-  bool operator >(Object other) => q > numToScalar(other);
-
-  /// Whether this scalar is numerically larger than or equal to [other] in common units.
-  ///
-  /// [other] may be a [Quantity] or a raw [num].
-  bool operator >=(Object other) => q >= numToScalar(other);
+  /// Unlike [operator *], this operation is guaranteed to return the same type [T].
+  T scaled(Object scalar) => q.scaled(scalar) as T;
 }