Merge pull request #1 from spexy11/main

quantity reviewd

Author: khoi-nguyen

packages/core/src/expr.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'bun:test'
 
-import { expr } from './expr'
+import { expr, quantity } from './expr'
 
 type Test<T = any> = {
   desc: string
@@ -200,6 +200,47 @@ test.each<Test>([
     promise: expr('x^2').subs({ x: 'y' }).latex(),
     result: 'y^{2}',
   }),
+  define({
+    desc: 'subs: x^2, x -> y',
+    promise: expr('x^2').subs({ x: 'y' }).latex(),
+    result: 'y^{2}',
+  }),
+
+  define({
+    desc: 'isEqual with error: 1.005kg equals 1kg ± 0.01kg',
+    promise: quantity('1.005\\mathrm{kg}').isEqual('1\\mathrm{kg}', '0.01\\mathrm{kg}'),
+    result: true,
+  }),
+  define({
+    desc: 'isEqual with error: 1.02kg does not equal 1kg ± 0.01kg',
+    promise: quantity('1.02\\mathrm{kg}').isEqual('1\\mathrm{kg}', '0.01\\mathrm{kg}'),
+    result: false,
+  }),
+  define({
+    desc: 'isEqual with error: 9.85 m/s² equals 9.8 m/s² ± 0.1 m/s²',
+    promise: quantity('9.85\\mathrm{m/s^2}').isEqual('9.8\\mathrm{m/s^2}', '0.1\\mathrm{m/s^2}'),
+    result: true,
+  }),
+  define({
+    desc: 'isEqual with error: 1050g equals 1kg ± 100g',
+    promise: quantity('1050\\mathrm{g}').isEqual('1\\mathrm{kg}', '100\\mathrm{g}'),
+    result: true,
+  }),
+  define({
+    desc: 'isEqual with error: 1200g does not equal 1kg ± 100g',
+    promise: quantity('1200\\mathrm{g}').isEqual('1\\mathrm{kg}', '100\\mathrm{g}'),
+    result: false,
+  }),
+  define({
+    desc: 'isEqual with error: 101400 Pa equals 101325 Pa ± 100 Pa',
+    promise: quantity('101400\\mathrm{Pa}').isEqual('101325\\mathrm{Pa}', '100\\mathrm{Pa}'),
+    result: true,
+  }),
+  define({
+    desc: 'isEqual with error: 101600 Pa does not equal 101325 Pa ± 100 Pa',
+    promise: quantity('101600\\mathrm{Pa}').isEqual('101325\\mathrm{Pa}', '100\\mathrm{Pa}'),
+    result: false,
+  }),
 ])('$desc', async ({ promise, result }) => {
   expect(await promise).toEqual(result)
 })

packages/core/src/expr.ts

@@ -1,6 +1,5 @@
+import { type ExpressionInput, ComputeEngine, N } from '@cortex-js/compute-engine'
 import * as v from 'valibot'
-
-import { type MathJsonExpression, ComputeEngine } from '@cortex-js/compute-engine'
 import symapi from './symapi'
 
 const ce = new ComputeEngine()
@@ -17,7 +16,7 @@ const integrateParams = v.union([
   ),
 ])
 
-const Math: v.GenericSchema<MathJsonExpression> = v.union([
+const Math: v.GenericSchema<ExpressionInput> = v.union([
   v.pipe(
     v.string(),
     v.check((expr) => ce.parse(expr).isValid, "Ceci n'est pas une expression mathématique valide"),
@@ -57,21 +56,23 @@ function _expr(input: Math) {
     degree: () => symapi.expr.degree({ expr: json }),
     diff: (x = 'x') => expr(['Derivative', json, x]),
     expand: () => expr(['Expand', json]),
+    evaluate: () => ce.expr(json).evaluate(),
+    N: () => N(expr(json).evaluate()) as unknown as number,
     factor: () => expr(['Factor', json]),
     func: () => {
       if (!Array.isArray(json)) throw new Error(`Only arrays have the property func`)
       return json[0] as string
     },
     integrate: (...params: v.InferInput<typeof integrateParams>) =>
       expr(['Integrate', json, ...v.parse(integrateParams, params)]),
-    isEqual: (expr: Expression) =>
-      symapi.expr.equal({ expr1: json, expr2: v.parse(Expression, expr) }),
+    isEqual: (other: Expression) =>
+      symapi.expr.equal({ expr1: json, expr2: v.parse(Expression, other) }),
     isFactored: () => symapi.expr.isFactored({ expr: json }),
     isPartialFractionDecomposition: () =>
       symapi.expr.isPartialFractionDecomposition({ expr: json }),
     latex: () => symapi.expr.latex({ expr: json }),
-    matches: (expr: Expression) =>
-      symapi.expr.match({ expr1: json, expr2: v.parse(Expression, expr) }),
+    matches: (other: Expression) =>
+      symapi.expr.match({ expr1: json, expr2: v.parse(Expression, other) }),
     roots: (complex = false) => symapi.expr.roots({ expr: json, complex }),
     simplify: () => expr(['Simplify', json]),
     subs: (substitutions: Record<string, Math>) => expr(ce.expr(json).subs(substitutions).json),
@@ -84,3 +85,42 @@ export function expr<T extends Math | undefined>(
   if (input === undefined) return undefined as any
   return _expr(input) as any
 }
+
+const Quantity = v.union([
+  Math,
+  v.pipe(
+    v.tuple([Math, Math]),
+    v.transform((quantity) => ce.expr(['Quantity', ...quantity]).evaluate()),
+  ),
+])
+type Quantity = v.InferInput<typeof Quantity>
+
+export function quantity(qty: Quantity) {
+  const json = v.parse(Quantity, qty)
+
+  function apply(method: string, ...args: ExpressionInput[]) {
+    return ce.expr([method, ...args]).evaluate()
+  }
+
+  return {
+    convert: (rawUnit: Quantity) => {
+      const unit = v.parse(Quantity, rawUnit)
+      return quantity(apply('UnitConvert', json, unit).json)
+    },
+    magnitude: () => expr(apply('QuantityMagnitude', json).json),
+    subtract: (rawOther: Quantity) => {
+      const other = v.parse(Quantity, rawOther)
+      return quantity(apply('Subtract', json, other).json)
+    },
+    unit: () => apply('QuantityUnit', json).latex,
+    json,
+
+    async isEqual(rawExpr2: Quantity, rawError?: Quantity) {
+      const expr2 = v.parse(Quantity, rawExpr2)
+      const error = rawError ? v.parse(Quantity, rawError) : undefined
+      if (!error) return this.subtract(expr2).magnitude().isEqual(0)
+      const diff = this.subtract(expr2).convert(error).magnitude().abs().N()
+      return diff < quantity(error).magnitude().abs().N()
+    },
+  }
+}