How to prevent Quantity calculations from converting units

Question

I have an accrual calculation that I would like to preserve the units even though they are of the same dimension (e.g. time). For example, I would like the following

Quantity[5, "Days"] / Quantity[52, "Weeks"]

to return in units of days per week instead of a unitless number. Later in the process I would like to multiply the result by some number of weeks (Quantity[_, "Week"]) and have the result in day units.

I know about IndependentUnit but prefer that the units in the result still be known to Mathematica (KnownUnitQ true) for other purposes.

I have tried this with UpValues (my first UpValues attempt) with the following but I get an error.

Quantity /: 
 op : (Alternatives @@ (Symbol /@ 
       WolframLanguageData[
        EntityClass["WolframLanguageSymbol", 
          {"FunctionalityArea", "MathOperationFunctions"}], "Name"]))[
   Quantity[v1_, u1_],
   Quantity[v2_, u2_]
   ] :=
 Quantity[op[v1, v2], op[u1, u2]]

Is it possible to do this or force a unit hold in quantity calculations?

I am expecting

Quantity[5, "Days"] / Quantity[52, "Weeks"]

to give the result that the following gives

Quantity[5/52, "Days"/"Weeks"]

(* Quantity[5/52, ("Days")/("Weeks")] *)

Answer 1

Products of quantities are handled by (see PrintDefinitions[Quantity])

Quantity /: 
HoldPattern[Times][Longest[e2___], q_?QuantityQ, Shortest[e1, ___] /; 
    QuantityUnits`$AutomaticUnitTimes === True := ...

which calls QuantityUnits`Private`qTimes and in turn QuantityUnits`Private`iqTimes. A way to go is to redefine this last function only

(* Ensures the symbol exists from a fresh kernel for unprotecting it *)
System`Quantity;

Unprotect[Quantity];

QuantityUnits`Private`iqTimes[QuantityUnits`Private`q_List] := Module[{units},

        With[{vlist = QuantityUnits`Private`q[[All, 1]], 
              ulist = QuantityUnits`Private`q[[All, 2]]},

             units = Apply[Times, ulist];
             Quantity[Apply[Times, vlist], units]
        ]
];

Protect[Quantity];

This yields the desired outputs

Quantity[5, "Days"] / Quantity[52, "Weeks"]

(* Quantity[5/52, ("Days")/("Weeks")] *)

Quantity[2, "Weeks"] * %

(* Quantity[5/26, "Days"] *)

Your code and the above redefinition could also be enclosed in a Block. Note that even though the modifications seem minimum, there is the possibility that this redefinition breaks other things as it can happen when redefining built-in symbols.

Answer 2

Since it's a financial calculation I would think you would want something with a minimum chance of behaving unexpectedly. Hence I offer this very simple approach, which should be completely canonical. It gives an output form close to what you requested:

a = HoldForm[Quantity[5, "Days"]/Quantity[52, "Weeks"]]

$\dfrac{5 \text{ days}}{52\text{ wk}}$

UnitConvert[ReleaseHold@a*Quantity[26., "Weeks"], "Days"]

2.5 days

Or you may prefer this syntax, which works as well:

UnitConvert[a*Quantity[26., "Weeks"], "Days"]//ReleaseHold

And if you don't want to specify HoldForm each time:

f[days_, weeks_] := HoldForm[Quantity[days, "Days"]/Quantity[weeks, "Weeks"]] 
f[5, 52]

$\dfrac{5 \text{ days}}{52\text{ wk}}$

Answer 3

I'm not certain if I should post this as an answer or an edit to the OP. It seems it is more of an answer so I put it here.

Since posting this question have and developed and answer that amost works. It is pattern matching based and works for the "MathOperationFunctions" except for Divide.

qtyUnitHoldRule=
   (op:Alternatives @@ (Symbol /@ 
       WolframLanguageData[
          EntityClass["WolframLanguageSymbol", 
              {"FunctionalityArea", "MathOperationFunctions"}], "Name"])
     )[q1_?QuantityQ, q2_?QuantityQ ] -> 
          Quantity[op @@ QuantityMagnitude[{q1, q2}], op @@ QuantityUnit[{q1, q2}]]

qtyUnitHoldRule will be used to convert move the Quantity arithmetic between two quantities inside of one Quantity object.

Remove[holdQuantityUnits];
Attributes[holdQuantityUnits]={HoldAllComplete};
holdQuantityUnits[code_] := Unevaluated[code] //. qtyUnitHoldRule 

Quantity arithmetic will be wrapped in holdQuantityUnits so that qtyUnitHoldRule can be ReplaceRepeated to convert all instances of this arithmetic.

This works for the "MathOperationFunctions" functions I have tested but does not work for the notation form of Divide (i.e. /).

holdQuantityUnits[
    x=Quantity[5,"Days"];
    y=Quantity[52,"Weeks"];
    {Divide[x,y], x / y}
]

(* {Quantity[5/52, ("Days")/("Weeks")], 5 / 364} *)

Any ideas how I can extend this to include the notation form of Divide?

Answer 4

Here's another simple, semi-aggressive way to do this. First we'll note that we have these:

Names["QuantityUnits`$Automatic*"]

{"QuantityUnits`$AutomaticUnitParsing", \
"QuantityUnits`$AutomaticUnitPlus", \
"QuantityUnits`$AutomaticUnitTimes"} 

And so we'll just Block all of them.

withHeldUnits[expr_] :=
  Block[{QuantityUnits`$AutomaticUnitParsing,
    QuantityUnits`$AutomaticUnitPlus,
    QuantityUnits`$AutomaticUnitTimes},
   expr
   ];
withHeldUnits~SetAttributes~HoldFirst

(Quantity["SpeedOfLight"] + Quantity[2, "Angstroms"/"Seconds"])
withHeldUnits@(Quantity["SpeedOfLight"] + 
   Quantity[2, "Angstroms"/"Seconds"])

Quantity[2997924580000000002, ("Angstroms")/("Seconds")]

Quantity[2, ("Angstroms")/("Seconds")] + Quantity[1, "SpeedOfLight"]