Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

Portable floor_divide returns non-whole numbers for floats and wrong values for a zero divisor

Abierto
  • ¿Algo no está bien?
#23,684 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

@usmanmateen ya está trabajando en esto.

Desde el 11/10/2026.

  • #23685 de @usmanmateen — abierto

Evaluación

Dificultad
3/5
Tiempo estimado
1-2 días
Aptitud para principiantes
52/100
Tipo de issue
Error
Claridad
Bastante claro
Estado de actividad
Activo
Stack tecnológico
cpp, python, pytorch
Área
backend, testing

Línea de trabajo

Start with kernels/portable/cpu/util/math_util.h and inspect utils::floor_divide; the issue says the same helper is used by portable div and by Cadence HiFi and Fusion G3 div operators. Compare its floating-point behavior with ATen's div_floor_floating, focusing on rounding errors and zero divisors, then add tests for the reported cases. Done means floating-point results match eager behavior for those cases while integer behavior remains unaffected.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

🐛 Describe the bug

For floating-point inputs, the portable floor_divide kernel often returns a value that is not a whole number, and it returns the wrong value when dividing by zero. div.Tensor_mode / div.Scalar_mode with rounding_mode="floor" use the same helper (utils::floor_divide in kernels/portable/cpu/util/math_util.h), so they behave the same way.

  1. Results that aren't whole numbers. The helper returns (a - fmod(a, b)) / b, minus 1 if the signs differ. That quotient can be off from a whole number by a rounding error. ATen's div_floor_floating then floors it and rounds up if the remainder is above 0.5; the portable helper skips that step. With random inputs (a in [-10, 10], b in [0.01, 2.01]), about 7% of float64 results and 6% of float32 results differ from eager. When the result is converted to an integer, as is common for bucket or index computations, it comes out one too small for positive results (2.9999999999999996 → 2) and one too large for negative ones (-3.9999999999999996 → -3).
  2. Division by zero. For b == 0 the helper returns ±inf based on the sign of a. ATen returns a / b, so 0.0 // 0.0 is nan instead of inf, nan // 0.0 is nan instead of inf, and a -0.0 divisor flips the sign (1.0 // -0.0 is -inf).
import torch
from executorch.exir import to_edge
from executorch.runtime import Runtime


class FloorDiv(torch.nn.Module):
    def forward(self, a, b):
        return torch.div(a, b, rounding_mode="floor")


def run(a, b):
    prog = to_edge(torch.export.export(FloorDiv(), (a, b))).to_executorch()
    return Runtime.get().load_program(prog.buffer).load_method("forward").execute([a, b])[0]


a = torch.tensor([4.2, 0.7, -4.2], dtype=torch.float64)
b = torch.tensor([1.4, 0.1, 1.4], dtype=torch.float64)
print(torch.div(a, b, rounding_mode="floor").tolist(), run(a, b).tolist())
# [3.0, 6.0, -4.0] [2.9999999999999996, 6.000000000000001, -3.9999999999999996]
print(torch.div(a, b, rounding_mode="floor").long().tolist(), run(a, b).long().tolist())
# [3, 6, -4] [2, 6, -3]

a = torch.tensor([-6.4278764724731445])
b = torch.tensor([1.870701551437378])
print(torch.floor_divide(a, b).item(), run(a, b).item())
# -4.0 -3.999999761581421

a = torch.tensor([0.0, float("nan"), 1.0])
b = torch.tensor([0.0, 0.0, -0.0])
print(torch.floor_divide(a, b).tolist(), run(a, b).tolist())
# [nan, nan, -inf] [inf, inf, inf]

Integer inputs are not affected. utils::floor_divide is also used by the Cadence HiFi and Fusion G3 div operators. I have a fix with tests and will open a PR.

Versions

executorch 1.5.1 (math_util.h is the same on main at f2575be), torch 2.14.1+cpu, Python 3.12, Linux x86_64 (WSL2).

Lenguaje dominante
Python
Estrellas
5.1k
Forks
1.2k
Merge medio
2 d 9 h
PR fusionados (30 d)
632

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de pytorch/executorch

Todos los issues de pytorch/executorch

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.