Support arithmetic and comparison operators on Constants when safe

[matthew-reynolds]

Currently, Constants do not support all arithmetic and comparison operations, as the goal is to ensure perfect representation.

Constants support the following mixins (All mixins below are commutative):

• MakesQuantityFromNumber, which permits
  • Constant * raw num -> Quantity
  • Constant / raw num -> Quantity
• ComposesWith, which permits
  • Constant * Constant -> Constant
  • Constant / Constant -> Constant
  • Constant * QuantityMaker -> QuantityMaker
  • Constant / QuantityMaker -> QuantityMaker
  • Constant * SingularNameFor -> SingularNameFor
  • Constant / SingularNameFor -> SingularNameFor
• SupportsRationalPowers, which permits
  • au::pow<integer>(Constant) -> Constant
  • au::root<integer>(Constant) -> Constant
• CanScaleByMagnitude, which permits
  • Constant * Magnitude -> Constant
  • Constant / Magnitude -> Constant

Plus implicit conversion to Quantity and therefore all the op(Constant, Quantity) -> op(Quantity, Quantity) operations supported on Quantities.

This leaves a few gaps when working purely in the Constant domain (Or, equivalently, in the Constant and Magnitude domain). See below:

Arithmetic Operators

Operator	LHS Operand	RHS Operand	Status
+ (Unary)	Constant	N/A	Prohibited but desired
- (Unary)	Constant	N/A	Permitted
+	Constant	Constant	Prohibited but desired
-	Constant	Constant	Prohibited but desired
*	Constant	Constant	Permitted
/	Constant	Constant	Permitted
%	Constant	Constant	Prohibited but desired
~ (Unary)	Constant	N/A	Prohibited
&	Constant	Constant	Prohibited
|	Constant	Constant	Prohibited
^	Constant	Constant	Prohibited
<<	Constant	Constant	Prohibited
>>	Constant	Constant	Prohibited

Comparison Operators

Operator	LHS Operand	RHS Operand	Status
==	Constant	Constant	Prohibited but desired
!=	Constant	Constant	Prohibited but desired
<	Constant	Constant	Prohibited but desired
>	Constant	Constant	Prohibited but desired
<=	Constant	Constant	Prohibited but desired
>=	Constant	Constant	Prohibited but desired
<=>	Constant	Constant	Out of scope, C++20 only

For arithmetic operators, we need to be mindful about maintaining safety, particularly when working with prefixes, ScaledUnits, Pows, and RatioPows. We have previously talked about only supporting the subset of cases that are safe, which makes sense to me, though I can't recall what those unsafe cases actually are.

I think comparison operators will be more straightforward.

To summarize, I would like for there to be support for the following, from highest to lowest priority:

• All comparison operators
• Constant + Constant and Constant - Constant
  • This is a real point of friction for my team today. One common pattern we have is to have some Constant<Seconds> which we wish to subtract 1ms from. We are forced to convert to the Quantity domain (eg with CONST - milli(seconds)(1)) rather than staying in the Constant domain (eg with CONST - make_constant(milli(seconds) * mag<1>()))
• Constant % Constant
  • This is probably a bit more controversial and less generally useful, but still seems like we ought to provide it if we can.
• Unary +Constant
  • This is a no-op, but could be provided just for consistency and symmetry with the unary minus operator. As with floats and doubles, there is no integer promotion for the unary plus operator to apply, so the operand is just returned as is.

[chiphogg]

The cases of concern aren't so much "unsafe", as "non-trivial to implement with confidence".

The scope of this issue will be specifically "anything we can implement using only exact conversions to integer types". This will still permit, e.g., comparing degrees and revolutions --- even though both contain factors of pi, those factors are the same, so they cancel out.

Thank you for this really clear and comprehensive list!

[matthew-reynolds]

I went back and forth a few times on Constant % Magnitude vs Constant % Constant. Both are a little bit awkward from a dimensional analysis perspective. But since in the Quantity land we do Quantity<U, R> % Quantity<U, R> -> Quantity<U, R>, I think that Constant % Constant is probably a bit more consistent. I've updated the issue, but I'd be interested in your thoughts here too.

With Constant % Magnitude, we have:

• 15 seconds % mag<10> -> 5 seconds
• 15 milliseconds % mag<1000> -> 15 milliseconds

With Constant % Constant, we have:

• 15 seconds % 10 seconds -> 5 seconds
• 15 milliseconds % 1 second -> 15 milliseconds

[chiphogg]

You've stumbled on a fascinating little rabbit hole! IMO, the right answer is to permit % only for same-dimension quantities. I think the reasoning in this comment applies to constants as well. In fact, if anything it applies more strongly.

(Actually, you'll probably find that whole thread interesting! 😅)