tpmkms/common/rates.js

Reusable libraries for Entodicton, a natural language to json converter

const { knowledgeModule, where, Digraph, debug } = require('./runtime').theprogrammablemind
const { defaultContextCheck, toEValue, toFinalValue } = require('./helpers')
const dimension = require('./dimension.js')
const length = require('./length.js')
const time = require('./time.js')
const rates_tests = require('./rates.test.json')
const instance = require('./rates.instance.json')

/*
  miles per hour

  TODO 2 meters every 3 minutes
*/

const template = {
  configs: [
    {
      operators: [
        // "((mile) [unitPerUnit|per] (hour))", 
        "((context.dimension != undefined) [unitPerUnit|per] (context.dimension != undefined))", 
      ],
      bridges: [
        {
          id: 'unitPerUnit',
          before: ['amountOfCoordinate'],
          isA: ['unit'],
          bridge: `{ 
            ...operator, 
            numerator: before[0], 
            denominator: after[0],
            interpolate: [{ property: 'numerator', context: { number: 'many' } }, { context: operator }, { property: 'denominator' }] 
          }`,
          "enhanced_associations": true,
        },
      ],
      semantics: [
        {
          where: where(),
          match: ({context}) => context.marker == 'convertToUnits' && context.evaluate && (context.from?.unit?.marker == 'unitPerUnit' || context.to.marker == 'unitPerUnit'),
          apply: async ({remember, context, kms, e, callId, resolveEvaluate, toEValue, error}) => {

            async function convert(fromUnits, fromAmount, toUnits) {
              let evalue;
              if (toUnits.value == fromUnits.value) {
                evalue = fromAmount
                // if (!fromAmount.value) {
                //  debugger
                //}
                evalue.evalue = fromAmount.evalue || fromAmount.value
              } else {
                const formula = kms.formulas.api.get(toUnits, [fromUnits])
                if (!formula) {
                  const reason = { marker: 'reason', focusableForPhrase: true, evalue: { marker: 'noconversion', from: fromUnits, to: toUnits } }
                  kms.stm.api.remember({ context: reason })
                  error(reason)
                }
                kms.stm.api.setVariable(fromUnits.value, fromAmount)
                evalue = await e(formula)
              }
              return evalue
            }

            if (!context.from.unit) {
              resolveEvaluate(context.from, await e(context.from))
            }


            const from = toEValue(context.from)
            remember(context.to)
            const evalueNumerator = await convert(from.unit.numerator, from.amount, context.to.numerator)
            const evalueDenominator = await convert(from.unit.denominator, 1, context.to.denominator)
            const evalue = { evalue: (toFinalValue(evalueNumerator) || evalueNumerator.value) / (toFinalValue(evalueDenominator) || evalueDenominator.evalue) }
            context.evalue = {
              paraphrase: true,
              marker: 'quantity',
              level: 1,
              unit: context.to,
              amount: { evalue, paraphrase: undefined }
            }
          },
        },
      ]
    },
  ],
}

knowledgeModule({ 
  config: { name: 'rates' },
  includes: [dimension, length, time],

  module,
  description: 'Length dimension',
  test: {
    name: './rates.test.json',
    contents: rates_tests,
    checks: {
      objects: [
        { km: 'dimension' },
        { km: 'stm' },
      ],
      context: [
        defaultContextCheck({ marker: 'unitPerUnit', exported: true, extra: ['numerator', 'denominator'] }),
        defaultContextCheck()
      ],
    }
  },
  instance,
  template,
})