Support units in function round

[stoplion]

Is there a way to make units work with functions?
round(2.70 inches)
errors out.

[josdejong]

Units do work with a lot of functions, but is not supported with round.

We can consider adding support for units in round It can lead to ambiguous situations, like what would you expect as output for round(2.5 cm + 10.5 mm) ? Would that round to 3 cm or to 31 mm?

It could work if we pass an additional argument to round to specify in which unit we would like to round, like round(2.5 cm + 10.5 mm, cm).

[joshhansen]

Would it be feasible to support rounding of Unit instances? They could be rounded and kept in the same units. Then there's no ambiguity such as with 2.5 cm + 10.5 mm---the caller would have to resolve the ambiguity before passing it in to round.

[josdejong]

@joshhansen I'm not sure whether I understand you, so how would the caller resolve ambiguity?

[mofosyne]

I think what he is saying is that round() would accept only a single number and unit and not a complex expression

So you would need to write like?

round( (2.5 cm + 10.5 mm) in cm)

[josdejong]

That could be. However right now I think there is no way to enforce this. After applying ... in cm there is a property .fixPrefix that is true, but we should also recognize when there is a newly created unit like round(2.5 cm).

What could also work is passing the unit that you want to use as second argument, like round( (2.5 cm + 10.5 mm), cm), that is unambiguous, but it is also less concise.

[mofosyne]

Okay learned a bit more about how fixPrefix behaves... I was thinking maybe to have fixPrefix not be resetted as long as there is no operators that changed unit prefix. But I see now that if this flag is true then function format will not search for the best prefix but leave it as initially provided. So we cannot use that.

I think we may need a separate but similar flag to track if the original prefix is preserved so far.
E.g. maybe ambigiousPrefix flag? or something?

Quick look at current behaviour

Had a quick look at current behavior

math.evaluate("2.5 cm + 10.5 mm").toString()
"3.5500000000000003 cm"
math.evaluate("10.5 mm + 2.5 cm").toString()
"35.5 mm" 

Regarding when fixPrefix changes, it surprisingly change to false even if both side of an add function is the same units. This is as per ~/git/mathjs/src/function/arithmetic/addScalar.js behaviour, as it will always set that flag to false upon any add operations regardless if prefix is fixed.

math.add(math.evaluate("10mm in cm"), math.evaluate("10mm in cm"))
	Object { fixPrefix: false, skipAutomaticSimplification: true, units: (1) […], dimensions: (859) […], value: 0.02 }
		dimensions: Array(859) [ 0, 1, 0, … ]
		fixPrefix: false
		skipAutomaticSimplification: true
		units: Array [ {…} ]
		value: 0.02

