Resolve NumbaIRAssumptionWarning

Fixes #226
mhostetter · Jan 31, 2022 · a5e6386 · a5e6386
1 parent 70dc6e2
commit a5e6386
Show file tree

Hide file tree

Showing 7 changed files with 40 additions and 41 deletions.
diff --git a/galois/_fields/_calculate.py b/galois/_fields/_calculate.py
@@ -93,11 +93,10 @@ def _ufunc_calculate(cls, name):
  degree = cls._degree
  irreducible_poly = cls._irreducible_poly_int
 
- # NOTE: Using lambda arguments `aa` and `bb` to workaround these issues: https://github.com/mhostetter/galois/issues/178 and https://github.com/numba/numba/issues/7623
  if cls._UFUNC_TYPE[name] == "unary":
- cls._UFUNC_CACHE_CALCULATE[key] = numba.vectorize(["int64(int64)"], nopython=True)(lambda aa: function(aa, characteristic, degree, irreducible_poly))
+ cls._UFUNC_CACHE_CALCULATE[key] = numba.vectorize(["int64(int64)"], nopython=True)(lambda a: function(a, characteristic, degree, irreducible_poly))
  else:
- cls._UFUNC_CACHE_CALCULATE[key] = numba.vectorize(["int64(int64, int64)"], nopython=True)(lambda aa, bb: function(aa, bb, characteristic, degree, irreducible_poly))
+ cls._UFUNC_CACHE_CALCULATE[key] = numba.vectorize(["int64(int64, int64)"], nopython=True)(lambda a, b: function(a, b, characteristic, degree, irreducible_poly))
 
  cls._reset_globals()
 

