Rename metric -> SI (#192)

* Rename metric -> SI

* Fix build

* Fix again

docs/examples/measuresDimension.ts

@@ -1,9 +1,9 @@
-import { Measure, MetricSystem } from "safe-units";
+import { Measure, SIUnitSystem } from "safe-units";
 
 // START
-const meter = Measure.dimension(MetricSystem, "length");
+const meter = Measure.dimension(SIUnitSystem, "length");
 console.log(meter); // 1 m
 
-const second = Measure.dimension(MetricSystem, "time");
+const second = Measure.dimension(SIUnitSystem, "time");
 console.log(second); // 1 s
 // END

docs/examples/measuresDimensionless.ts

@@ -1,7 +1,7 @@
-import { Measure, MetricSystem, meters } from "safe-units";
+import { Measure, SIUnitSystem, meters } from "safe-units";
 
 // START
-const scalar = Measure.dimensionless(MetricSystem, 2);
+const scalar = Measure.dimensionless(SIUnitSystem, 2);
 const distance = Measure.of(20, meters);
 const doubled = distance.times(scalar); // 40 m
 // END

docs/examples/measuresScale.ts

@@ -1,9 +1,9 @@
-import { Measure, MetricSystem, seconds } from "safe-units";
+import { Measure, SIUnitSystem, seconds } from "safe-units";
 
 // START
 const t = Measure.of(10, seconds);
 const doubledShort = t.scale(2); // 20 s
-const doubledLong = t.times(Measure.dimensionless(MetricSystem, 2)); // 20 s
+const doubledLong = t.times(Measure.dimensionless(SIUnitSystem, 2)); // 20 s
 // END
 
 console.log(doubledShort, doubledLong);

src/measure/genericMeasureFactory.ts

@@ -71,7 +71,7 @@ export function createMeasureType<N, S extends {} = {}>(
     const { createMeasure, isMeasure } = createMeasureClass(num);
 
     const common: GenericMeasureCommon<N> = {
-        ...getGenericMeasureStaticMethods(),
+        ...getGenericMeasureStaticMethods(num),
         isMeasure,
         dimensionless: (unitSystem, value) => createMeasure(value, unitSystem.createDimensionlessUnit(), unitSystem),
         dimension: (unitSystem, dimension, symbol) =>

src/measure/genericMeasureStatic.ts

@@ -1,5 +1,5 @@
-import { GenericMeasure } from "./genericMeasure";
-import { BinaryFn, PrefixFn, SpreadFn } from "./genericMeasureUtils";
+import { GenericMeasure, NumericOperations } from "./genericMeasure";
+import { BinaryFn, PrefixFn, SpreadFn, wrapBinaryFn, wrapReducerFn } from "./genericMeasureUtils";
 import { DivideUnits, MultiplyUnits, Unit } from "./unitTypeArithmetic";
 
 export interface GenericMeasureStatic<N> {
@@ -39,16 +39,13 @@ export interface GenericMeasureStatic<N> {
     prefix(prefix: string, multiplier: N): PrefixFn<N>;
 }
 
-export const getGenericMeasureStaticMethods = <N>(): GenericMeasureStatic<N> => {
-    const add: BinaryFn<N> = (left, right) => left.plus(right);
-    const min: BinaryFn<N> = (min, curr) => (curr.lt(min) ? curr : min);
-    const max: BinaryFn<N> = (max, curr) => (curr.gt(max) ? curr : max);
+export const getGenericMeasureStaticMethods = <N>(num: NumericOperations<N>): GenericMeasureStatic<N> => {
     return {
-        sum: reduce(add as any),
-        min: reduce(min as any),
-        max: reduce(max as any),
-        add,
-        subtract: (left, right) => left.minus(right),
+        sum: wrapReducerFn(num.add),
+        min: wrapReducerFn((left, right) => (num.compare(left, right) < 0 ? left : right)),
+        max: wrapReducerFn((left, right) => (num.compare(left, right) < 0 ? right : left)),
+        add: wrapBinaryFn(num.add),
+        subtract: wrapBinaryFn(num.sub),
         multiply: (left, right) => left.times(right),
         divide: (left, right) => left.over(right),
         prefix: (prefix, multiplier) => {
@@ -59,12 +56,3 @@ export const getGenericMeasureStaticMethods = <N>(): GenericMeasureStatic<N> =>
         },
     };
 };
-
-export function reduce<N>(
-    fn: <Basis, U extends Unit<Basis>>(
-        left: GenericMeasure<N, Basis, U>,
-        right: GenericMeasure<N, Basis, U>,
-    ) => GenericMeasure<N, any, U>,
-): SpreadFn<N> {
-    return (first, ...rest) => rest.reduce(fn, first);
-}

src/unit/__test__/trigTests.ts

@@ -1,14 +1,14 @@
 import { Measure } from "../../measure/numberMeasure";
 import { degrees, piRadians } from "../angle";
-import { MetricSystem, meters, radians } from "../base";
+import { SIUnitSystem, meters, radians } from "../base";
 import * as Trig from "../trig";
 
 describe("Trig", () => {
     const zeroRadians = Measure.of(0, radians);
-    const zero = Measure.dimensionless(MetricSystem, 0);
+    const zero = Measure.dimensionless(SIUnitSystem, 0);
 
     it("normal", () => {
-        expect(Trig.cos(zeroRadians)).toEqual(Measure.dimensionless(MetricSystem, 1));
+        expect(Trig.cos(zeroRadians)).toEqual(Measure.dimensionless(SIUnitSystem, 1));
         expect(Trig.sin(zeroRadians)).toEqual(zero);
         expect(Trig.tan(zeroRadians)).toEqual(zero);
     });

src/unit/base.ts

@@ -2,7 +2,7 @@ import { GenericMeasureType } from "../measure";
 import { Measure } from "../measure/numberMeasure";
 import { UnitSystem } from "../measure/unitSystem";
 
-const MetricSystemBasis = {
+const SIUnitSystemBasis = {
     length: "m",
     mass: "kg",
     time: "s",
@@ -15,23 +15,23 @@ const MetricSystemBasis = {
     memory: "b",
 } as const;
 
-type MetricSystemBasis = typeof MetricSystemBasis;
+type SIUnitSystemBasis = typeof SIUnitSystemBasis;
 
-export interface MetricSystem extends MetricSystemBasis {}
+export interface SIUnitSystem extends SIUnitSystemBasis {}
 
-export const MetricSystem = UnitSystem.from<MetricSystem>(MetricSystemBasis);
+export const SIUnitSystem = UnitSystem.from<SIUnitSystem>(SIUnitSystemBasis);
 
 export const createSIBaseUnits = <N>(measure: GenericMeasureType<N, any>) => ({
-    meters: measure.dimension(MetricSystem, "length"),
-    kilograms: measure.dimension(MetricSystem, "mass"),
-    seconds: measure.dimension(MetricSystem, "time"),
-    amperes: measure.dimension(MetricSystem, "current"),
-    kelvin: measure.dimension(MetricSystem, "temperature"),
-    moles: measure.dimension(MetricSystem, "substance"),
-    candelas: measure.dimension(MetricSystem, "intensity"),
-    radians: measure.dimension(MetricSystem, "planeAngle"),
-    steradians: measure.dimension(MetricSystem, "solidAngle"),
-    bits: measure.dimension(MetricSystem, "memory"),
+    meters: measure.dimension(SIUnitSystem, "length"),
+    kilograms: measure.dimension(SIUnitSystem, "mass"),
+    seconds: measure.dimension(SIUnitSystem, "time"),
+    amperes: measure.dimension(SIUnitSystem, "current"),
+    kelvin: measure.dimension(SIUnitSystem, "temperature"),
+    moles: measure.dimension(SIUnitSystem, "substance"),
+    candelas: measure.dimension(SIUnitSystem, "intensity"),
+    radians: measure.dimension(SIUnitSystem, "planeAngle"),
+    steradians: measure.dimension(SIUnitSystem, "solidAngle"),
+    bits: measure.dimension(SIUnitSystem, "memory"),
 });
 
 export const { meters, kilograms, seconds, amperes, kelvin, moles, candelas, radians, steradians, bits } =

src/unit/quantities.ts

@@ -1,57 +1,69 @@
 import { GenericMeasure, LiftMeasure } from "../measure/genericMeasure";
 import { Measure } from "../measure/numberMeasure";
 import { DimensionlessUnit } from "../measure/unitTypeArithmetic";
-import * as Base from "./base";
+import {
+    amperes,
+    bits,
+    candelas,
+    kelvin,
+    kilograms,
+    meters,
+    moles,
+    radians,
+    seconds,
+    SIUnitSystem,
+    steradians,
+} from "./base";
 
 // Dimensionless
 
 /** A measure without any unit */
-export type Dimensionless<N = number> = GenericMeasure<N, Base.MetricSystem, DimensionlessUnit<Base.MetricSystem>>;
-export const Dimensionless: Dimensionless = Measure.dimensionless(Base.MetricSystem, 1);
+export type Dimensionless<N = number> = GenericMeasure<N, SIUnitSystem, DimensionlessUnit<SIUnitSystem>>;
+export const Dimensionless: Dimensionless = Measure.dimensionless(SIUnitSystem, 1);
 
 // Base units
 
 /** meters */
-export type Length<N = number> = LiftMeasure<typeof Base.meters, N>;
-export const Length: Length = Base.meters;
+export type Length<N = number> = LiftMeasure<typeof meters, N>;
+export const Length: Length = meters;
 
 /** kilograms */
-export type Mass<N = number> = LiftMeasure<typeof Base.kilograms, N>;
-export const Mass: Mass = Base.kilograms;
+export type Mass<N = number> = LiftMeasure<typeof kilograms, N>;
+export const Mass: Mass = kilograms;
 
 /** seconds */
-export type Time<N = number> = LiftMeasure<typeof Base.seconds, N>;
-export const Time: Time = Base.seconds;
+export type Time<N = number> = LiftMeasure<typeof seconds, N>;
+export const Time: Time = seconds;
 
 /** Amperes */
-export type ElectricCurrent<N = number> = LiftMeasure<typeof Base.amperes, N>;
-export const ElectricCurrent: ElectricCurrent = Base.amperes;
+export type ElectricCurrent<N = number> = LiftMeasure<typeof amperes, N>;
+export const ElectricCurrent: ElectricCurrent = amperes;
 
 /** Kelvin */
-export type Temperature<N = number> = LiftMeasure<typeof Base.kelvin, N>;
-export const Temperature: Temperature = Base.kelvin;
+export type Temperature<N = number> = LiftMeasure<typeof kelvin, N>;
+export const Temperature: Temperature = kelvin;
 
 /** moles */
-export type AmountOfSubstance<N = number> = LiftMeasure<typeof Base.moles, N>;
-export const AmountOfSubstance: AmountOfSubstance = Base.moles;
+export type AmountOfSubstance<N = number> = LiftMeasure<typeof moles, N>;
+export const AmountOfSubstance: AmountOfSubstance = moles;
 
 /** candelas */
-export type LuminousIntensity<N = number> = LiftMeasure<typeof Base.candelas, N>;
-export const LuminousIntensity: LuminousIntensity = Base.candelas;
+export type LuminousIntensity<N = number> = LiftMeasure<typeof candelas, N>;
+export const LuminousIntensity: LuminousIntensity = candelas;
 
 /** bits */
-export type Memory<N = number> = LiftMeasure<typeof Base.bits, N>;
-export const Memory: Memory = Base.bits;
+export type Memory<N = number> = LiftMeasure<typeof bits, N>;
+export const Memory: Memory = bits;
 
 // Angular base units
 
 /** radians */
-export type PlaneAngle<N = number> = LiftMeasure<typeof Base.radians, N>;
-export const PlaneAngle: PlaneAngle = Base.radians;
+export type PlaneAngle<N = number> = LiftMeasure<typeof radians, N>;
+export const PlaneAngle: PlaneAngle = radians;
 
 /** steradians */
-export type SolidAngle<N = number> = LiftMeasure<typeof Base.steradians, N>;
-export const SolidAngle: SolidAngle = Base.steradians;
+export type SolidAngle<N = number> = LiftMeasure<typeof steradians, N>;
+export const SolidAngle: SolidAngle = steradians;
 
 // Derived units
 

src/unit/trig.ts

@@ -1,7 +1,7 @@
 import { GenericMeasure } from "../measure/genericMeasure";
 import { Measure } from "../measure/numberMeasure";
 import { DimensionlessUnit } from "../measure/unitTypeArithmetic";
-import { MetricSystem, radians } from "./base";
+import { SIUnitSystem, radians } from "./base";
 import { Length, PlaneAngle } from "./quantities";
 
 /**
@@ -56,10 +56,10 @@ export function atan2(y: Length, x: Length): PlaneAngle {
     return Measure.of(Math.atan2(y.value, x.value), radians);
 }
 
-type Dimensionless = GenericMeasure<number, MetricSystem, DimensionlessUnit<MetricSystem>>;
+type Dimensionless = GenericMeasure<number, SIUnitSystem, DimensionlessUnit<SIUnitSystem>>;
 
 function wrapTrigFn(f: (x: number) => number): (angle: PlaneAngle) => Dimensionless {
-    return angle => Measure.dimensionless(MetricSystem, f(angle.value));
+    return angle => Measure.dimensionless(SIUnitSystem, f(angle.value));
 }
 
 function wrapInverseTrigFn(f: (x: number) => number): (angle: Dimensionless) => PlaneAngle {