unit.fixPrefix is set to true
- when creating new physical constants as in ~/git/mathjs/src/type/unit/physicalConstants.js as shown in math.evaluate("speedOfLight").fixPrefix = true - when setting uni to SI unit math.evaluate("2cm + 1m").toSI().fixPrefix = true in/git/mathjs/src/type/unit/Unit.js- when setting to in Unit.prototype.to in/git/mathjs/src/type/unit/Unit.js`

unit.fixPrefix is passed along
- fromJSON() in ~/git/mathjs/src/type/unit/Unit.js - Unit.prototype.clone in ~/git/mathjs/src/type/unit/Unit.js

[josdejong]

Yes something like a ambigiousPrefix flag could help here. It feels a bit tricky though.

Please note that we're planning on migrating to use UnitMath, so if we want to may any changes we should align it with UnitMath.

@ericman314 do you have any thoughts on this matter?

[mofosyne]

Investigated what we can change to add ambigiousPrefix flag. I'm not familiar enough to change mathjs directly, but here is my observations.

Files of interest for people to modify

• ~/git/mathjs/src/function/arithmetic/round.js : To enable unit we would need to add 'string, Unit | string | Object': function (x, n) and then add checks to check if this.ambigiousPrefix is true before continuing to process Unit

• ~/git/mathjs/src/type/unit/Unit.js : Maybe consider adding this.ambigiousPrefix = false to flag if prefix unit has changed after an operator.

• ~/git/mathjs/src/function/arithmetic/addScalar.js : Consider adding this.ambigiousPrefix = true to be set if both units being added / subtracted has different prefix.

• ~/git/mathjs/src/type/unit/Unit.js defines Unit.prototype.to which we can modify to add this.ambigiousPrefix = false

  • ~/git/mathjs/src/function/unit/to.js : This calls a unit object .to(unit) handler with a desired unit

Hypothetical usage example of a unit round function

This example using my scripting calculator https://github.com/mofosyne/QuickMathJS that uses math.js as it's backend.
It provides at least a usage case for round function with rounding support for Unit inputs (just note a slight difference in syntax, as unit can have space in my calculator).

Note this line round(foodPricePP(paxCount).toNumber(), 2) where I did a workaround to convert to a dimentionless number before putting it though a round function. Fixing this issue would allow me to just do foodPricePP_rounded(paxCount) = round(foodPricePP(paxCount), 2) / pax

# Range Quote Input
upper_bound_price = 50.33 AUD exc gst / pax
upper_pax_count = 30 pax
lower_bound_price = 55.55 AUD exc gst / pax
lower_pax_count = 10 pax

# Slope Intercept Formula (y = mx + c)
m(y1, y2, x1, x2) = ((y1 - y2) / (x1 - x2))
c(y1, y2, x1, x2) = y1 - m(y1, y2, x1, x2)*x1
y_linear(x, y1, y2, x1, x2) = m(y1, y2, x1, x2)*x + c(y1, y2, x1, x2)

# Food Price Per Persion Function
foodPricePP(paxCount) = y_linear(paxCount, upper_bound_price, lower_bound_price, upper_pax_count, lower_pax_count)

# Note that unit price is $ per person
foodPricePP(10 pax): 55.55 AUD exc gst / pax

# Ah here, this fails because round() doesn't support units... solved by using .toNumber() to remove units for now
foodPricePP_rounded(paxCount) = round(foodPricePP(paxCount).toNumber(), 2) * AUD exc gst / pax
foodPricePP_rounded(3 pax): 57.38 AUD exc gst / pax

# Formatted Output Functions
style = {notation: 'fixed', precision: 2}
foodPricePPout(paxCount) = format(foodPricePP_rounded(paxCount) , style)
foodTotalPrice(paxCount) = format(foodPricePP_rounded(paxCount) * paxCount , style)

# People Count To Per Person Price
foodPricePPout(10 pax): 55.55 AUD exc gst / pax
foodPricePPout(11 pax): 55.29 AUD exc gst / pax
foodPricePPout(12 pax): 55.03 AUD exc gst / pax
#... etc...
foodPricePPout(28 pax): 50.85 AUD exc gst / pax
foodPricePPout(29 pax): 50.59 AUD exc gst / pax
foodPricePPout(30 pax): 50.33 AUD exc gst / pax

# People Count To Total Food Cost
foodTotalPrice(10 pax): 555.50 AUD exc gst
foodTotalPrice(11 pax): 608.19 AUD exc gst
foodTotalPrice(12 pax): 660.36 AUD exc gst
#... etc...
foodTotalPrice(28 pax): 1423.80 AUD exc gst
foodTotalPrice(29 pax): 1467.11 AUD exc gst
foodTotalPrice(30 pax): 1509.90 AUD exc gst

[ericman314]

Really interesting discussion! In UnitMath I've actually tried to remove "hidden" flags like fixPrefix, which can affect how units are formatted in unpredictable ways. Setting fixPrefix is a side effect of converting units, and is probably best to be avoided. I suspect that ambiguousPrefix could be even worse, as it affects not only how units are formatted, but also the behavior of other arithmetic functions like round. IMHO, it's far better to have consistent, predictable behavior, even if it requires a little more effort up front.

So, unfortunately I don't have a good suggestion on how to round units automatically without providing the unit you want to round by. But, if you do know what unit you want to round by, you can do it pretty easily:

x = 10.5 cm
round(x / cm) * cm   // 11 cm

[josdejong]

Thanks for you inputs. I indeed have my doubts about an ambiguousPrefix approach too.

Thanks for sharing your workaround! Working this out one step further, you can define a util function:

roundUnit(x, unit) = round(x / unit) * unit

roundUnit(10.5 cm, cm) 
# 11 cm

[mofosyne]

I see, thanks for the workaround, it makes somewhat sense. It would be nice if it can be baked in to round().

If ambiguousPrefix doesn't make sense then checking if fixPrefix is always set before using round is preferred.
Ergo round(25mm to cm) looks more nicer to me than round(25mm, cm) and is still keeping in consistent to known mathjs syntax to.

However I thought it would still be okay as the idea is that as long as there has not been any changes to a unit prefix, we can easily assume that the current prefix is the user intent. E.g. adding the same 1cm + 2cm is highly likely to be cm and should be rounded as such.

Perhaps to reduce confusion ambiguousPrefix flag should really be unambiguousPrefix, which will stay set until made dirty. Thus if a Unit value is sent to round() it would check if unambiguousPrefix is set and if not then throw an error.

Tried the suggestion util function

# Util to work around the lack of unit support for round() and to apply currency formatting
roundUnit(x, precision, unit) = round(x / unit, precision) * unit
currencyFormat(x) = format(x, {notation: 'fixed', precision: 2})

# Range Quote Input
upper_bound_price = 50.33 AUD exc gst / pax
upper_pax_count = 30 pax
lower_bound_price = 55.55 AUD exc gst / pax
lower_pax_count = 10 pax

# Slope Intercept Formula (y = mx + c)
m(y1, y2, x1, x2) = ((y1 - y2) / (x1 - x2))
c(y1, y2, x1, x2) = y1 - m(y1, y2, x1, x2)*x1
y_linear(x, y1, y2, x1, x2) = m(y1, y2, x1, x2)*x + c(y1, y2, x1, x2)

# Food Price Per Persion Function
foodPricePP(paxCount) = y_linear(paxCount, upper_bound_price, lower_bound_price, upper_pax_count, lower_pax_count)
foodPricePP_rounded(paxCount) = roundUnit(foodPricePP(paxCount), 2, AUD exc gst / pax)

# People Count To Per Person Price
foodPricePP_formatted(paxCount) = currencyFormat(foodPricePP_rounded(paxCount))
foodPricePP_formatted(10 pax): 55.55 AUD exc gst / pax
foodPricePP_formatted(11 pax): 55.29 AUD exc gst / pax
foodPricePP_formatted(12 pax): 55.03 AUD exc gst / pax
#... etc...
foodPricePP_formatted(28 pax): 50.85 AUD exc gst / pax
foodPricePP_formatted(29 pax): 50.59 AUD exc gst / pax
foodPricePP_formatted(30 pax): 50.33 AUD exc gst / pax

# People Count To Total Food Cost
foodTotalPrice_formatted(paxCount) = currencyFormat(foodPricePP_rounded(paxCount) * paxCount)
foodTotalPrice_formatted(10 pax): 555.50 AUD exc gst
foodTotalPrice_formatted(11 pax): 608.19 AUD exc gst
foodTotalPrice_formatted(12 pax): 660.36 AUD exc gst
#... etc...
foodTotalPrice_formatted(28 pax): 1423.80 AUD exc gst
foodTotalPrice_formatted(29 pax): 1467.11 AUD exc gst
foodTotalPrice_formatted(30 pax): 1509.90 AUD exc gst

[josdejong]

Thanks for sharing Brian.

It would be nice indeed to extend the function round to support an optional extra argument with a unit. Anyone interested in working this out in a PR? Help would be welcome.

[mofosyne]

#3091 Okay gave a stab at it. Got AssertionError [ERR_ASSERTION]: Values have same structure but are not reference-equal but should be something to start with for others who know what they are doing to jump in.

[josdejong]

Nice! Thanks.

About the unit test error: try deepStrictEqual instead of strictEqual (a Unit is an class instance with properties)

[mofosyne]

Thanks, made the change to #3091. Surprisingly passes even thought its says "deep Strict" rather than just "strict"? It's a little unintuative.
Anyway, I'm sure it's super ugly and there is stuff to clean up, but hopefully it's enough to get the point across. Feel free to change my commit as needed before committing.

[josdejong]

👍

If you want to know more about assert.deepStrictEqual: https://stackoverflow.com/questions/16745855/difference-between-equal-deep-equal-and-strict-equal

[mofosyne]

Also attempted to add fixed prefixed unit support here, but didnt work out.

    'Unit, number': function (valueInput, decimals) {
      if (valueInput.value === null || valueInput.value === undefined) { throw new Error('Parameter input contains a unit with undefined value') }
      if (!valueInput.fixPrefix) { throw new Error('Parameter input requires prefix to be fixed') }
      const res = valueInput.clone()
      // Not sure how to do the inverse of toNumeric() here... also cannot find a way to get the set valuelessUnit of this input
      res.value = roundNumber(valueInput.toNumeric(), decimals)
      return res
    },

so that this would pass in test/unit-tests/function/arithmetic/round.test.js

  it('should round unit', function () {
    assert.deepStrictEqual(round(math.evaluate('31.2345mm in cm'), 3), math.unit('3.123cm'))
    assert.deepStrictEqual(round(math.unit('3.12345cm'), 3, math.unit('cm')), math.unit('3.123cm'))
  })

[josdejong]

I think we shouldn't try to find a solution in the direction of fixPrefix but go for an explicit solution 😅 (see our discussion above).

[mofosyne]

Ah I guess #3091 is good enough then. Should be ready to merge if all good.

[josdejong]

@mofosyne can you have a look at #3095? I'm working out this support for units.

[josdejong]

Support for units in function round is now available in v12.1.0

[mofosyne]

Okay just double checked how it looks now, when integrated with quickmathjs...
Looks much better than the previous workaround of roundUnit(x, precision, unit) = round(x / unit, precision) * unit.
Hopefully we can figure something that looks more nicer aesthetically (hence my hope for unambiguousPrefix)...

But this shall do as it's still better than having to use a hack/workaround! Thanks for getting this in!

# Range Quote Input
upper_bound_price = 50.33 AUD exc gst / pax
upper_pax_count = 30 pax
lower_bound_price = 55.55 AUD exc gst / pax
lower_pax_count = 10 pax

# Slope Intercept Formula (y = mx + c)
m(y1, y2, x1, x2) = ((y1 - y2) / (x1 - x2))
c(y1, y2, x1, x2) = y1 - m(y1, y2, x1, x2)*x1
y_linear(x, y1, y2, x1, x2) = m(y1, y2, x1, x2)*x + c(y1, y2, x1, x2)

# Food Price Per Person Function
foodPricePP(paxCount) = y_linear(paxCount, upper_bound_price, lower_bound_price, upper_pax_count, lower_pax_count)
foodPricePP_rounded(paxCount) = round(foodPricePP(paxCount), 2, AUD exc gst / pax )

# Formatted Output Functions
style = {notation: 'fixed', precision: 2}
foodPricePPout(paxCount) = format(foodPricePP_rounded(paxCount) , style)
foodTotalPrice(paxCount) = format(foodPricePP_rounded(paxCount) * paxCount , style)

# People Count To Per Person Price
foodPricePPout(10 pax): 55.55 AUD exc gst / pax
foodPricePPout(11 pax): 55.29 AUD exc gst / pax
foodPricePPout(12 pax): 55.03 AUD exc gst / pax
#... etc...
foodPricePPout(28 pax): 50.85 AUD exc gst / pax
foodPricePPout(29 pax): 50.59 AUD exc gst / pax
foodPricePPout(30 pax): 50.33 AUD exc gst / pax

# People Count To Total Food Cost
foodTotalPrice(10 pax): 555.50 AUD exc gst
foodTotalPrice(11 pax): 608.19 AUD exc gst
foodTotalPrice(12 pax): 660.36 AUD exc gst
#... etc...
foodTotalPrice(28 pax): 1423.80 AUD exc gst
foodTotalPrice(29 pax): 1467.11 AUD exc gst
foodTotalPrice(30 pax): 1509.90 AUD exc gst