diff --git a/galois/_fields/_functions.py b/galois/_fields/_functions.py
@@ -309,7 +309,7 @@ def _poly_roots(cls, nonzero_degrees, nonzero_coeffs):
  ###############################################################################
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _matmul_calculate(A, B, ADD, MULTIPLY, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  args = CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY
  dtype = A.dtype
@@ -328,7 +328,7 @@ def _matmul_calculate(A, B, ADD, MULTIPLY, CHARACTERISTIC, DEGREE, IRREDUCIBLE_P
  return C
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _convolve_calculate(a, b, ADD, MULTIPLY, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  args = CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY
  dtype = a.dtype
@@ -341,7 +341,7 @@ def _convolve_calculate(a, b, ADD, MULTIPLY, CHARACTERISTIC, DEGREE, IRREDUCIBLE
  return c
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _poly_evaluate_calculate(coeffs, values, ADD, MULTIPLY, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY): # pragma: no cover
  args = CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY
  dtype = values.dtype
@@ -355,7 +355,7 @@ def _poly_evaluate_calculate(coeffs, values, ADD, MULTIPLY, CHARACTERISTIC, DEGR
  return results
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _poly_divmod_calculate(a, b, SUBTRACT, MULTIPLY, DIVIDE, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  args = CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY
 
@@ -376,7 +376,7 @@ def _poly_divmod_calculate(a, b, SUBTRACT, MULTIPLY, DIVIDE, CHARACTERISTIC, DEG
  return qr
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _poly_roots_calculate(nonzero_degrees, nonzero_coeffs, primitive_element, ADD, MULTIPLY, POWER, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  args = CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY
  dtype = nonzero_coeffs.dtype

diff --git a/galois/_fields/_gf2m.py b/galois/_fields/_gf2m.py
@@ -82,7 +82,7 @@ def _subtract_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return a ^ b
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _multiply_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  a in GF(2^m), can be represented as a degree m-1 polynomial a(x) in GF(2)[x]
@@ -113,7 +113,7 @@ def _multiply_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return c
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  From Fermat's Little Theorem:
@@ -145,7 +145,7 @@ def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return result
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if b == 0:
  raise ZeroDivisionError("Cannot compute the multiplicative inverse of 0 in a Galois field.")
@@ -157,7 +157,7 @@ def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return MULTIPLY(a, b_inv, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  Square and Multiply Algorithm
@@ -195,7 +195,7 @@ def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return result
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _log_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  TODO: Replace this with more efficient algorithm

diff --git a/galois/_fields/_gfp.py b/galois/_fields/_gfp.py
@@ -59,36 +59,36 @@ def _reset_globals(cls):
  ###############################################################################
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _add_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  c = a + b
  if c >= CHARACTERISTIC:
  c -= CHARACTERISTIC
  return c
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _negative_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if a == 0:
  return 0
  else:
  return CHARACTERISTIC - a
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _subtract_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if a >= b:
  return a - b
  else:
  return CHARACTERISTIC + a - b
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _multiply_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return (a * b) % CHARACTERISTIC
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  s*x + t*y = gcd(x, y) = 1
@@ -113,7 +113,7 @@ def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return t2
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if b == 0:
  raise ZeroDivisionError("Cannot compute the multiplicative inverse of 0 in a Galois field.")
@@ -125,7 +125,7 @@ def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return (a * b_inv) % CHARACTERISTIC
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  Square and Multiply Algorithm
@@ -163,7 +163,7 @@ def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return result
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _log_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  TODO: Replace this with more efficient algorithm

diff --git a/galois/_fields/_gfpm.py b/galois/_fields/_gfpm.py
@@ -157,7 +157,7 @@ def _ufunc_routine_subtract(cls, ufunc, method, inputs, kwargs, meta):
  ###############################################################################
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _int_to_poly(a, CHARACTERISTIC, DEGREE):
  """
  Convert the integer representation to vector/polynomial representation
@@ -170,7 +170,7 @@ def _int_to_poly(a, CHARACTERISTIC, DEGREE):
  return a_vec
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _poly_to_int(a_vec, CHARACTERISTIC, DEGREE):
  """
  Convert the integer representation to vector/polynomial representation
@@ -181,30 +181,30 @@ def _poly_to_int(a_vec, CHARACTERISTIC, DEGREE):
  return a
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _add_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  a_vec = INT_TO_POLY(a, CHARACTERISTIC, DEGREE)
  b_vec = INT_TO_POLY(b, CHARACTERISTIC, DEGREE)
  c_vec = (a_vec + b_vec) % CHARACTERISTIC
  return POLY_TO_INT(c_vec, CHARACTERISTIC, DEGREE)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _negative_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  a_vec = INT_TO_POLY(a, CHARACTERISTIC, DEGREE)
  a_vec = (-a_vec) % CHARACTERISTIC
  return POLY_TO_INT(a_vec, CHARACTERISTIC, DEGREE)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _subtract_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  a_vec = INT_TO_POLY(a, CHARACTERISTIC, DEGREE)
  b_vec = INT_TO_POLY(b, CHARACTERISTIC, DEGREE)
  c_vec = (a_vec - b_vec) % CHARACTERISTIC
  return POLY_TO_INT(c_vec, CHARACTERISTIC, DEGREE)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _multiply_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  a_vec = INT_TO_POLY(a, CHARACTERISTIC, DEGREE)
  b_vec = INT_TO_POLY(b, CHARACTERISTIC, DEGREE)
@@ -233,7 +233,7 @@ def _multiply_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return POLY_TO_INT(c_vec, CHARACTERISTIC, DEGREE)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  From Fermat's Little Theorem:
@@ -264,7 +264,7 @@ def _reciprocal_calculate(a, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return result
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if b == 0:
  raise ZeroDivisionError("Cannot compute the multiplicative inverse of 0 in a Galois field.")
@@ -276,7 +276,7 @@ def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return MULTIPLY(a, b_inv, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY)
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  Square and Multiply Algorithm
@@ -314,7 +314,7 @@ def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return result
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _log_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  """
  TODO: Replace this with more efficient algorithm

diff --git a/galois/_fields/_lookup.py b/galois/_fields/_lookup.py
@@ -120,7 +120,7 @@ def _ufunc_lookup(cls, name):
  ###############################################################################
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _add_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -152,7 +152,7 @@ def _add_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[m + ZECH_LOG[n - m]]
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _negative_lookup(a, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -170,7 +170,7 @@ def _negative_lookup(a, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[ZECH_E + m]
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _subtract_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -210,7 +210,7 @@ def _subtract_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[m + ZECH_LOG[z]]
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _multiply_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -228,7 +228,7 @@ def _multiply_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[m + n]
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _reciprocal_lookup(a, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -248,7 +248,7 @@ def _reciprocal_lookup(a, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[(ORDER - 1) - m]
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _divide_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -273,7 +273,7 @@ def _divide_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[(ORDER - 1) + m - n] # We add `ORDER - 1` to guarantee the index is non-negative
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _power_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)
@@ -300,7 +300,7 @@ def _power_lookup(a, b, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  return EXP[(m * b) % (ORDER - 1)] # TODO: Do b % (ORDER - 1) first? b could be very large and overflow int64
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _log_lookup(beta, alpha, EXP, LOG, ZECH_LOG, ZECH_E): # pragma: no cover
  """
  α is a primitive element of GF(p^m)

diff --git a/galois/_fields/_main.py b/galois/_fields/_main.py
@@ -2715,7 +2715,7 @@ def _divide_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return a & b
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if a == 0 and b < 0:
  raise ZeroDivisionError("Cannot compute the multiplicative inverse of 0 in a Galois field.")
@@ -2726,7 +2726,7 @@ def _power_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  return a
 
  @staticmethod
- @numba.extending.register_jitable(inline="always")
+ @numba.extending.register_jitable
  def _log_calculate(a, b, CHARACTERISTIC, DEGREE, IRREDUCIBLE_POLY):
  if a == 0:
  raise ArithmeticError("Cannot compute the discrete logarithm of 0 in a Galois field.")