tpmkms_4wp 9.5.1 → 9.6.0

package/common/dimension.js

@@ -1,5 +1,5 @@
-const { knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
-const { defaultObjectCheck, defaultContextCheck } = require('./helpers')
+const { debug, knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
+const { defaultObjectCheck, defaultContextCheck, defaultContextCheckProperties } = require('./helpers')
 const hierarchy = require('./hierarchy.js')
 const formulas = require('./formulas.js')
 const testing = require('./testing.js')
@@ -11,6 +11,14 @@ const instance = require('./dimension.instance.json')
   x fahrenheit equals (x-32)*5/9 + 32 fahrenheit
   10 celcius + 5
 
+  1 meter 10 centimeters
+
+  1 meter in feet and inches
+  10 feet in meters and inches
+
+  show length in feet and inches
+  show length in meters and millimeters
+
   10 C
 
   use a digraph for calculating convertions
@@ -24,8 +32,21 @@ const instance = require('./dimension.instance.json')
 */
 class API {
 
-  initialize({ config }) {
+  initialize({ config, objects }) {
     this._config = config
+    this._objects = objects
+  }
+
+  setMeasurementSystem(measurementSystem) {
+    this._objects.measurementSystem = measurementSystem
+  }
+
+  // if the user says 2 feet deduce english etc
+  deduceMeasurementSystem(utterance) {
+  }
+
+  getMeasurementSystem() {
+    return this._objects.measurementSystem
   }
 
   setup( {dimension, units} ) {
@@ -50,27 +71,26 @@ class API {
   }
 }
 
-const api = new API()
+// eg, dimension == length; meters == unit; 2 meters == quantity
 
 const config = {
   name: 'dimension',
   operators: [
-    "([dimension])",
+    "([quantity])",
     "([unit])",
-    // "(([unit]) [kindOfDimension|of] ([dimension]))",
-    "((amount/1 || number/1) [amountOfDimension|] ([unit]))",
+    "((amount/* || number/*) [amountOfCoordinate|] ([unit]))",
     "(([amount]) [unit])",
-    "((dimension) [convertToUnits|in] (unit))",
+    "((@<=quantity || context.possession == true) [convertToUnits|in] (unit))",
 
     "(([number]) [degree])",
-    { pattern: "([length])", development: true },
+    { pattern: "([length])", scope: "testing" },
   ],
   priorities: [
     // TODO this should have been calculated
-    { "context": [['amountOfDimension', 0], ['convertToUnits', 0], ], "choose": [0] },
+    { "context": [['amountOfCoordinate', 0], ['convertToUnits', 0], ], "choose": [0] },
   ],
   hierarchy: [
-    { child: 'convertToUnits', parent: 'testingValue', development: true },
+    { child: 'convertToUnits', parent: 'testingValue', scope: "testing" },
   ],
   generators: [
     {
@@ -83,29 +103,21 @@ const config = {
     { 
       where: where(),
       id: "dimension", 
+    },
+    { 
+      where: where(),
+      id: "quantity", 
+      isA: ["noun"],
       bridge: "{ ...next(operator) }",
-      isA: [],
-      generatorpr: {
-        match: ({context}) => context.amount,
-        apply: async ({context, gp, gr}) => `${await gr(context.amount)} ${await gp(context.unit)}`,
-      },
+      generatorpr: async ({context, gp, gr}) => `${await gr(context.amount)} ${await gp(context.unit)}`,
     },
     { 
       id: "length", 
       isA: ['dimension'], 
       bridge: "{ ...next(operator) }",
-      development: true 
+      scope: "testing" 
     },
     { id: "amount", },
-    /*
-    { 
-      id: "kindOfDimension", 
-      bridge: "{ ...next(operator), subclass: before[0], class: after[0], value: concat(before[0].marker.id, after[0].marker.id) }",
-      // bridge: "{ ...next(operator), subclass: before[0], class: after[0], value: concat(before[0].marker, after[0].marker) }",
-      isA: ['preposition'],
-      generatorp: ({context, gp}) => `${gp(context.subclass)} ${context.word} ${gp(context.class)}`,
-    },
-    */
     { 
       where: where(),
       id: "degree", 
@@ -115,9 +127,9 @@ const config = {
       bridge: "{ ...next(operator), value: before[0].value, amount: before[0] }",
     },
     { 
-      id: "amountOfDimension", 
+      id: "amountOfCoordinate", 
       convolution: true, 
-      bridge: "{ marker: operator('dimension'), unit: after[0], value: before[0].value, amount: before[0] }" 
+      bridge: "{ marker: next(operator('quantity')), dead: true, unit: after[0], value: before[0].value, amount: before[0] }" 
     },
     { 
       where: where(),
@@ -128,31 +140,53 @@ const config = {
       after: [['possession', 0], ['possession', 1]],
       generatorp: async ({context, g}) => `${await g(context.from)} ${context.word} ${await g(context.to)}`,
       // evaluator: ({context, kms, error}) => {
-      evaluator: async ({context, kms, e, error}) => {
-        /*
-        error(({context, e}) => {
-          context.evalue = 'dont know...'
-        })
-        */
+      evaluator: async ({context, kms, e, error, toArray, gp, gr, toList}) => {
         const from = context.from;
-        const to = context.to;
+        const tos = toArray(context.to);
         let evalue;
         let efrom = from
         if (!from.unit) {
           efrom = (await e(from)).evalue
         }
-        if (to.value == efrom.unit.value) {
-          evalue = efrom.amount
-        } else {
-          const formula = kms.formulas.api.get(to, [efrom.unit])
-          if (!formula) {
-            const reason = { marker: 'reason', focusableForPhrase: true, evalue: { marker: 'noconversion', from: efrom.unit, to } }
-            kms.stm.api.mentioned({ context: reason })
-            error(reason)
+        async function convert(to) {
+          if (to.value == efrom.unit.value) {
+            evalue = efrom.amount
+            evalue.evalue = efrom.amount.value
+          } else {
+            const formula = kms.formulas.api.get(to, [efrom.unit])
+            if (!formula) {
+              const reason = { marker: 'reason', focusableForPhrase: true, evalue: { marker: 'noconversion', from: efrom.unit, to } }
+              kms.stm.api.mentioned({ context: reason })
+              error(reason)
+            }
+            kms.stm.api.setVariable(efrom.unit.value, efrom.amount)
+            evalue = await e(formula)
           }
-          kms.stm.api.setVariable(efrom.unit.value, efrom.amount)
-          evalue = await e(formula)
+          return evalue
+        }
+
+        let evalues = []
+        for (const to of tos) {
+          evalues.push({ value: await convert(to), to: structuredClone(to) })
+        }
+        evalues.sort((a, b) => a.evalue - b.evalue )
+
+        let fractionalPart = 0
+        let scale = 1
+        for (const evalue of evalues) {
+          const value = evalue.value.evalue * scale
+          const integerPart = Math.trunc(value)
+          fractionalPart = Math.abs(value - integerPart)
+          evalue.value.evalue = integerPart
+          scale = fractionalPart / value * scale
         }
+        // evalues[evalues.length-1].value.evalue = Number((integerPart * (1+scale)).toFixed(4))
+        evalues[evalues.length-1].value.evalue += fractionalPart
+        evalues[evalues.length-1].value.evalue = Number(evalues[evalues.length-1].value.evalue.toFixed(4))
+
+        // remove the zeros
+        evalues = evalues.filter( (evalue) => evalue.value.evalue )
+
         /*
         '{
             "marker":"dimension",
@@ -161,12 +195,21 @@ const config = {
             "amount":{"word":"degrees","number":"many","text":"10 degrees","marker":"degree","range":{"start":8,"end":17},"value":10,"amount":{"value":10,"text":"10","marker":"number","word":"10","range":{"start":8,"end":9},"types":["number"]}},
               "text":"10 degrees celcius","range":{"start":8,"end":25}}'
         */
-        context.evalue = { 
-          paraphrase: true,
-          marker: 'dimension',
-          level: 1,
-          unit: to,
-          amount: { evalue, paraphrase: undefined }
+        evalues = evalues.map((evalue) => {
+          const number = evalue.value.evalue == 1 ? 'one' : 'many'
+          evalue.to.number = number
+          return { 
+            paraphrase: true,
+            marker: 'quantity',
+            level: 1,
+            unit: evalue.to,
+            amount: { evalue: evalue.value, paraphrase: undefined }
+          }
+        })
+        if (evalues.length > 1) {
+          context.evalue = toList(evalues)
+        } else {
+          context.evalue = evalues[0]
         }
       },
     },
@@ -179,8 +222,49 @@ const config = {
 
 const template = {
   configs: [
-    "dimension and unit are concepts",
+    "measurement modifies unit",
+    "dimension and measurement unit are concepts",
+    "unit means measurement unit",
+    ({apis}) => {
+      apis('properties').addHierarchyWatcher({
+        match: ({parentId, isA}) => isA(parentId, 'unit') && parentId.startsWith('unit_'),
+        apply: ({config, childId, parent, parentId}) => {
+          config.updateBridge(childId, ({ bridge }) => {
+            if (!bridge.init) {
+              bridge.init = {}
+            }
+            // bridge.init['dimension'] = parent.object.marker
+            bridge.init['dimension'] = parent.object.value
+          })
+        }
+      })
+    },
+    "metric modifies system",
+    "imperial modifies system",
+    "measurement modifies system",
+    "the metric system is a measurement system",
+    "the imperial system is a measurement system",
+    "imperial modifies unit",
+    "metric modifies unit",
+    "imperial unit is a unit",
+    "metric unit is a unit",
     config,
+    {
+      operators: [
+        "([useMeasurementSystem|use] (measurement_system))",
+      ],
+      bridges: [
+        {
+          id: 'useMeasurementSystem',
+          isA: ['verb'],
+          bridge: "{ ...next(operator), system: after[0], interpolate: [ { context: operator }, { property: 'system' } ] }",
+          semantic: ({context, api}) => {
+            api.setMeasurementSystem(context.system.value)
+          },
+          check: defaultContextCheckProperties(['system']),
+        },
+      ],
+    },
   ],
 }
 
@@ -196,9 +280,19 @@ knowledgeModule({
     name: './dimension.test.json',
     contents: tests,
     checks: {
-      objects: [{ km: 'properties' }],
+      objects: [
+        { km: 'properties' },
+        { path: ['measurementSystem'] },
+      ],
       context: [
-        defaultContextCheck(),
+        defaultContextCheck({ marker: 'metric_system', exported: true }),
+        defaultContextCheck({ marker: 'convertToUnits', exported: true, extra: ['from', 'to'] }),
+        defaultContextCheck({ 
+          match: ({context, isA}) => isA(context.marker, 'unit'), 
+          exported: true, 
+          extra: ['dimension'],
+        }),
+        // defaultContextCheck(['dimension', 'response']),
       ],
     },
   },