How do you use math.add in a factory 'add' function?

[christianpetty]

Hello! I have a custom datatype Dim that is a nominal +/- a tolerance (supports numbers, Unit, etc.). I then have a factory function for adding these types.

export const createDim = factory('Dim', ['typed', 'typeOf'], ({ typed, typeOf }) => {
  function Dim (nominal, tolerance) {
    if (typeOf(nominal) !== typeOf(tolerance)) {
      throw new Error('Both nominal and tolerance must be of the same type: either numbers or instances of Unit');
    }
    this.nominal = nominal
    this.tolerance = tolerance
  }
  Dim.prototype.isDim = true
  Dim.prototype.toString = function () {
    return `${this.nominal} ± ${this.tolerance}`
  }

  typed.addType({
    name: 'Dim',
    test: function (x) {
      return x && x.isDim === true
    }
  })
  return Dim
})

export const createAddDim = factory('add', ['typed', 'Dim'], ({ typed, Dim, add }) => {
  return typed('add', {
    'Dim, Dim': function (a, b) {
      return new Dim(add(a.nominal, b.nominal), add(a.tolerance, b.tolerance))
    }
  })
})

Currently this only works if I also import math into this js file. Because the two properties of Dim are also math types, I have to use math.add to add them. I thought I could inject 'add' into the typed function, but maybe there's a conflict there.

Do I need to import math here, or is there another option to make math.add available inside the function?

[dvd101x]

Hi, you might be missing an add in your createAddDim

Try this

