[Omair-Asdaq]

Three elementwise functions build their result's units incorrectly. I noticed it while checking that the function forms agree with the operator forms.

multiply — converted magnitude, unconverted units

multiply computes units = x1.units * x2.units but feeds the second operand through x2.m_as(x1.units). The magnitude ends up expressed in x1.units while the units are labelled as the product:

• multiply(1 m, 1 mm) → 1e-06 m², should be 1e-03 m² (off by the conversion factor)
• multiply(1 m, 1 s) → DimensionalityError, should give m·s

Using the raw magnitude together with the product of the two units agrees with the * operator, which was already correct.

divide — result carried the dividend's units

divide came out of the generic elementwise loop, which sets units = x1.units and converts x2 into x1.units:

• divide(2 m, 1 m) → 2 m, should be dimensionless 2
• divide(6 m, 3 s) → DimensionalityError, should be 2 m/s

It now has its own implementation using x1.units / x2.units, mirroring the way multiply is already special-cased.

square — units not squared

square came from the generic single-array loop, which returns the input units, so square(3 m) had units m. sqrt already special-cases this (x.units**0.5); square now returns x.units**2.

floor_divide — floored on incompatible scales

floor_divide has its own implementation using x1.units / x2.units, mirroring the way multiply is already special-cased.

Floor division of two quantities is a count — the number of whole right-hand-side units that fit in one left-hand-side unit — so the operands have to be brought onto a common scale before flooring, and the result is dimensionless. This is what pint's Quantity.__floordiv__ does, what this module's own // operator does, and what divmod returns as its quotient. The operands are therefore converted onto a common scale first, which also raises DimensionalityError for dimensionally incompatible units.

prod — tuple axis

prod computed the unit exponent as magnitude.shape[axis], which raises TypeError when axis is a tuple of axes, because a tuple cannot index the shape. The array API allows a tuple of axes, and the magnitude was already computed correctly, so only the unit was wrong. The exponent is now the product of the sizes of the reduced axes.

Tests

One regression test class per fix, asserting both the units and the numeric magnitude (normalised through m_as). All of them fail on the current master and pass with these changes. Full suite: 64 passed, 4 xfailed — the same 4 that are xfailed today.

I ran the suite against the array-api-strict==2.2 pinned in pixi.lock; a newer release rejects a list for shape and makes six unrelated tests fail.

CI

The xp-tests task cloned array-api-tests from master on every run, so the suite moved under the pinned array-api-strict. Tests that the pinned backend does not implement yet — finfo/iinfo with an array argument, added in array-api-tests#358 — then failed, and CI had been red for every pull request since. The checkout is now pinned to the last commit the pinned array-api-strict passes, so a failure in that job means a real regression.

Two things I noticed but did not change

• The // operator strips units entirely and raises for dimensionally different operands, because __floordiv__ is bound by the generic unitless_binary_names loop. That is pre-existing and separate, but it means the new floor_divide can't agree with // until it's addressed.
• Now that the units come from Unit arithmetic, multiply(1 degC, 1 m) and divide(1 degC, 2 s) return degC·m and degC/s where they previously raised. That is consistent with how the module already handles operation-defined units (prod, var, sqrt), and with pint's own array-function path, but it is a behaviour change worth a look.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

An organization owner can choose the repository organization as the billing source for reviews requested by members with a paid Copilot license. Learn about Copilot code review billing.