[data] Add more div/multiply methods to ExecutionResources

[iamjustinhsu]

For my future autoscaler changes, I would like to divide and multiply execution resources. See https://github.com/anyscale/rayturbo/pull/2778 for more info.

a = ExecutionResources(memory=1E-6)
b = ExecutionResources(memory=1E6)
a.multiply(b)

In the example above, a * b returns 0 due to rounding errors. Ideally, this should be preserved. The approach I do is to use _cpu, _gpu, _memory, and _object_store_memory hold the true precision, but cpu, gpu, memory, and object_store_memory do not.

[gemini-code-assist]

Code Review

This pull request makes a solid improvement by separating the internal high-precision resource values from the public, rounded properties. This effectively addresses the precision loss issue described. The addition of __truediv__ and __mul__ is a good extension for the class's functionality.

My main feedback is to add safe handling for division-by-zero in __truediv__ to prevent potential runtime errors. I've also suggested reordering arguments in the new dunder methods for better consistency with the rest of the class. Overall, these are great changes.

[gemini-code-assist]

This implementation of __truediv__ doesn't handle division by zero, which will raise a ZeroDivisionError if any resource in other is zero. This can lead to unexpected crashes. It's better to define a safe behavior for this case. For resource calculations, a common approach is to treat x / 0 as inf (for x > 0) and 0 / 0 as 0.

I've also reordered the arguments to match the __init__ method for consistency and fixed a minor typo in the comment.

    def __truediv__(self, other: "ExecutionResources") -> "ExecutionResources":
        # NOTE: We access each resource privately because we want to preserve the
        # decimal precision. The public properties will now on runtime safe_round to
        # 5 decimals.
        def _safe_div(a, b):
            if b == 0.0:
                return float("inf") if a != 0.0 else 0.0
            return a / b

        return ExecutionResources(
            cpu=_safe_div(self._cpu, other._cpu),
            gpu=_safe_div(self._gpu, other._gpu),
            object_store_memory=_safe_div(
                self._object_store_memory, other._object_store_memory
            ),
            memory=_safe_div(self._memory, other._memory),
        )

[gemini-code-assist]

For consistency with the __init__ method and other methods in this class, the keyword arguments for ExecutionResources should be in the order cpu, gpu, object_store_memory, memory. This improves readability and maintainability.

    def __mul__(self, other: "ExecutionResources") -> "ExecutionResources":
        return ExecutionResources(
            cpu=self._cpu * other._cpu,
            gpu=self._gpu * other._gpu,
            object_store_memory=self._object_store_memory * other._object_store_memory,
            memory=self._memory * other._memory,
        )

[cursor]

Bug: Division of NaN by zero returns wrong value

The safe_div function mishandles the case where the numerator is NaN and the denominator is 0.0. Since nan == 0.0 is False and nan > 0.0 is also False, the function falls through to return -inf instead of the mathematically correct nan. Adding an explicit math.isnan check at the start of safe_div would fix this edge case.