export const createAddDim = factory('add', ['typed', 'Dim', 'add'], ({ typed, Dim, add }) => {

[christianpetty]

Hi! I had that in there but I get this error: Maximum call stack size exceeded

Here's the expression for reference: dim(3 in, 0.1 in) + dim(3 in, 0.2 in)

[dvd101x]

I just read Jos's answer so I'd go with that. I'm leaving this comment just in case.

It seems that your createAddDim is trying to replace the default add and because the factory function imports add it might might loop indefinitely.

If what you need is to include the type of Dim to the function add you might need to instead import your typed function. Something like

import({
    add: typed('add', {
        'Dim, Dim': function (a, b) {
            return new Dim(add(a.nominal, b.nominal), add(a.tolerance, b.tolerance))
        }
    })
})

Reference: https://mathjs.org/docs/core/extension.html#typed-functions

If you are creating a new function called addDim then I guess the issue is the name should be addDim instead of add both in the factory function and the typed function.

[christianpetty]

I think the crux is that I need to use math.add inside createAddDim. Is that possible?

I'm trying to keep all custom functions and datatypes in a separate file, so I'm trying to avoid importing math twice. This all works if I just use math.add instead of add in the return line, but then this function becomes dependent on a math instance.

[dvd101x]

You can use math.add inside createAddDim, but I think the conflict is the name you are using is causing a circular reference as the name of the created function is the name of one of the dependencias.

Could you try a different name and test if addDim works as expected?

export const createAddDim = factory('addDim', ['typed', 'Dim', 'add'], ({ typed, Dim, add }) => {
    return typed('addDim', {
        'Dim, Dim': function (a, b) {
            return new Dim(add(a.nominal, b.nominal), add(a.tolerance, b.tolerance))
        }
    })
})

[christianpetty]

That works if I evaluate addDim(dim(3 in, 0.1 in), dim(3 in, 0.2 in)), but I'd like to overrride 'add' for 'Dim' to allow for:

dim(3 in, 0.1 in) + dim(3 in, 0.2 in)

[christianpetty]

Maybe there is a different way to add Units together to avoid the conflict?

[dvd101x]

I think what's left is at the end to import addDim to the function add for the signatures of your new type.

import({
    add: typed('add', {
        'Dim, Dim': addDim
    })
})

So add would work for the default cases and also for your new signature.

[christianpetty]

Seems like I can only use "typed" inside a factory function. Were you thinking this could be in that same closure?

[josdejong]

You can use typed.referToSelf there (there are examples of that in the mathjs code base). It will look something like:

export const createAddDim = factory('add', ['typed', 'Dim'], ({ typed, Dim }) => {
  return typed('add', {
    'Dim, Dim': typed.referToSelf(self => (a, b) => {
      return new Dim(self(a.nominal, b.nominal), self(a.tolerance, b.tolerance))
    })
  })
})

There is also an typed.referTo that you can use if you know the exact signature that you need (like adding two numbers), that will be faster.

EDIT: in the example there where two occurrences of add(...), that should be self(...). Fixed now

[christianpetty]

Answered my own question. That's a slick solution!

[josdejong]

😄

[christianpetty]

Is it possible to do multiple override with different type pairs?

import { factory } from "mathjs";

export const createMultiplyDim = factory(
  "multiply",
  ["typed", "Dim", "add"],
  ({ typed, Dim, add }) => {
    return typed("multiply", {
      "Dim, Dim": typed.referToSelf(
        (self) =>
          function (a, b) {
            return new Dim(
              self(a.nominal, b.nominal),
              add(self(a.nominal, b.tolerance), self(b.nominal, a.tolerance))
            );
          }
      ),
    });
  }
);

export const createMultiplyScalarDim = factory(
  "multiply",
  ["typed", "Dim"],
  ({ typed, Dim }) => {
    return typed("multiply", {
      "Dim, number": typed.referTo(
        "Dim, number",
        (self) =>
          function (a, b) {
            return new Dim(self(a.nominal, b), self(a.tolerance, b));
          }
      ),
    });
  }
);

I get the error Cannot import "multiply" twice.

Also you mentioned the typed.referTo function. Is that how you would implement that, and how is it different again?

[christianpetty]

Nevermind on the multiple overrides. Figured that out:

import { factory } from "mathjs";

export const createMultiplyDim = factory(
  "multiply",
  ["typed", "Dim", "add"],
  ({ typed, Dim, add }) => {
    return typed("multiply", {
      "Dim, Dim": typed.referToSelf(
        (self) =>
          function (a, b) {
            return new Dim(
              self(a.nominal, b.nominal),
              add(self(a.nominal, b.tolerance), self(b.nominal, a.tolerance))
            );
          }
      ),

      "Dim, number": typed.referToSelf(
        (self) =>
          function (dim, number) {
            return new Dim(
              self(dim.nominal, number),
              self(dim.tolerance, number)
            );
          }
      ),

      "number, Dim": typed.referToSelf(
        (self) =>
          function (number, dim) {
            return new Dim(
              self(dim.nominal, number),
              self(dim.tolerance, number)
            );
          }
      ),
    });
  }
);

Still curious about how referTo is affecting performance.

[josdejong]

Is it possible to do multiple override with different type pairs?

That should indeed work as long as both function implementations are typed functions, and they do not have duplicate signatures (like demonstrated here, extending a function with a new signature: #3129 (comment)).

Still curious about how referTo is affecting performance.

I think there is no need to worry there, but if you really want to know you'll have to set up a little benchmark for yourself and try out with and without referTo.

[christianpetty]

For future viewers:

evaluator.js:

import { create, all } from "mathjs"
import * as dimsum from "./dimsum"

math.import([
  dimsum.createDim, 
  dimsum.createAddDim
  ...
])

math.import({
  add: math.typed('add', {
      'Dim, Dim': math.addDim
  })
})

dimsum.js:

import { factory } from 'mathjs'

export const createDim = factory('Dim', ['typed', 'typeOf'], ({ typed, typeOf }) => {
  function Dim (nominal, tolerance) {
    if (typeOf(nominal) !== typeOf(tolerance)) {
      throw new Error('Both nominal and tolerance must be of the same type: either numbers or instances of Unit');
    }
    this.nominal = nominal
    this.tolerance = tolerance
  }
  Dim.prototype.isDim = true
  Dim.prototype.toString = function () {
    return `${this.nominal} ± ${this.tolerance}`
  }

  typed.addType({
    name: 'Dim',
    test: function (x) {
      return x && x.isDim === true
    }
  })
  return Dim
})

export const createAddDim = factory('addDim', ['typed', 'Dim', 'add'], ({ typed, Dim, add }) => {
  return typed('addDim', {
    'Dim, Dim': function (a, b) {
      return new Dim(add(a.nominal, b.nominal), add(a.tolerance, b.tolerance))
    }
  })
})

[dvd101x]

I'm glad it worked, here are a few ideas

Probably in evaluator.js could be simplified as addDim was already typed.

math.import({
  add: math.addDim
  })

Also if you won't be needing to use addDim by itself you could skip it's import to math and do directly something like:

math.import({
  add: dimsum.createAddDim()
  })

[christianpetty]

Exactly what I need. Serious thank you to y’all! MathJS has been indispensable for the work I do and there’s nothing comparable in any other language I’ve found.