Make error strings more consistent

Author: mhostetter

src/galois/_codes/_linear.py

@@ -37,15 +37,15 @@ def __init__(
         verify_isinstance(systematic, bool)
 
         if not n >= k:
-            raise ValueError(f"Argument `n` must be greater than or equal to `k`, {n} is not greater than {k}.")
+            raise ValueError(f"Argument 'n' must be greater than or equal to 'k', {n} is not greater than {k}.")
         if not d >= 1:
-            raise ValueError(f"Argument `d` must be at least 1, not {d}.")
+            raise ValueError(f"Argument 'd' must be at least 1, not {d}.")
         if not type(G) is type(H):
-            raise ValueError(f"Arguments `G` and `H` must be over the same field, not {type(G)} and {type(H)}.")
+            raise ValueError(f"Arguments 'G' and 'H' must be over the same field, not {type(G)} and {type(H)}.")
         if not G.shape == (k, n):
-            raise ValueError(f"Argument `G` must be have shape (k, n), {G.shape} is not ({k}, {n}).")
+            raise ValueError(f"Argument 'G' must be have shape (k, n), {G.shape} is not ({k}, {n}).")
         if not H.shape == (n - k, n):
-            raise ValueError(f"Argument `H` must be have shape (n - k, n), {H.shape} is not ({n - k}, {n}).")
+            raise ValueError(f"Argument 'H' must be have shape (n - k, n), {H.shape} is not ({n - k}, {n}).")
 
         self._n = n
         self._k = k
@@ -78,7 +78,7 @@ def encode(self, message: ArrayLike, output: Literal["codeword", "parity"] = "co
         verify_literal(output, ["codeword", "parity"])
 
         if output == "parity" and not self.is_systematic:
-            raise ValueError("Argument `output` may only be 'parity' for systematic codes.")
+            raise ValueError("Argument 'output' may only be 'parity' for systematic codes.")
 
         message, is_message_1d = self._check_and_convert_message(message)
         codeword = self._encode_message(message)
@@ -207,10 +207,10 @@ def _check_and_convert_message(self, message: ArrayLike) -> tuple[FieldArray, bo
         message = self.field(message)
 
         if message.ndim > 2:
-            raise ValueError(f"Argument `message` can be either 1-D or 2-D, not {message.ndim}-D.")
+            raise ValueError(f"Argument 'message' can be either 1-D or 2-D, not {message.ndim}-D.")
         if not 1 <= message.shape[-1] <= self.k:
             raise ValueError(
-                f"The `message` must be a 1-D or 2-D array with last dimension between 1 and {self.k}, "
+                f"Argument 'message' must be a 1-D or 2-D array with last dimension between 1 and {self.k}, "
                 f"not shape {message.shape}."
             )
 
@@ -229,7 +229,7 @@ def _check_and_convert_codeword(self, codeword: FieldArray) -> FieldArray:
 
         if not self.n - self.k + 1 <= codeword.shape[-1] <= self.n:
             raise ValueError(
-                f"The argument `codeword` must be a 1-D or 2-D array with last dimension between {self.n - self.k + 1} "
+                f"Argument 'codeword' must be a 1-D or 2-D array with last dimension between {self.n - self.k + 1} "
                 f"and {self.n}, not shape {codeword.shape}."
             )
 

src/galois/_domains/_linalg.py

@@ -153,7 +153,7 @@ def __call__(self, a: Array, b: Array) -> Array:
             return a * b
         if not a.shape[-1] == b.shape[-1]:
             raise ValueError(
-                f"Operation 'inner' requires `a` and `b` to have the same last dimension, not {a.shape} and {b.shape}."
+                f"Operation 'inner' requires 'a' and 'b' to have the same last dimension, not {a.shape} and {b.shape}."
             )
 
         return np.sum(a * b, axis=-1)

src/galois/_fields/_array.py

@@ -420,7 +420,8 @@ def Vector(cls, array: ArrayLike, dtype: DTypeLike | None = None) -> FieldArray:
         x = x.view(np.ndarray)  # Convert into an integer array
         if not x.shape[-1] == degree:
             raise ValueError(
-                f"The last dimension of `array` must be the field extension dimension {cls.degree}, not {x.shape[-1]}."
+                f"Argument 'array' must have last dimension equal to the field extension dimension {cls.degree}, "
+                f"not {x.shape[-1]}."
             )
 
         degrees = np.arange(degree - 1, -1, -1, dtype=dtype)

src/galois/_ntt.py

@@ -110,7 +110,7 @@ def ntt(
     """
     verify_isinstance(x, (tuple, list, np.ndarray, FieldArray))
     if isinstance(x, FieldArray) and not type(x).is_prime_field:
-        raise ValueError(f"If argument `x` is a FieldArray, it must be a prime field, not {type(x)}.")
+        raise ValueError(f"If argument 'x' is a FieldArray, it must be a prime field, not {type(x)}.")
 
     if modulus is None and isinstance(x, FieldArray):
         modulus = type(x).characteristic
@@ -228,7 +228,7 @@ def intt(
     """
     verify_isinstance(X, (tuple, list, np.ndarray, FieldArray))
     if isinstance(X, FieldArray) and not type(X).is_prime_field:
-        raise ValueError(f"If argument `X` is a FieldArray, it must be a prime field, not {type(X)}.")
+        raise ValueError(f"If argument 'X' is a FieldArray, it must be a prime field, not {type(X)}.")
 
     if modulus is None and isinstance(X, FieldArray):
         modulus = type(X).characteristic

src/galois/_polymorphic.py

@@ -91,7 +91,7 @@ def gcd(a, b):
         return int_gcd(a, b)
     if isinstance(a, Poly) and isinstance(b, Poly):
         return poly_gcd(a, b)
-    raise TypeError(f"Arguments `a` and `b` must both be either int or galois.Poly, not {type(a)} and {type(b)}.")
+    raise TypeError(f"Arguments 'a' and 'b' must both be either int or galois.Poly, not {type(a)} and {type(b)}.")
 
 
 @overload
@@ -169,7 +169,7 @@ def egcd(a, b):
         return int_egcd(a, b)
     if isinstance(a, Poly) and isinstance(b, Poly):
         return poly_egcd(a, b)
-    raise TypeError(f"Arguments `a` and `b` must both be either int or galois.Poly, not {type(a)} and {type(b)}.")
+    raise TypeError(f"Arguments 'a' and 'b' must both be either int or galois.Poly, not {type(a)} and {type(b)}.")
 
 
 @overload

src/galois/_polys/_functions.py

@@ -12,7 +12,7 @@ def gcd(a: Poly, b: Poly) -> Poly:
     This function is wrapped and documented in `_polymorphic.gcd()`.
     """
     if not a.field is b.field:
-        raise ValueError(f"Polynomials `a` and `b` must be over the same Galois field, not {a.field} and {b.field}.")
+        raise ValueError(f"Polynomials 'a' and 'b' must be over the same Galois field, not {a.field} and {b.field}.")
 
     r2, r1 = a, b
     while r1 != 0:
@@ -31,7 +31,7 @@ def egcd(a: Poly, b: Poly) -> tuple[Poly, Poly, Poly]:
     This function is wrapped and documented in `_polymorphic.egcd()`.
     """
     if not a.field is b.field:
-        raise ValueError(f"Polynomials `a` and `b` must be over the same Galois field, not {a.field} and {b.field}.")
+        raise ValueError(f"Polynomials 'a' and 'b' must be over the same Galois field, not {a.field} and {b.field}.")
 
     field = a.field
     zero = Poly([0], field=field)