Scaling Quantities by Scalar values

[benhutchison]

Is there a way to scale Quantities by a scalar, dimensionless number, without first lifting the scalar into a Quantity?

In my use case, I have a bunch of millisecond timestamps that I want to group/bin depending on which time window they fall into. The time window width is specified by an Int parameter, and I want to scale a base window size by the int multiple.

This seems to be just one example of a common need, to scale/multiply a dimensioned quantity by a dimensionless quantity.

ATM does that require lifting the scalar into a Quantity with unit 1 to enable multiply?

[benhutchison]

So I tried defining scale operators for Int and Double that would allow scaling a quantity by a scalar, and hit a perplexing problem that may signal problems with using the literal type 1 for unitless quantities.

code:

extension [VL, UL] (ql: Quantity[VL, UL])
  transparent inline def scale(n: Int)(using tq: coulomb.ops.Mul[VL, UL, Int, 1]): Quantity[tq.VO, tq.UO] =
    ql * Quantity[1](n)
  transparent inline def scale(n: Double)(using tq: coulomb.ops.Mul[VL, UL, Double, 1]): Quantity[tq.VO, tq.UO] =
    ql * Quantity[1](n)

compiler error:

[error] 48 |    ql * Quantity[1](n)
[error]    |                       ^
[error]    |Multiplication not defined in scope for Quantity[VL, UL] and Quantity[Int, Int].
[error]    |I found:
[error]    |
[error]    |    basetypes.Basetypes$package.ctx_mul_2V2U[VL, UL, Int, Int](
[error]    |      scala.util.NotGiven.value
[error]    |    ,
[error]    |      /* ambiguous: both given instance ctx_VR_LpR in object ValueResolution and given instance ctx_VR_RpL in object ValueResolution match type coulomb.ops.ValueResolution[VL, Int] */
[error]    |        summon[coulomb.ops.ValueResolution[VL, Int]]
[error]    |    ,
[error]    |      basetypes.Basetypes$package.ctx_Quantity_Conversion_2V2U[VL, UL, vres.VO, UL](
[error]    |        basetypes.Basetypes$package.ctx_VC_Float[VF]
[error]    |      , ???)
[error]    |    , ???, ???, ???)
[error]    |
[error]    |But given instance ctx_VC_Float in package basetypes does not match type coulomb.conversion.ValueConversion[VL, vres.VO].

What caught my eye was Multiplication not defined in scope for Quantity[VL, UL] and Quantity[Int, Int]. That second quantity has had the literal unit type 1 widened to Int. That surely isn't going to resolve correctly.

But I wasn't able to figure out why compiler had widened the singleton type. It is something Scala is a bit notorious for..

[benhutchison]

extension [VL, UL] (ql: Quantity[VL, UL])
  transparent inline def scale(n: Int)(using mul: coulomb.ops.Mul[VL, UL, Int, 1]): Quantity[mul.VO, mul.UO] =
    mul.eval(ql, Quantity[1](n))
  transparent inline def scale(n: Double)(using mul: coulomb.ops.Mul[VL, UL, Double, 1]): Quantity[mul.VO, mul.UO] =
    mul.eval(ql, Quantity[1](n))

my new heuristic: when defining custom operations that take an implicit operator like Mul, call eval on the operator.

[erikerlandson]

Yes, multiplication by scalars is interesting. I have in the past tried to support expressions like double * Quantity, but the Scala compiler has never quite let me get away with it, even when I define * Q in an extension.

I could try allowing an implicit Conversion from scalar V to Quantity[V, 1], and see if that works.

I'm pretty sure I could define another * overloading where the RHS is scalar. The lack of symmetry always bugged me a little since I could not get scalar * Q to work, but it would at least be an easy way to do scalar multiplications.