Recent Releases of galois

Changes

Improved performance further of linear algebra over finite fields with prime order. (#598)
Improved TypeError description for arithmetic on FieldArray instances with same order but different irreducible polynomials. (#602)
Fixed bug in .log() of scalar 0-dim FieldArrays. (#600)
Fixed bug in typing of IterableLike, which didn't support lists of NDArray. (#602)

Contributors

@fyellin
@rafaelha
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 1 year ago

Changes

Improved performance of linear algebra over finite fields with prime order. This is achieved by using floating-point BLAS implementations, where possible. A 10-100x performance improvement is seen. (#596)
Upgrade documentation styling.

Contributors

Bogdan Reznychenko (@theodotk)
@rafaelha
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 1 year ago

Changes

Added support for Python 3.13. (#587)
Added support for NumPy 2.1. (#587)
Added support for Numba 0.61. (#587)

Contributors

Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] over 1 year ago

Changes

Fixed occasional bug in polynomial modular exponentiation. (#575)
Fixed occasional bug in square root calculation in extension fields with even degree. (#573)

Contributors

TDQuering (@TDQuering)
maple (@maple3142)
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] over 1 year ago

Changes

Added support for NumPy 2.1. (#567)

Contributors

Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] almost 2 years ago

Changes

Fixed multithreading incompatibility. Previously only one thread could read from the SQLite databases. (#558)
Clarified Poly string representation when underlying field is non-primitive and uses the "poly" element representation. (#329)
Fixed typo in error message. (#557)
Made minor documentation improvements.

Contributors

Semjon Kravtšenko (@semjon00)
@MrVeka
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 2 years ago

Changes

Added support for NumPy 2.0. (#550)
Added support for Numba 0.60. (#550)

Contributors

Iyán Méndez Veiga (@iyanmv)
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 2 years ago

Changes

Added support for ufunc_mode="python-calculate" for all fields. (#551)

Contributors

Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 2 years ago

Changes

Added support for python -OO optimization. (#545)
Improved documentation in minor ways.

Contributors

Justin Charlong (@jcharlong)
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] about 2 years ago

Changes

Added support for Python 3.12. (#534)
Added support for NumPy 1.26. (#534)
Added support for Numba 0.59. (#534)
Fixed bug in FieldArray.multiplicative_order() for large fields. (#533)

Contributors

Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] over 2 years ago

Changes

Added wheel factorization for finding large primes. (#527)
Improved type annotations. (#510, #511)
Removed optional [dev] extra. If developing, install from requirements-dev.txt. (#521)
Fixed bugs in prev_prime() and next_prime() for large primes. (#527)

Contributors

@avadov
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] over 2 years ago

Changes

Added support for NumPy 1.25. (#507)
Added support for Numba 0.58. (#507)
Fixed rare overflow with computing a large modular exponentiation of polynomials. (#488)
Resolved various deprecations warnings with NumPy 1.25. (#492)

Contributors

Iyán Méndez Veiga (@iyanmv)
@Lasagnenator
Matt Hostetter (@mhostetter)

- Python
Published by github-actions[bot] almost 3 years ago

Changes

Added py.typed file to indicate to mypy and other type checkers that galois supports typing. (#481)
Fixed bug with multiple, concurrent BCH and/or Reed Solomon decoders. (#484)

Contributors

Matt Hostetter (@mhostetter)

Commits

a140a468 Add release notes for v0.3.5 2e49783d Prevent GitHub Release workflow from failing 7418aa5f Make colors easier to read in dark mode bd0546df Limit right-side TOC depth for release note pages 329aaa60 Move star call to dismissable banner 5bbec50a Store BCH and RS decoders in different namespaces c3a82df0 Store BCH/RS decoders for each base/extension field pair 18234405 Add unit test to catch #483 d91f83d9 Fix unhidden table of contents 214cd52e Display NumPy and Numba versions when testing 7dcd6d0f Make release note pages more succinct 1c5980a9 Comply with PEP 561

- Python
Published by github-actions[bot] about 3 years ago

galois - galois v0.3.4

Released May 2, 2023

Changes

Added support for Python 3.11. (#415)
Added support for NumPy 1.24. (#415)
Fixed indexing bug in FieldArray.plu_decompose() for certain input arrays. (#477)

Contributors

Matt Hostetter (@mhostetter)

Commits

a2fa1ac9 Add release notes for v0.3.4 f94af2a7 Support NumPy 1.24 95f5b1fb Support Python 3.11 with NumPy 1.23.2 and Numba 0.57 1edbb193 Change Twitter badge color to blue c882d728 Add unit test for #476 09926f2d Use consistent variable names between LU and PLU 43fe231b Fix error message in lu_decompose() 79325b53 Fix array sizing for PLU decomposition 766ba862 Format HTML file 2a27ccd2 Fix the Twitter badge

- Python
Published by github-actions[bot] about 3 years ago

galois - galois v0.3.3

Released February 1, 2023

Changes

Added a terms keyword argument to irreducible_poly(), irreducible_polys(), primitive_poly(), and primitive_polys() to find a polynomial with a desired number of non-zero terms. This may be set to an integer or to "min". (#463) python >>> import galois >>> galois.irreducible_poly(7, 9) Poly(x^9 + 2, GF(7)) >>> galois.irreducible_poly(7, 9, terms=3) Poly(x^9 + x + 1, GF(7)) >>> galois.primitive_poly(7, 9) Poly(x^9 + x^2 + x + 2, GF(7)) >>> galois.primitive_poly(7, 9, terms="min") Poly(x^9 + 3x^2 + 4, GF(7))
Added a database of binary irreducible polynomials with degrees less than 10,000. These polynomials are lexicographically-first and have the minimum number of non-zero terms. The database is accessed in irreducible_poly() when terms="min" and method="min". (#462) ```python In [1]: import galois

# Manual search In [2]: %time galois.irreducible_poly(2, 1001) CPU times: user 6.8 s, sys: 0 ns, total: 6.8 s Wall time: 6.81 s Out[2]: Poly(x^1001 + x^5 + x^3 + x + 1, GF(2))

# With the database In [3]: %time galois.irreduciblepoly(2, 1001, terms="min") CPU times: user 745 µs, sys: 0 ns, total: 745 µs Wall time: 1.4 ms Out[3]: Poly(x^1001 + x^17 + 1, GF(2)) ``- Memoized expensive polynomial testsPoly.isirreducible()andPoly.is_primitive(). Now, the expense of those calculations for a given polynomial is only incurred once. ([#470](https://github.com/mhostetter/galois/pull/470))``python In [1]: import galois

In [2]: f = galois.Poly.Str("x^1001 + x^17 + 1"); f Out[2]: Poly(x^1001 + x^17 + 1, GF(2))

In [3]: %time f.is_irreducible() CPU times: user 1.05 s, sys: 3.47 ms, total: 1.05 s Wall time: 1.06 s Out[3]: True

In [4]: %time f.isirreducible() CPU times: user 57 µs, sys: 30 µs, total: 87 µs Wall time: 68.2 µs Out[4]: True ``- Added tests for Conway polynomialsPoly.isconway()andPoly.isconwayconsistent(). ([#469](https://github.com/mhostetter/galois/pull/469)) - Added the ability to manually search for a Conway polynomial if it is not found in Frank Luebeck's database, usingconway_poly(p, m, search=True)`. (#469) - Various documentation improvements.

Contributors

Iyán Méndez Veiga (@iyanmv)
Matt Hostetter (@mhostetter)

Commits

db0fde5c Add release notes for v0.3.3 1fafb790 Fix formatting 09463a7c Fix pylint errors bbc41337 Speed up database calls by sharing a connection and cursor 4339f25e Add performance note about the irreducible poly database 0ec28361 Add hyperlink to additional linear algebra methods f14901b5 Add hyperlinks in README be2e4013 Make conway_polys.db only contain non-zero coefficients b61044aa Clean up polynomial LUTs 4177128b Simplify database interfaces f2cb05af Remove use_database kwarg from irreducible_poly() b5eec8f7 Update method versus property documentation comment 58dcccbd Add slow performance warnings for manual Conway poly search a4d6a5d1 Add Conway polynomial manual search unit tests c3bc7b1d Add manual Conway polynomial test and search functions ff28d979 Clean up recursive function 77f8316c Add unit tests 89d8086b Use IrreduciblePolyDatabase with terms="min" bf6010be Add irreducible polynomials for GF(2^m) 9153adbb Silence erroneous pylint error 4c61dadd Better solution for avoiding circular imports 9485b5df Minor variable name tweak 021ec943 Minor terminology tweak c2d5d7f9 Move Lagrange polys to _lagrange.py e2eee570 Fix type hint e228261a Preserve intellisense autocompletion and brief docstring of patched Poly methods 289857a8 Remove unused imports 0dffee78 Memoize Poly.is_primitive() 9392bd44 Memoize Poly.is_irreducible() 460cec59 Simplify Poly hash b2f33f16 Move polynomial search functions into _search.py 4804c086 Move Conway polys to their own module f1740795 Reorganize poly factors methods 9d846e26 Reorganize irreducibility and primitivity tests 1a863ef9 Sort keywords ca979685 Organize class items better in docs b87dd04f Fix docs links to FieldArray.compile() and FieldArray.repr() 95327a12 Modify slow performance warnings 28a8108a Add performance-related custom admonitions 00689019 Move polynomial deterministic search into _poly.py 534de4e1 Make search for a random irreducible/primitive polynomial much more efficient a82c9d0f Move common irreducible/primitive poly functions to _poly.py 4cc9fbc5 Add a terms="min" option to irreducible/primitive poly functions a5344cfa Make search for polynomials of fixed-term much more efficient f4b908ec Add terms kwarg to primitive poly functions 7ab1c028 Add terms kwarg to irreducible poly functions 44cc2140 Parse Google docstring "See Also" sections as if they were NumPy docstring 7b3aed9b Clean up docstrings 100363b4 Change max line length to 120 41b17f0a Use Google docstrings instead of NumPy docstrings 1c89c5eb Add pytest-benchmark back to [dev] dependencies 87c8850c Upgrade to Sphinx Immaterial 0.11.2 1d5ffcfd Update copyright 7bb4da31 Fix typo in pollard_p1() docstring

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.3.2

Released December 18, 2022

Changes

Added a prime factorization database for $n = b^k \pm 1$, with $b \in {2, 3, 5, 6, 7, 10, 11, 12}$. The factorizations are from the Cunningham Book. This speeds up the creation of large finite fields. (#452) ```python In [1]: import galois

v0.3.1

In [2]: %time galois.factors(2**256 - 1)

Took forever...

v0.3.2

In [2]: %time galois.factors(2**256 - 1) Wall time: 1 ms Out[2]: ([3, 5, 17, 257, 641, 65537, 274177, 6700417, 67280421310721, 59649589127497217, 5704689200685129054721], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) - Added speed-up when factoring powers of small primes. This speeds up the creation of large finite fields. ([#454](https://github.com/mhostetter/galois/pull/454))python In [1]: import galois

v0.3.1

In [2]: %time galois.factors(2**471) Wall time: 4.18 s Out[2]: ([2], [471])

v0.3.2

In [2]: %time galois.factors(2**471) Wall time: 2 ms Out[2]: ([2], [471]) ``` - Added four additional Mersenne primes that were discovered between 2013-2018. (#452)

Contributors

Matt Hostetter (@mhostetter)

Commits

2a006d14 Add release notes for v0.3.2 5b9d50a5 Add check in perfect_power() to see if n is a prime power for small primes 3eb1cb61 Add the Cunningham Book to the acknowledgements 50899c62 Add prime factors database 15e4d96c Clean up conway poly script 458f20e7 Fix typo in pollard_rho docstring c3bbab8b Update database path for Conway poly database dabb41ef Add newly discovered Mersenne exponents

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.3.1

Released December 12, 2022

Changes

Fixed a bug in the Pollard $\rho$ factorization algorithm that caused an occasional infinite loop. (#450) ```python In [1]: import galois

v0.3.0

In [2]: %time galois.GF(2400610585866217)

Never returns...

v0.3.1

In [2]: %time galois.GF(2400610585866217) Wall time: 96 ms Out[2]: ``- Formatted the code and unit tests withblackandisort`. (#446, #449)

Contributors

Matt Hostetter (@mhostetter)
@pivis

Commits

638f0aaa Add release notes for v0.3.1 deb4c1e9 Fix a bug in factorization function causing infinite loops in rare cases bd9e576b Lint unit tests in CI b8c3a099 Lint tests/ with pylint 6544fb4b Format tests/ with black 0c9133c9 Skip formatting on occasional long lines a843fdc2 Resolve missing-module-docstring pylint errors 37af083b Resolve invalid-unary-operand-type pylint errors b19b4e76 Resolve not-callable pylint errors 62bf749f Resolve unsubscriptable-object pylint errors 0c7392de Resolve eval-used pylint errors 19de2f52 Resolve unnecessary-lambda-assignment pylint errors a0a11154 Resolve no-else-return pylint errors 18011897 Resolve consider-using-enumerate pylint errors 55eb55c0 Use pylint to check for lines that are too long 9019123f Sort imports with isort 82f5fee9 Run black in the CI 10f81836 Format codebase with black 253ce898 Add GitHub star suggestion 41dcc7df Update performance docs for faster matrix multiplication

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.3.0

Released December 9, 2022

Breaking changes

Increased minimum NumPy version to 1.21.0. (#441)
Increased minimum Numba version to 0.55.0 (#441)
Modified galois.GF() and galois.Field() so that keyword arguments irreducible_poly, primitive_element, verify, compile, and repr may no longer be passed as positional arguments. (#442)

Changes

Added a galois.GF(p, m) call signature in addition to galois.GF(p**m). This also applies to galois.Field(). Separately specifying $p$ and $m$ eliminates the need to factor the order $p^m$ in very large finite fields. (#442) python >>> import galois # This is faster than galois.GF(2**409) >>> GF = galois.GF(2, 409) >>> print(GF.properties) Galois Field: name: GF(2^409) characteristic: 2 degree: 409 order: 1322111937580497197903830616065542079656809365928562438569297590548811582472622691650378420879430569695182424050046716608512 irreducible_poly: x^409 + x^7 + x^5 + x^3 + 1 is_primitive_poly: True primitive_element: x
Optimized matrix multiplication by parallelizing across multiple cores. (#440) ```python In [1]: import galois

In [2]: GF = galois.GF(3**5)

In [3]: A = GF.Random((300, 400), seed=1)

In [4]: B = GF.Random((400, 500), seed=2)

v0.2.0

In [5]: %timeit A @ B 664 ms ± 3.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

v0.3.0

In [5]: %timeit A @ B 79.1 ms ± 7.32 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) - Optimized polynomial evaluation by parallelizing across multiple cores. ([#440](https://github.com/mhostetter/galois/pull/440))python In [1]: import galois

In [2]: GF = galois.GF(3**5)

In [3]: f = galois.Poly.Random(100, seed=1, field=GF)

In [4]: x = GF.Random(100_000, seed=1)

v0.2.0

In [5]: %timeit f(x) 776 ms ± 2.12 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

v0.3.0

In [5]: %timeit f(x) 13.9 ms ± 2.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) ``- Fixed an occasional arithmetic type error in binary extension fields $\mathrm{GF}(2^m)$ when using the built-innp.bitwise_xor()`. (#441)

Contributors

Matt Hostetter (@mhostetter)

Commits

648aa062 Add release notes for v0.3.0 87ec4fc7 Fix incorrect GF on Array Classes page 4679e20b JIT parallelize polynomial evaluation dacc9e4e JIT parallelize matrix multiplication 4c82984c Enable parallel processing of JIT functions 153614a5 Document ways to speed up large field construction 04e77a2f Add galois.GF(p, m) optional call signature 13770e0d Fix overflow bug with "python-calculate" using native NumPy ufuncs 38f27997 Bump minimum NumPy version to 1.21 and Numba version to 0.55

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.2.0

Released November 17, 2022

Breaking changes

Refactored FEC classes and usage. (#413, #435)
- Modified BCH codes to support q-ary, non-primitive, and non narrow-sense codes.
- Modified ReedSolomon codes to support non-primitive codes.
- Enabled instantiation of a BCH or ReedSolomon code by specifying (n, k) or (n, d).
- Removed parity_only=False keyword argument from FEC encode() methods and replaced with output="codeword".
- Removed bch_valid_codes() from the API. Instead, use galois.BCH(n, d=d) to find and create a BCH code with codeword size n and design distance d. For example, here is how to find various code sizes of primitive BCH codes over GF(5).
```python

import galois GF = galois.GF(5) for d in range(3, 10): ... bch = galois.BCH(5**2 - 1, d=d, field=GF) ... print(repr(bch)) ... ``- Removedgeneratortoparitycheckmatrix(),paritychecktogeneratormatrix(),polytogeneratormatrix(), androotstoparitycheck_matrix()` from the API.
Renamed properties and methods for changing the finite field element representation. (#436)
- Renamed display keyword argument in GF() to repr.
- Renamed FieldArray.display() classmethod to FieldArray.repr().
- Renamed FieldArray.display_mode property to FieldArray.element_repr. python >>> import galois >>> GF = galois.GF(3**4, repr="poly") >>> x = GF.Random(2, seed=1); x GF([2α^3 + 2α^2 + 2α + 2, 2α^3 + 2α^2], order=3^4) >>> GF.repr("power"); x GF([α^46, α^70], order=3^4) >>> GF.element_repr 'power'

Changes

Added output="codeword" keyword argument to FEC encode() methods. (#435)
Added output="message" keyword argument to FEC decode() methods. (#435)
Standardized NumPy scalar return types (np.bool_ and np.int64) to Python types (bool and int). For example, in FieldArray.multiplicative_order(). (#437)
Improved documentation and published docs for pre-release versions (e.g., v0.3.x).

Contributors

Matt Hostetter (@mhostetter)

Commits

a1827638 Add release notes for v0.2.0 ba3d3d3c Minor clarifications in docs 6ae4a780 Standardize scalar return types f0d92b3f Fix typos 07783e23 Fix ValueError messages 475212d9 Modify admonition types e876aa7f Conform dropdown admonitions to new Sphinx Immaterial 66e6c1e8 Change seealso admonition icon 4cbbf302 Fix docs error of mismatched parameter names 4d569033 Add abstract admonitions ebbb1970 Add Galois quote cfb8f2d0 Update Sphinx Immaterial to latest 419df85b Fix color of outdated version banner b933732b Rename display to repr and display_mode to element_repr 5b593b26 Fix CI push to gh-pages d26b3738 Run Python script in CI without custom action 04f00836 Add outdated version banner 7f592310 Create latest symlink when publishing docs to GitHub Pages 3676b4ca Remove fast-forward-pr GitHub Action 96966350 Run all CI on release/* branches 61b8016e Clean up docs for optional return argument f8d63ac2 Clean up _convert_codeword_to_message() 1b36c35a Add output kwarg to FEC decode() methods 054b480a Add output kwarg to FEC encode() methods b3c4e6e2 Set docs page's "Last updated" field with git e43e396d Add unit tests for generalized BCH and RS codes fb04257d Clean up TypeError from verify_issubclass() 61f1849a Fix console syntax highlighting in README f0f35f16 Remove old g(x) to G and H functions 2dd16354 Modify ReedSolomon to support general Reed-Solomon codes over GF(q) 189fa0b6 Remove bch_valid_codes() from public API 4a91a040 Use binary search when finding BCH d when n and k known 0a5b51ee Modify BCH to support general BCH codes over GF(q) dfe8ee9a Remove unnecessary pytest helper files 1fe55efc Fix the repr of Array and FieldArray when not subclasses 83bf603a Use pyproject.toml pytest settings in VS Code 3e173381 Add --showlocals to pyproject.toml pytest settings 3d47673b Add .coverage to gitignore 3f957dae Remove FEC helper functions from public API b1e42953 Move FEC unit tests into their own folders 11868e4f Run CI on PRs to version branches 676d0dd9 Fix docs publish on package release

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.1.2

Released November 9, 2022

Changes

Fixed major inefficiency when dividing an array by a scalar or smaller (broadcasted) array. (#429) ```python In [1]: import galois

In [2]: GF = galois.GF(31**5)

In [3]: x = GF.Random(10_000, seed=1); x Out[3]: GF([13546990, 14653018, 21619804, ..., 15507037, 24669161, 19116362], order=31^5)

In [4]: y = GF.Random(1, seed=2); y Out[4]: GF([23979074], order=31^5)

# v0.1.1 In [5]: %timeit x / y 261 ms ± 5.67 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# v0.1.2 In [5]: %timeit x / y 8.23 ms ± 51 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) - Optimized [`lagrange_poly()`](https://mhostetter.github.io/galois/v0.1.2/api/galois.lagrange_poly/) by adding a custom JIT-compilable routine. ([#432](https://github.com/mhostetter/galois/pull/432))python In [1]: import galois

In [2]: GF = galois.GF(13693)

In [3]: x = GF.Random(100, seed=1)

In [4]: y = GF.Random(100, seed=2)

# v0.1.1 In [5]: %timeit galois.lagrange_poly(x, y) 2.85 s ± 3.25 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# v0.1.2 In [5]: %timeit galois.lagrange_poly(x, y) 4.77 ms ± 190 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) - Added ability in [`FieldArray.row_reduce()`](https://mhostetter.github.io/galois/v0.1.2/api/galois.FieldArray.row_reduce/) to solve for an identity matrix on the right side of a matrix using the `eye` keyword argument. ([#426](https://github.com/mhostetter/galois/pull/426))python

import galois GF = galois.GF(31) A = GF([[16, 12, 1, 25], [1, 10, 27, 29], [1, 0, 3, 19]]) A.rowreduce() GF([[ 1, 0, 0, 11], [ 0, 1, 0, 7], [ 0, 0, 1, 13]], order=31) A.rowreduce(eye="right") GF([[ 5, 1, 0, 0], [27, 0, 1, 0], [17, 0, 0, 1]], order=31) - Removed comma separators in [`FieldArray.__str__()`](https://mhostetter.github.io/galois/v0.1.2/api/galois.FieldArray.__str__/) to be consistent with NumPy's use of `str()` and `repr()`. ([#432](https://github.com/mhostetter/galois/pull/432))python import galois GF = galois.GF(3**5, display="power") x = GF.Random((3, 4), seed=1) x GF([[α^185, α^193, α^49, α^231], [ α^81, α^60, α^5, α^41], [ α^50, α^161, α^151, α^171]], order=3^5) print(x) [[α^185 α^193 α^49 α^231] [ α^81 α^60 α^5 α^41] [ α^50 α^161 α^151 α^171]] ``- Modernized type annotations to use abbreviated notation. For example,a | binstead ofUnion[a, b]. ([#418](https://github.com/mhostetter/galois/pull/418)) - AddedSelf` type annotation where appropriate. (#420) - Updated documentation and improved examples. (#424, #430)

Contributors

Matt Hostetter (@mhostetter)

Commits

e07461b4 Add release notes for v0.1.2 db88a80d Don't display comma separator in FieldArray.__str__() 81dfe9ac JIT compile construction of Lagrange polys 7eed6401 JIT compile polynomial subtraction routine 3d090c82 JIT compile polynomial addition routine 7e8a6885 Make lagrange_poly() unit tests more robust 8b8a40e5 Add documentation about NumPy's subok kwarg b02314fa Fix typo in release notes 2a27178f Better support for np.convolve() for prime fields 8a692ffb Add unit tests for np.convolve() b131da15 Add dropdown tips to docs 6e089143 Add polynomial composition example 83cf2fc4 Add additional ipython-with-reprs usage 01f86f18 Clean up arithmetic examples 6ee9d792 Convert docs to use new ipython-with-reprs directive 670600da Add custom ipython-with-reprs Sphinx directive c17cd6a1 Fix inefficiency when dividing by a scalar 0e317c36 Add ability to row_reduce() to solve for I on the right side f165b023 Add verify_literal helper function eb007cfb Fix typo in array divmod example a973c5d5 Change admonition styling 251954e3 Fix <details> sections for arithmetic examples abdb71b2 Upgrade to latest Sphinx Immaterial 85b1b4ee Upgrade to Sphinx 5.3 dc49c7c9 Use built-in Material for Mkdocs linked content tabs instead of sphinx-design tabs d06d385e Upgrade to latest version of sphinx-immaterial 9e259559 Remove pytest-benchmark from [dev] dependencies until fixed 4fbc26fc Add more debug for docs build on package release 954742d5 Upgrade actions/download-artifact to v3 10aefa17 Upgrade actions/upload-artifact to v3 e3dc09a5 Upgrade codecov/codecov-action to v3 4f4b4c39 Upgrade tj-action/glob action to v15 6fe28de2 Upgrade GitHub Actions set-output command 29f2ff5d Upgrade setup-python action to v4 e3af9944 Fix NumPy set_printoptions() demo bc72d182 Fix display of union "short" type annotations in Sphinx bee9b753 Use PEP 585 type annotations in documentation bbc06f1d Add SPHINX_BUILD flag back 5991ae29 Use Self type hint throughout library 2a4d9456 Require typing_extensions 4.0.0 or greater for Self 46ef7beb Minor modification to ValueError messages 8677e90d Fix potentially unbound variable 78ec48cc Fix dangerous default value of empty dict f7b5c8ec Convert List[a, b] to list[a, b] 3aefcea2 Convert Tuple[a, b] to tuple[a, b] 0a4ec798 Convert Optional[a] to a | None a9a765ef Convert Union[a, b] to a | b 79655f22 Move view without verification to Array to fix type hinting 0eacac36 Run unit tests for code coverage on master 05f8c5e4 Run package build CI on master 76a98221 Run linting CI on master 72ee31da Use v3 of the checkout GitHub action 5e50c810 Add workflow dispatch to build versioned docs on demand

- Python
Published by github-actions[bot] over 3 years ago

galois - galois v0.1.1

Released September 2, 2022

Changes

Added support for NumPy 1.23. (#414)
Added seed keyword argument to random_prime(). (#409) python >>> galois.random_prime(100, seed=1) 2218840874040723579228056294021 >>> galois.random_prime(100, seed=1) 2218840874040723579228056294021
Deployed documentation to https://mhostetter.github.io/galois/latest/ with GitHub Pages. (#408)

Contributors

Matt Hostetter (@mhostetter)

Commits

1b87674c Add release notes for v0.1.1 ac57fc41 Fix code coverage 36c24138 Support NumPy 1.23 with Numba 0.56.2 8512651c Run CI tests with pytest-xdist 95b2910e Add pytest-xdist to dev dependencies f5abfac3 Ensures tests start with known state 498e26f4 Enable displaying local variables in event of test failure c58dbab4 Add seed kwarg to random_prime() f1741346 Fix LaTeX lexer 3cd2c559 Properly lex console output f67539a9 Fix lexer for .txt document b3584a00 Remove unnecessary SPHINX_BUILD flag 93c9a688 Simplify exporting public members of the API 1f63d388 Fix intermediate versions in CI builds 559ae653 Make "latest" first in version dropdown 2591ebb5 Update package metadata to point to docs on GitHub pages 0341cdaa Remove imports from public galois.typing module e1fa463a Update README links to point to GitHub pages deployment 632d85cc Avoid duplicate CI runs on master c89a8ec4 Show setuptools_scm version during package build 7a4c5990 Add deployment to GitHub pages d0ac1edf Add version dropdown to GitHub Pages docs build 875e069b Modify warning section in README 06035722 Remove extra v in version tag

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.1.0

Released August 27, 2022

Changes

First beta release!
Fixed PyPI package metadata.

Contributors

Matt Hostetter (@mhostetter)

Commits

58e0078 Add release notes for v0.1.0 f5c248e Fix PyPI project metadata 0526f30 Fix wait for wheel action on git pushes 1a6437b Run CI on pushes to master 0ee78ef Fix double v in version specifier

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.0.33

Released August 26, 2022

Breaking changes

Modified FEC encode(), detect(), and decode() methods to always return FieldArray instances, not np.ndarray. (#397)
- Invoke .view(np.ndarray) on the output to convert it back to a NumPy array, if needed.

Changes

Added support for ArrayLike inputs to FEC encode(), detect(), and decode() methods. (#397)
Modified library packaging to use pyproject.toml and a src/ source code folder. (#404)

Contributors

Matt Hostetter (@mhostetter)

Commits

750cce9 Add release notes for v0.0.33 3c099b9 Remove [doc] extra and add docs/requirements.txt a1ba9f3 Fix GitHub Actions 36b1e70 Revert "Clean up galois.typing namespace" a17442a Fix coverage of unreachable code 17b09a4 Make all GitHub Actions run independently 7faa30a Rename .yml files to .yaml fe309c0 Add and center GitHub Actions badges to README 5708261 Update build artifact retention to 30 days 129fa3a Minor cleanup to GitHub Actions 9efa0d1 Make release GitHub Action trigger on tag push 5bd0b69 Sort disabled pylint errors 3aacf4a Remove numpy from docs build requirements c822914 Fix code coverage not locating source code 60e2eb3 Fix typo in power representation 6beb19b Update GitHub Actions for new packaging 8ac3da3 Update documentation for new packaging 5dbccb8 Move galois/ to src/galois/ a0e29c0 Use setuptools_scm for versioning d8dde7d Convert from setup.cfg to pyproject.toml 8edc8b4 Use verify_isinstance() and verify_issubclass() throughout library d2c458a Rename _overrides.py to _helper.py a20bcfc Clean up galois.typing namespace c75a080 Fix display of inherited docstring in VS Code tooltips 974f60e Move FieldArrayMeta into _fields/_meta.py 14e6561 Update Sphinx Immaterial version to correctly display inherited docstrings 0ddcbd7 Accept ArrayLike to FEC encode/decode methods d0495cf Always return FieldArray from FEC encode/decode methods

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.0.32

Released July 28, 2022

Breaking changes

Changed "quadratic residue" language in Galois fields to "square". This seems to be more canonical. Quadratic residue connotes quadratic residue modulo $p$, which is a square in $\mathrm{GF}(p)$. However, a quadratic residue modulo $p^m$ is not a square in $\mathrm{GF}(p^m)$. Hopefully the "square" language is more clear. (#392)
- Renamed FieldArray.is_quadratic_residue to FieldArray.is_square.
- Renamed FieldArray.quadratic_residues to FieldArray.squares.
- Renamed FieldArray.quadratic_non_residues to FieldArray.non_squares.

Changes

Added support for Numba 0.56.x. (#389)
Added general logarithm base any primitive element in FieldArray.log(). (#385) python >>> GF = galois.GF(3**5) >>> x = GF.Random(10, low=1); x GF([215, 176, 52, 20, 236, 48, 217, 131, 13, 57], order=3^5) >>> beta = GF.primitive_elements[-1]; beta GF(242, order=3^5) >>> i = x.log(beta); i array([171, 240, 109, 65, 162, 57, 34, 166, 72, 56]) >>> np.array_equal(beta ** i, x) True
Added Pollard-$\rho$ discrete logarithm for certain $\mathrm{GF}(2^m)$ fields. The algorithm is only applicable to fields whose multiplicative group has prime order. It has complexity $O(\sqrt{n})$ compared to $O(n)$ for the brute-force algorithm. In this example, Pollard-$\rho$ is 1,650% faster than brute force. (#385) ```python In [3]: GF = galois.GF(2**19, compile="jit-calculate")

In [4]: galois.is_prime(GF.order - 1) Out[4]: True

In [5]: x = GF.Random(100, low=1, seed=1)

# v0.0.31 In [6]: %timeit np.log(x) 80.3 ms ± 55.8 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

# v0.0.32 In [6]: %timeit np.log(x) 4.59 ms ± 90.5 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) - Added Pohlig-Hellman discrete logarithm to replace the brute-force search. It has complexity $O(\sum e_i(\textrm{lg}\ n + \sqrt{p_i}))$ compared to $O(n)$ for the brute-force algorithm. It is especially efficient for fields whose multiplicative group has smooth order. In this example with $p^m - 1$ smooth, Pohlig-Hellman is **~3,000,000%** faster than brute force. ([#387](https://github.com/mhostetter/galois/pull/387))python In [3]: GF = galois.GF(491954233)

# The multiplicative group's order is smooth In [4]: galois.factors(GF.order - 1) Out[4]: ([2, 3, 7, 11, 19, 14011], [3, 1, 1, 1, 1, 1])

In [5]: x = GF.Random(1, low=1, seed=1)

# v0.0.31 In [6]: %timeit np.log(x) 1.82 s ± 2.95 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

# v0.0.32 In [6]: %timeit np.log(x) 61.3 µs ± 14.6 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) - Added Itoh-Tsujii inversion algorithm for extension fields, which is **35%** faster than inversion with Fermat's Little Theorem. ([#383](https://github.com/mhostetter/galois/pull/383))python In [3]: GF = galois.GF(109987**4)

In [4]: x = GF.Random(100, low=1, seed=1)

# v0.0.31 In [5]: %timeit np.reciprocal(x) 646 ms ± 834 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

# v0.0.32 In [5]: %timeit np.reciprocal(x) 479 ms ± 26.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) ``- Fixed a bug whereFieldArray` subclasses and instances could not be pickled. (#393)

Contributors

Matt Hostetter (@mhostetter)

Commits

bf1275a Version bump to 0.0.32 cc89ff1 Add release notes for v0.0.32 4270191 Use LaTeX math in old release notes 9e6fdaf Allow $...$ math notation in .md documents b0ff7fd Update Sphinx Immaterial to remove rubrics from left TOC 97eb7a2 Add FieldArray class and instance pickling unit tests 3fc1cbb Support pickling FieldArray subclasses and instances d94c3b6 Rename FieldArray.quadratic_non_residues to FieldArray.non_squares ea714b3 Rename FieldArray.quadratic_residues to FieldArray.squares 2c33d99 Rename FieldArray.is_quadratic_residue() to FieldArray.is_square() ce1e4cf Revert minor README edit 80f1e79 Minor README edit (to test --ff-only merge) 5540337 Fix error in --ff-only merge action 61b03be Add fast-forward merge GitHub action for PRs 7781e01 Add support for Numba 0.56.x a291a0e Move lookup table construction to _lookup.py 7f28770 Add Pohlig-Hellman discrete logarithm b5d452c Rename variables to be consistent with textbook algorithm 106dc72 Add CRT helper JIT function 198b1b3 Add unit test for Pollard-rho logarithm 1957c25 Add Pollard-rho discrete logarithm for some GF(2^m) fields 7dbe38f Ensure lookup tables were created before compiling lookup ufuncs ed5b9e4 Add unit test for arbitrary logarithm e12d3a4 Add arbitrary logarithm in FieldArray.log 036d3eb Raise an arithmetic error is log base non-primitive element b3fb252 Reorganize default ufunc dispatcher definitions 182a493 Update benchmark stats 7b26bc6 Add square-and-multiply helper ufunc 7878c7a Use Itoh-Tsujii inversion algorithm for reciprocal in extension fields

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.0.31

Released July 24, 2022

Breaking changes

Renamed FieldArray.Elements() classmethod to FieldArray.elements class property. This naming convention is more consistent with primitive_elements, units, quadratic_residues, and quadratic_non_residues. (#373) python >>> GF = galois.GF(3**2, display="poly") >>> GF.elements GF([ 0, 1, 2, α, α + 1, α + 2, 2α, 2α + 1, 2α + 2], order=3^2)
Renamed BCH.systematic to BCH.is_systematic. (#376)
Renamed ReedSolomon.systematic to ReedSolomon.is_systematic. (#376)

Changes

Added support for polynomial composition in Poly.__call__(). (#377) python >>> GF = galois.GF(3**5) >>> f = galois.Poly([37, 123, 0, 201], field=GF); f Poly(37x^3 + 123x^2 + 201, GF(3^5)) >>> g = galois.Poly([55, 0, 1], field=GF); g Poly(55x^2 + 1, GF(3^5)) >>> f(g) Poly(77x^6 + 5x^4 + 104x^2 + 1, GF(3^5))
Added FieldArray.units class property. (#373) python >>> GF = galois.GF(3**2, display="poly") >>> GF.units GF([ 1, 2, α, α + 1, α + 2, 2α, 2α + 1, 2α + 2], order=3^2)

Documentation

Reworked API reference using Sphinx Immaterial's python-apigen. (#370)
Shortened website URLs to use directories. https://galois.readthedocs.io/en/v0.0.30/getting-started.html is converted to https://galois.readthedocs.io/en/v0.0.31/getting-started/. (#370)

Contributors

Matt Hostetter (@mhostetter)

Commits

d50f88b Version bump to 0.0.31 5a3b484 Add release notes for v0.0.31 4df5d7b Move primitive element functions into _fields/ folder 23337ad Clean up math equations 373a246 Remove math notation from individual numbers 4619383 Include rubrics in docstring in the local TOC cb25b40 Update hyperlinks to use the new dirhtml style e6acdfd Add polynomial composition unit test 30aa67e Add support for polynomial composition 0e63b7c Clarify type hint for primitive_element in GF() 5cf9161 Make poly evaluation at a matrix a private function 8d7a8b8 Make operand verification private functions 2f667d8 Make _convert_coeffs a private function 8613f22 Make _root_multiplicity a private function 371d7b1 Rename systematic property to is_systematic e8f58ce Modify Sphinx Immaterial linkable parameter coloring cae910d Indicate in docs that the dirhtml builder is used 2b2e5bf Fix search in dirhtml docs builds eacf60f Add units and quadratic_residues to Array Creation page 9a4366c Remove OBE note on GF2 docstring 9a7ccb9 Add FieldArray.units class property 31ad02b Move FieldArray.Elements() to the FieldArray.elements property 1306f91 Make class property monkey patching for docs more algorithmic f34038f Remove unnecessary autosummary templates 7a50cc1 Do not use "Tests" sections in classes dd9476f Add note about polymorphic polynomial functions 9fc2b29 Clean up vector space method docstrings d9f6fdb Remove unnecessary private methods from FieldArray 649bd10 Add basic docstrings to Array class properties 4635f81 Suppress private base classes from class documentation ffee1bd Remove pandoc from CI docs build ecefd5f Remove need for explicit forward references 4a5381c Use Sphinx Immaterial's conversion of type annotations ce1bdde Use the Sphinx dirhtml builder for cleaner URLs a0133d3 Use Sphinx Immaterial's python-apigen for API Reference

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.0.30

Released July 12, 2022

Changes

Added support for NumPy 1.22 with Numba 0.55.2. This allows users to upgrade NumPy and avoid recently-discovered vulnerabilities CVE-2021-34141, CVE-2021-41496, and CVE-2021-41495. (#366)
Made FieldArray.repr_table() more compact. (#367) ```python In [2]: GF = galois.GF(3**3)

In [3]: print(GF.repr_table()) Power Polynomial Vector Integer

 0           0         [0, 0, 0]      0
x^0          1         [0, 0, 1]      1
x^1          x         [0, 1, 0]      3
x^2         x^2        [1, 0, 0]      9
x^3        x + 2       [0, 1, 2]      5
x^4       x^2 + 2x     [1, 2, 0]      15
x^5     2x^2 + x + 2   [2, 1, 2]      23
x^6     x^2 + x + 1    [1, 1, 1]      13
x^7     x^2 + 2x + 2   [1, 2, 2]      17
x^8       2x^2 + 2     [2, 0, 2]      20
x^9        x + 1       [0, 1, 1]      4
x^10      x^2 + x      [1, 1, 0]      12
x^11    x^2 + x + 2    [1, 1, 2]      14
x^12      x^2 + 2      [1, 0, 2]      11
x^13         2         [0, 0, 2]      2
x^14         2x        [0, 2, 0]      6
x^15        2x^2       [2, 0, 0]      18
x^16       2x + 1      [0, 2, 1]      7
x^17      2x^2 + x     [2, 1, 0]      21
x^18    x^2 + 2x + 1   [1, 2, 1]      16
x^19   2x^2 + 2x + 2   [2, 2, 2]      26
x^20    2x^2 + x + 1   [2, 1, 1]      22
x^21      x^2 + 1      [1, 0, 1]      10
x^22       2x + 2      [0, 2, 2]      8
x^23     2x^2 + 2x     [2, 2, 0]      24
x^24   2x^2 + 2x + 1   [2, 2, 1]      25
x^25      2x^2 + 1     [2, 0, 1]      19

- Made `FieldArray.arithmetic_table()` more compact. ([#367](https://github.com/mhostetter/galois/pull/367))python In [2]: GF = galois.GF(13)

In [3]: print(GF.arithmetic_table("*")) x * y | 0 1 2 3 4 5 6 7 8 9 10 11 12 ------|---------------------------------------------------- 0 | 0 0 0 0 0 0 0 0 0 0 0 0 0 1 | 0 1 2 3 4 5 6 7 8 9 10 11 12 2 | 0 2 4 6 8 10 12 1 3 5 7 9 11 3 | 0 3 6 9 12 2 5 8 11 1 4 7 10 4 | 0 4 8 12 3 7 11 2 6 10 1 5 9 5 | 0 5 10 2 7 12 4 9 1 6 11 3 8 6 | 0 6 12 5 11 4 10 3 9 2 8 1 7 7 | 0 7 1 8 2 9 3 10 4 11 5 12 6 8 | 0 8 3 11 6 1 9 4 12 7 2 10 5 9 | 0 9 5 1 10 6 2 11 7 3 12 8 4 10 | 0 10 7 4 1 11 8 5 2 12 9 6 3 11 | 0 11 9 7 5 3 1 12 10 8 6 4 2 12 | 0 12 11 10 9 8 7 6 5 4 3 2 1 ```

Contributors

Iyán Méndez Veiga (@iyanmv)
Matt Hostetter (@mhostetter)

Commits

84ca4e1 Version bump to 0.0.30 740f888 Add release notes for v0.0.30 1deead9 Pin Sphinx to v4.5 for docs build ec52ec3 Lower minimum required NumPy versions 6b6a20f Add type hints to ufunc dispatchers afb5938 Add Python syntax highlighting to inline code 501a323 Use mathjax in GitHub-flavored markdown 0c8e5c8 Update pylint and linter errors 5c1dc7b Make arithmetic_table() output more compact a05b58a Make repr_table() output more compact d7d6988 Add support for numpy 1.22

- Python
Published by github-actions[bot] almost 4 years ago

galois - galois v0.0.29

Released May 18, 2022

Breaking changes

Moved galois.square_free_factorization() function into Poly.square_free_factors() method. (#362)
Moved galois.distinct_degree_factorization() function into Poly.distinct_degree_factors() method. (#362)
Moved galois.equal_degree_factorization() function into Poly.equal_degree_factors() method. (#362)
Moved galois.is_irreducible() function into Poly.is_irreducible() method. This is a method, not property, to indicate it is a computationally-expensive operation. (#362)
Moved galois.is_primitive() function into Poly.is_primitive() method. This is a method, not property, to indicate it is a computationally-expensive operation. (#362)
Moved galois.is_monic() function into Poly.is_monic property. (#362)

Changes

Added galois.set_printoptions() function to modify package-wide printing options. This is the equivalent of np.set_printoptions(). (#363) ```python In [1]: GF = galois.GF(3**5, display="poly")

In [2]: a = GF([109, 83]); a Out[2]: GF([α^4 + α^3 + 1, α^4 + 2], order=3^5)

In [3]: f = galois.Poly([3, 0, 5, 2], field=galois.GF(7)); f Out[3]: Poly(3x^3 + 5x + 2, GF(7))

In [4]: galois.set_printoptions(coeffs="asc")

In [5]: a Out[5]: GF([1 + α^3 + α^4, 2 + α^4], order=3^5)

In [6]: f Out[6]: Poly(2 + 5x + 3x^3, GF(7)) ``- Addedgalois.getprintoptions()function to return the current package-wide printing options. This is the equivalent ofnp.getprintoptions(). ([#363](https://github.com/mhostetter/galois/pull/363)) - Addedgalois.printoptions()context manager to modify printing options inside of awithstatement. This is the equivalent ofnp.printoptions(). ([#363](https://github.com/mhostetter/galois/pull/363)) - Added a separatePoly.factors()method, in addition to the polymorphicgalois.factors(). ([#362](https://github.com/mhostetter/galois/pull/362)) - Added a separatePoly.issquarefree()method, in addition to the polymorphicgalois.issquarefree(). This is a method, not property, to indicate it is a computationally-expensive operation. ([#362](https://github.com/mhostetter/galois/pull/362)) - Fixed a bug (believed to be introduced in v0.0.26) wherePoly.degreeoccasionally returnednp.int64instead ofint`. This could cause overflow in certain large integer operations (e.g., computing $q^m$ when determining if a degree-$m$ polynomial over $\mathrm{GF}(q)$ is irreducible). When the integer overflowed, this created erroneous results. (#360, #361) - Increased code coverage.

Contributors

Matt Hostetter (@mhostetter)

Commits

efc645e Version bump to 0.0.29 810bca8 Add release notes for v0.0.29 db27b73 Use consistent section capitalization bb75879 Use decorator for the FieldArray.display() context manager 992c215 Add galois.printoptions() context manager b77cabf Modify Sphinx explicit references b2987bc Add set_printoptions() tips in docs 3d72707 Add get/set_printoptions() functions 5c03168 Add index page to docs 7356465 Update documentation prose a8d5086 Update minimum Sphinx version cd312a1 Verify factored polynomials are indeed square-free a64b771 Add Poly.is_square_free() 9f029c1 Move galois.is_primitive() to Poly.is_primitive() 008b971 Move galois.is_irreducible() to Poly.is_irreducible() 89e8ec7 Move galois.is_monic() to the Poly.is_monic property e0a3e24 Make polynomial factorization functions Poly methods 062a118 Add Poly.factors() method fe379c3 Add additional unit test 3eeb4ec Always return int from Poly.degree c5d930d Increase NTT code coverage eadc6a3 Improve class factory code coverage 94db928 Increase primitive element code coverage 26e91c5 Increase Array code coverage 450fb3e Improve LFSR code coverage

- Python
Published by github-actions[bot] about 4 years ago

galois - galois v0.0.28

Released May 11, 2022

Changes

Modified JIT-compiled functions to use explicit calculation or lookup tables. Previously, JIT functions only used explicit calculation routines. Now all ufuncs and functions are JIT-compiled once on first invocation, but use the current ufunc_mode to determine the arithmetic used. This provides a significant performance boost for fields which use lookup tables by default. The greatest performance improvement can be seen in $\mathrm{GF}(p^m)$ fields. (#354)
- Polynomial multiplication is 210% faster. ```python In [2]: GF = galois.GF(7**5)
In [3]: f = galois.Poly.Random(10, seed=1, field=GF)

In [4]: g = galois.Poly.Random(5, seed=2, field=GF)

v0.0.27

In [6]: %timeit f * g 168 µs ± 722 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

v0.0.28

In [6]: %timeit f * g 54 µs ± 574 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each) - Polynomial modular exponentiation is **5,310% faster**.python

v0.0.27

In [8]: %timeit pow(f, 123456789, g) 5.9 ms ± 9.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

v0.0.28

In [8]: %timeit pow(f, 123456789, g) 109 µs ± 527 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each) - Matrix multiplication is **6,690% faster**.python In [9]: A = GF.Random((100, 100), seed=1)

In [10]: B = GF.Random((100, 100), seed=2)

v0.0.27

In [12]: %timeit A @ B 1.1 s ± 4.76 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

v0.0.28

In [12]: %timeit A @ B 16.2 ms ± 50.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ```
Simplified FieldArray subclasses' repr() and str(). Since these classes may be displayed in error logs, a concise representation is necessary. (#350) ```python

GF = galois.GF(3**5) GF ```
Added back FieldArray.properties for a detailed description of the finite field's relevant properties. (#350) ```python

GF = galois.GF(3**5) print(GF.properties) Galois Field: name: GF(3^5) characteristic: 3 degree: 5 order: 243 irreduciblepoly: x^5 + 2x + 1 isprimitivepoly: True primitiveelement: x ```
Increased code coverage.
Various documentation fixes.

Contributors

Matt Hostetter (@mhostetter)

Commits

4e0a68b Version bump to 0.0.28 ab0163f Add release notes for v0.0.28 7a4b6b2 Ensure GF(2) is compiled by default d488ceb Add polynomial "right" arithmetic 662e294 Add remainder unit test 0bc0198 Add divmod unit test 0f2c7ea Indicate no test coverage where necessary c98df85 Fix indentation of code blocks in bulleted lists 8d71f8a Fix hiding dot() method from Array API docs 2078aa9 Provide an additional benchmark example b5493e9 Adjust benchmark run array lengths ffae1ae Create and utilize ufunc and function dispatchers fc9265f Rework polynomial JIT function structure 2ca4d16 Rework FEC code JIT function structure 220a669 Fix Literal defaults in overloaded functions b8f0839 Rename Ufuncs to UFuncs 25064e9 Always dynamically compile ufuncs e356fb9 Update sphinx-immaterial version bcc8cba Fix incorrect reference f828267 Clean up explicit calculation inheritance aee74b7 Clean up class str() and repr() c8372bb Clean up API table of contents 1ddbfeb Prevent "Parameters" sections in docs API 657326f Update API TOC structure 0788cf3 Fix galois.typing module documentation links c8ab245 Clean up Array default monkey patching 8885574 Improve type hints 6b34647 Rename mixin classes 6aa410a Move polynomial JIT functions into their own file 6d5b872 Restructure linear algebra code 124aeb1 Inherit from ABC for abstract base classes 152366a Move ufunc- and function-overridding code 01cd714 Use public properties instead of internal attributes e9d6806 Move placeholder factory functions into _factory.py eefce37 Move all type aliases into typing.py 97a391d Move ArrayMeta to _meta.py 03919da Merge metaclasses into one in _meta.py 39ec643 Additional fix when monkey-patching for docs 55c5d8c Fix missing type signatures

- Python
Published by github-actions[bot] about 4 years ago

galois - galois v0.0.27

Released April 22, 2022

Breaking Changes

Sunsetted support for Python 3.6. This was necessary to support forward references with from __future__ import annotations (available in Python 3.7+). That import is required to support the type aliases in the new galois.typing subpackage. (#339)
Removed the FieldClass metaclass from the public API. It was previously included due to an inability of Sphinx to document class properties. In this release, we monkey patched Sphinx to document all classmethods, class properties, and instance methods in FieldArray itself. (#343)
- Use issubclass(GF, galois.FieldArray) anywhere isinstance(GF, galois.FieldClass) was previously used.
- Annotate with Type[galois.FieldArray] anywhere galois.FieldClass was previously used.

Changes

Added the galois.typing subpackage, similar to np.typing. It contains type hints for common coercible data types used throughout the library, including ElementLike, ArrayLike, and PolyLike. With these type hints, the annotations are simpler and more clear. (#339)
Modified functions to accept coercible data types wherever possible. For example, functions now accept PolyLike objects instead of strictly Poly instances. (#339)
Added Array which is an abstract base class of FieldArray (and RingArray in a future release). (#336)
Added support for the DFT over any finite field using np.fft.fft() and np.fft.ifft(). (#335) python >>> x GF([127, 191, 69, 35, 221, 242, 193, 108, 72, 102, 80, 163, 13, 74, 218, 159, 207, 12, 159, 129, 92, 71], order=3^5) >>> X = np.fft.fft(x); X GF([ 16, 17, 20, 137, 58, 166, 178, 52, 19, 109, 115, 93, 99, 214, 187, 235, 195, 96, 232, 45, 241, 24], order=3^5) >>> np.fft.ifft(X) GF([127, 191, 69, 35, 221, 242, 193, 108, 72, 102, 80, 163, 13, 74, 218, 159, 207, 12, 159, 129, 92, 71], order=3^5)
Implemented the Cooley-Tukey radix-2 $O(N\ \textrm{log}(N))$ algorithm for the NTT and JIT compiled it. (#333) ```python In [2]: x = list(range(1, 1024 + 1))

v0.0.26

In [4]: %timeit X = galois.ntt(x) 5.2 ms ± 121 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

v0.0.27

In [4]: %timeit X = galois.ntt(x) 695 µs ± 4.56 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each) ```
Added the FieldArray.primitive_root_of_unity() classmethod. (#333) ```python

GF = galois.GF(3**5) GF.primitiverootof_unity(22) GF(39, order=3^5) ```
Added the FieldArray.primitive_roots_of_unity() classmethod. (#333) ```python

GF = galois.GF(3**5) GF.primitiverootsof_unity(22) GF([ 14, 39, 44, 59, 109, 114, 136, 200, 206, 226], order=3^5) ```
Made 0-th degree coefficients more differentiated when using the polynomial element representation. (#328) ```python

v0.0.26

print(f) (α^2 + α + 1)x^4 + (α^3)x + α^3 + 2α^2 + 2α + 2

v0.0.27

print(f) (α^2 + α + 1)x^4 + (α^3)x + (α^3 + 2α^2 + 2α + 2) ```
Restructured code base for clarity. (#336)
Fixed display of overloaded functions in API reference. (#337)
Fixed broken "References" sections in API reference. (#281)
Fixed other small bugs.

Contributors

Matt Hostetter (@mhostetter)

Commits

2284442 Version bump to 0.0.27 db5c312 Add release notes for v0.0.27 f5376fd Monkey-patch class properties in conf.py e3d7029 Clean-up .. math:: directives d00abbc Hide Array and GF2 inherited methods and properties 98c2272 Update README d036af6 Remove metaclasses from API 7a3a2e6 Replace recommonmark with myst-parser 429a920 Fix error in ElementLike type hint 1e23c36 Use short object references in docs 96376b9 Add galois.typing subpackage and simplify type hints f08101e Remove support for Python 3.6 c2766b7 Differentiate Reed-Solomon repr() and str() 6046729 Differentiate BCH repr() and str() da5c8c9 Remove numba from inter-Sphinx mapping 0c34f4f Fix bug in Poly.degree when poly was zero a76c9f3 Simplify private function names 2f8c905 Fix improper circular import 4a8f34e Display overloaded signatures in docs 7259161 Move irreducible/primitve poly and primitive element functions into _polys/ folder de87b1f Rename FieldClass to FieldArrayClass b2a28fc Restructure polynomial code 630e638 Restructure code and import hierarchy 5d8d29e Update docs to add info about the FFT 1435b22 Add unit tests for the FFT over arbitrary fields e80d1b3 Support the DFT over any finite field 16544b9 Fix FFT recursion for non-compiled case fcd7c97 Properly set module for pollard_rho() 42217c8 Do not expose LRU cache wrappers in public API 0719969 Implement the radix-2 Cooley-Tukey FFT algorithm ab58cde JIT compile the O(N^2) NTT d5f9e94 Remove pylint pin before v2.13.0 8ae0848 Cached primitive elements are calculation 481b09f Clean-up class private attributes 29281f9 Add FieldClass.primitive_roots_of_unity() 01fe13c Add FieldClass.primitve_root_of_unity() 592da2c Update Google Analytics config of sphinx-immaterial 9587e30 Fix "References" sections in docstrings 05b2e4e Add social links to bottom of webpage 995b76b Add Jupyter notebook checkpoints to gitignore d4739e3 Add virtual environments to gitignore 303418b Add () around 0-degree coefficient if it has a + separator 5f011ae Fix percentages in release notes for v0.0.26

- Python
Published by github-actions[bot] about 4 years ago

galois - galois v0.0.26

Released March 30, 2022

Breaking Changes

Removed the Poly.copy() method as it was unnecessary. Polynomial objects are immutable. Use g = f wherever g = f.copy() was previously used. (#320)
Disabled true division f / g on polynomials since true division was not actually being performed. Use floor division f // g moving forward. (#312)
Refactored irreducible_polys() to return an iterator rather than list. Use list(irreducible_polys(...)) to obtain the previous output. (#325)
Refactored primitive_polys() to return an iterator rather than list. Use list(primitive_polys(...)) to obtain the previous output. (#325)
Refactored primitive_root() and primitive_roots(). (#325)
- Added method keyword argument and removed reverse from primitive_root(). Use primitive_root(..., method="max") where primitive_root(..., reverse=True) was previously used.
- Refactored primitive_roots() to now return an iterator rather than list. Use list(primitive_roots(...)) to obtain the previous output.
Refactored primitive_element() and primitive_elements(). (#325)
- Added method keyword argument to primitive_element().
- Removed start, stop, and reverse arguments from both functions.
Search functions now raise RuntimeError instead of returning None when failing to find an answer. This applies to primitive_root(), pollard_p1(), and pollard_rho(). (#312)

Changes

The galois.Poly class no longer returns subclasses BinaryPoly, DensePoly, and SparsePoly. Instead, only Poly classes are returned. The classes otherwise operate the same. (#320)
Made Galois field array creation much more efficient by avoiding redundant element verification. (#317)
- Scalar creation is 625% faster. ```python In [2]: GF = galois.GF(3**5)
  
  v0.0.25
  
  In [3]: %timeit GF(10) 21.2 µs ± 181 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
  
  v0.0.26
  
  In [3]: %timeit GF(10) 2.88 µs ± 8.03 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each) ```
- Nested iterable array creation is 150% faster. ```python
  
  v0.0.25
  
  In [4]: %timeit GF([[10, 20], [30, 40]]) 53.6 µs ± 436 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
  
  v0.0.26
  
  In [4]: %timeit GF([[10, 20], [30, 40]]) 20.9 µs ± 11.2 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) ```
- Nested iterable (with strings) array creation is 25% faster. ```python
  
  v0.0.25
  
  In [5]: %timeit GF([[10, "2x^2 + 2"], ["x^3 + x", 40]]) 67.9 µs ± 910 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
  
  v0.0.26
  
  In [5]: %timeit GF([[10, "2x^2 + 2"], ["x^3 + x", 40]]) 54.7 µs ± 16.3 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) ```
Made array arithmetic 35% faster by avoiding unnecessary element verification of outputs. (#309) ```python In [2]: GF = galois.GF(3**5)

In [3]: x = GF.Random((10_000), seed=1)

In [4]: y = GF.Random((10_000), seed=2)

v0.0.25

In [6]: %timeit x * y 39.4 µs ± 237 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

v0.0.26

In [6]: %timeit x * y 28.8 µs ± 172 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each) ```
Made polynomial arithmetic over binary fields 10,900% faster by making polynomial creation from integers much more efficient. (#320) ```python In [5]: f Out[5]: Poly(x^10 + x^9 + x^6 + x^5 + x^3 + x, GF(2))

In [6]: g Out[6]: Poly(x^10 + x^7 + x^4 + 1, GF(2))

v0.0.25

In [7]: %timeit f * g 283 µs ± 6.31 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

v0.0.26

In [7]: %timeit f * g 2.57 µs ± 54.4 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each) ```
JIT-compiled polynomial modular exponentiation. (#306)
- Binary fields are 14,225% faster. ```python In [5]: f Out[5]: Poly(x^10 + x^9 + x^6 + x^5 + x^3 + x, GF(2))
  
  In [6]: g Out[6]: Poly(x^5 + x^2, GF(2))
  
  v0.0.25
  
  In [7]: %timeit pow(f, 123456789, g) 19.2 ms ± 206 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
  
  v0.0.26
  
  In [7]: %timeit pow(f, 123456789, g) 134 µs ± 2.21 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) ```
- Other fields are 325% faster. ```python In [6]: f Out[6]: Poly(242x^10 + 216x^9 + 32x^8 + 114x^7 + 230x^6 + 179x^5 + 5x^4 + 124x^3 + 96x^2 + 159x + 77, GF(3^5))
  
  In [7]: g Out[7]: Poly(183x^5 + 83x^4 + 101x^3 + 203x^2 + 68x + 2, GF(3^5))
  
  v0.0.25
  
  In [8]: %timeit pow(f, 123456789, g) 17.6 ms ± 61.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
  
  v0.0.26
  
  In [8]: %timeit pow(f, 123456789, g) 4.19 ms ± 11.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ```
Made irreducible and primitive polynomial search routines faster. (#306, #309, #317, #320)
- Binary fields are 1,950% faster. ```python
  
  v0.0.25
  
  In [2]: %time f = galois.primitive_poly(2, 14) CPU times: user 296 ms, sys: 70.9 ms, total: 367 ms Wall time: 313 ms
  
  v0.0.26
  
  In [2]: %time f = galois.primitive_poly(2, 14) CPU times: user 14.7 ms, sys: 5.53 ms, total: 20.2 ms Wall time: 15.3 ms ```
- Other fields are 400% faster. ```python
  
  v0.0.25
  
  In [5]: %time f = galois.primitive_poly(7, 10) CPU times: user 2.22 s, sys: 0 ns, total: 2.22 s Wall time: 2.21 s
  
  v0.0.26
  
  In [4]: %time f = galois.primitive_poly(7, 10) CPU times: user 442 ms, sys: 0 ns, total: 442 ms Wall time: 439 ms ```
Made FieldArray.Vector() 100% faster and FieldArray.vector() 25% faster by making better use of divmod() when converting between integer and vector representations. (#322)

Contributors

Matt Hostetter (@mhostetter)

Commits

53c622e Version bump to 0.0.26 895053a Add release notes for v0.0.26 348c61a Update performance pages with latest speeds 429f0d8 Remove jinja2 pin since it was resolved in sphinx-immaterial upstream 810a3de Add "See Also" sections to docstrings 6ab4a49 Refactor primitive_element() and primitive_elements() 1273d16 Add private constructor Poly._PolyLike() fc52679 Refactor primitive_roots() to return an iterator 4985853 Memoize euler_phi() 645f755 Refactor primitve_polys() to return an iterator 30d554f Refactor irreducible_polys() to return an iterator 7d9f642 Raise RuntimeError rather than return None for pollard_rho() 7b3711a Raise RuntimeError rather than return None for pollard_p1() 9a38498 Ensure dtype=object arrays always have int objects, even after assignment 1d30fb9 Better use of divmod() in int/poly conversion for GF(p^m) fields a055e5b Speed-up Vector() and vector() using better use of divmod() 1a81be4 Adjust dense/sparse poly arithmetic threshold 864c977 Refactor Poly inheritance of BinaryPoly, DensePoly, and SparsePoly cf84272 Remove brackets around the 0-th degree coefficient in poly strings 3ebc562 Make poly/int conversion more efficient 05ec7b4 Remove Poly.copy() method a454532 Pin pylint before v2.13.0 b734de3 Speed-up array creation, especially 0-D arrays 74305d1 Ignore dtype check with performing an internal "cheap view" c2e0404 Avoid jinja2 bug until fixed in sphinx-immaterial 1c99193 Fix typo in Getting Started guide 8bbb1ee Disable true division on polynomials d86609b Fix NumPy capitalization in comments a9e1f9b Remove function that no longer exists from reference list 5354a1f Enable arbitarily-large exponents to JIT-compiled poly pow() b6347b6 Avoid array element range verification for internal .view(GF) conversions 9b1849d Cleanup FieldClass.display() context manager fb20569 Modify CSS rules so sphinx-design tabs match the theme better 5869373 Fix BibTeX label 0999e4e Fix typo in Galois LFSR step docstring a7624fc JIT compile polynomial modular exponentiation dc5dca8 JIT compile separate polynomial div and mod functions fa43cc1 Save 1 unnecessary calculation in poly divmod

- Python
Published by github-actions[bot] over 4 years ago

galois - galois v0.0.25

Released March 21, 2022

Breaking Changes

Separated LFSR into FLFSR/GLFSR and fixed/redefined terms (feedback poly, characteristic poly, state). (#285)
Removed galois.pow() and replaced it with the built-in pow(). (#300) python >>> f = galois.Poly([6, 3, 0, 1], field=galois.GF(7)) >>> g = galois.Poly([5, 0, 3], field=galois.GF(7)) >>> pow(f, 123456789, g) Poly(6x + 2, GF(7))
Removed FieldClass.properties and replaced with FieldClass.__str__. (#289) python >>> GF = galois.GF(3**5) >>> print(GF) Galois Field: name: GF(3^5) characteristic: 3 degree: 5 order: 243 irreducible_poly: x^5 + 2x + 1 is_primitive_poly: True primitive_element: x
Differentiated repr() and str() for Galois field arrays, like NumPy. repr() displays the finite field's order, but str() does not. python >>> GF = galois.GF(31, display="power") >>> x = GF([1, 23, 0, 15]) >>> x GF([ 1, α^27, 0, α^21], order=31) >>> print(x) [ 1, α^27, 0, α^21]
Renamed Poly.String() to Poly.Str(). Removed Poly.string and replaced it with Poly.__str__. (#300) python >>> f = galois.Poly.Str("x^3 + x + 1"); f Poly(x^3 + x + 1, GF(2)) >>> str(f) 'x^3 + x + 1'
Renamed Poly.Integer() to Poly.Int(). Removed Poly.integer and replaced it with Poly.__int__. (#300) python >>> f = galois.Poly.Int(11); f Poly(x^3 + x + 1, GF(2)) >>> int(f) 11

Changes

Fixed bug in Fibonacci/Galois LFSRs where feedback polynomial wasn't interpreted correctly for fields with characteristic greater than 2. (#299)
Utilized memoization for expensive search routines (irreducible_poly() and primitive_poly()) to speed-up subsequent calls. (#295) ```python In [2]: %time galois.primitive_poly(7, 4) CPU times: user 675 ms, sys: 6.24 ms, total: 682 ms Wall time: 741 ms Out[2]: Poly(x^4 + x^2 + 3x + 5, GF(7))

In [3]: %time galois.primitive_poly(7, 4) CPU times: user 30 µs, sys: 0 ns, total: 30 µs Wall time: 31.7 µs Out[3]: Poly(x^4 + x^2 + 3x + 5, GF(7)) ```
Added support for bin(), oct(), and hex() on Poly objects. (#300) ```python

f = galois.Poly.Int(11); f Poly(x^3 + x + 1, GF(2)) bin(f) '0b1011' oct(f) '0o13' hex(f) '0xb' ```
Made Galois field arrays display with fixed-width elements, like NumPy. (#270)
Achieved speed-up of repr() and str() on Galois field arrays of at least 25x. Achieved a much greater speed-up for large arrays, since now elements converted to ... are no longer needlessly converted to their string representation. (#270)
Overhauled documentation and website. Type hints are now displayed in the API reference. (#263)
Various bug fixes.

Contributors

Matt Hostetter (@mhostetter)

Commits

f9b6cab Version bump to 0.0.25 989657f Add release notes for v0.0.25 c2e3def Update feature list 98b9f3f Make GF() docstring more readable with a tab set a401abf Document poly arithmetic only on the Basic Usage page 3edc4e9 Remove galois.pow(), instead use built-in pow() 7f8ce52 Define Poly.__index__() to support bin(), oct(), and hex() 6816adc Remove unnecessary __ne__() definition 45db3a5 Rename Poly.Integer to Poly.Int d05ce1b Replace Poly.integer with int(poly) 4a3ff9d Rename Poly.String() to Poly.Str() 47eb6f5 Replace Poly.string with str(poly) af3e6ee Remove unused section in API reference 7c2b1f0 Do not fail CI if codecov fails to upload d3be8ab Complete overhaul of LFSRs and fix bug when p > 2 f691bb5 Memoize slow polynomial search functions 2bd30ef Differentiate str() and repr() for FieldArray 1b102d1 Remove unnecessary tabs in docstring 5b5c65c Replace FieldClass.properties with FieldClass.__str__() 3ec09d3 Separate LFSR into FLFSR and GLFSR 1a2a8e7 Build the docs with Python 3.8 on Read the Docs b373d45 Fix properties formatting for prime fields in power display mode 3881ea0 Fix typos in finite field tutorials 1aceed0 Display type hints in API documentation 5efd39c Add tabbed sections with different reprs in basic usage 1dd41e1 Add tabbed sections with different reprs for tutorials c63fecf Modify the CSS rules for tab-set from sphinx-design 1018fd5 Add sphinx-design dependency for tabbed sections b77e999 Switch light/night mode icons 337ef93 Update BibTeX citation 88487c1 Remove unnecessary doc dependencies 005c493 Revert autosummary table fix since already fixed in upstream 5799874 Separate Poly class and init docstrings 5553d0f Revert use of box drawing glyphs for monospace consistency with more fonts aaebb3d Remove NumPy reference and use Basic Usage articles instead 2f24414 Remove old basic usage file 7e19eab Fix autosummary strange line wrapping f28176d Add more detail in the field element representation docs 603c03d Update Getting Started guide with new array repr() fd9a57c Make repr() more efficient for large arrays 3c4c2d4 Make "poly" display mode use fixed widths 7ffd551 Make "poly" display mode more efficient for prime fields 3a0c668 Use fixed widths in "power" display mode for all array sizes b506f1b Make __repr__() more efficient 6872b7a Initial docs port to sphinx-immaterial

- Python
Published by github-actions[bot] over 4 years ago

galois - galois v0.0.24

Breaking Changes

Move galois.minimal_poly() functionality into FieldArray.minimal_poly().
Refactor FieldArray.lup_decompose() into FieldArray.plu_decompose().
Raise ValueError instead of returning None for prev_prime(2).
Return (n, 1) from perfect_power(n) if n is not a perfect power rather than returning None.

Changes

Compute a finite field element's square root (if it exists) with np.sqrt().
List which finite field elements are/aren't quadratic residues (have a square root) with FieldClass.quadratic_residues and FieldClass.quadratic_non_residues.
Compute standard vector spaces with FieldArray.row_space(), FieldArray.column_space(), FieldArray.left_null_space(), and FieldArray.null_space().
Compute a finite field element's additive and multiplicative orders with FieldArray.additive_order() and FieldArray.multiplicative_order().
Evaluate polynomials at square matrix inputs using f(X, elementwise=False).
Compute the characteristic polynomial of a single element or square matrix with FieldArray.characteristic_poly().
Compute the minimal polynomial of a single element with FieldArray.minimal_poly().
Compute a Lagrange interpolating polynomial with lagrange_poly(x, y).
Support non-square matrix inputs to FieldArray.lu_decompose() and FieldArray.plu_decompose().
Support polynomial scalar multiplication. Now p * 3 is valid syntax and represents p + p + p.
Allow polynomial comparison with integers and field scalars. Now galois.Poly([0]) == 0 and galois.Poly([0]) == GF(0) return True rather than raising TypeError.
Support testing 0-degree polynomials for irreducibility and primitivity.
Extend crt() to work over non co-prime moduli.
Extend prev_prime() and next_prime() to work over arbitrarily-large inputs.
Allow negative integer inputs to primes(), is_prime(), is_composite(), is_prime_power(), is_perfect_power(), is_square_free(), is_smooth(), and is_powersmooth().
Fix various type hinting errors.
Various other bug fixes.

Contributors

Iyán Méndez Veiga (@iyanmv)
Matt Hostetter (@mhostetter)

Commits

e35831a Version bump to 0.0.24 0196d7f Add release notes for v0.0.24 48dc549 Fix irreducible and primitive polynomial degree criteria 4083e89 Add () to functions/methods in README cf97f21 Add unit tests for null_space() 71dd31c Add FieldArray.null_space() method 2669826 Add unit tests for left_null_space() 0a103f6 Add FieldArray.left_null_space() method 839d621 Add unit tests for column_space() 3c8ced9 Add FieldArray.column_space() method bfbeb31 Add unit tests for row_space() 7c595cc Add FieldArray.row_space() method 134eb7d Fix code coverage exclusion of typing overloads 5d0f353 Update codecov GitHub action version 3aa7d1b Ensure pure-Python ufuncs are performing integer arithmetic 8993630 Add more is_powersmooth() unit tests 9b356cb Add more is_smooth() unit tests 9003ed4 Rearrange prime generation and factoring code 0748408 Add more is_monic() unit tests e61ba58 Accept non-monic polynomials to is_square_free() 322a962 Add more unit tests for testing square-free integers 0932530 Add is_perfect_power() unit tests 9e5fe69 Make perfect_power() and is_perfect_power() more consistent with Sage a70d95b Add more is_prime_power() unit tests 2153cef Allow negative integers to is_prime_power() a8fb8ef Allow negative integers to is_composite() d77bb3e Add more is_prime() unit tests 4c16712 Allow negative integers to is_prime() a55e277 Add more next_prime() unit tests 01a4737 Add more prev_prime() unit tests 7eea08a Raise ValueError instead of returning None for invalid previous prime 8b9f23c Add more kth_prime() unit tests 0f0d686 Add more primes() unit tests 19398cc Add more is_cyclic() unit tests d9dfa2d Add more carmichael_lambda() unit tests 93d486f Add more euler_phi() unit tests f8a9f24 Add unit tests for polynomial CRT ff04822 Raise ValueError on polynomial CRT if remainder degrees not less than moduli degrees 91f4651 Make CRT support non-coprime moduli 005d77c Resolve pytest warnings d68f537 Add unit tests for integer logarithms d77b1ee Add more unit tests for integer roots f29b0e8 Add more unit tests for integer square root f477eae Add more unit tests for integer modular exponentiation f61bae2 Add unit tests for integer prod() 12f3ca3 Add more unit tests for integer LCM e90d43e Add more unit tests for integer extended GCD 2d4f210 Remove old poly evaluation at matrices unit tests 1166dbe Add more primitive polynomial unit tests d3ad835 Add more irreducible polynomial unit tests d34b654 Add more unit tests for polynomial modular exponentiation 5344660 Add unit tests for galois.prod() with polynomials a5d9dd2 Add unit tests for polynomial LCM 15b4c7f Add more polynomial GCD unit tests f1452f6 Clean up test vector generation script 0140a45 Add more Poly.derivative() unit tests 5780e1e Add more Poly.roots() unit tests 8355743 Add unit tests for polynomial reversals 09f984b Add unit tests for poly evaluation at square matrices e78d46f Increase linear algebra code coverage 53d6b0e Support non-square matrices for LU and PLU decomposition fccdf0d Instruct code coverage to ignore typing overloads f27480c Add more np.linalg.solve() unit tests edd2e0f Add more matrix determinant unit tests f1561b4 Add unit tests for matrix inverses 991feb7 Refactor lup_decompose() into plu_decompose() f4a2cc7 Add more lu_decompose() unit tests 84eaaf6 Add unit tests for row_reduce() a8ac0e6 Add more matrix multiplication unit tests 6f64f2d Add more field_norm() unit tests 95d80ef Add more field_trace() unit tests 51c4362 Add more minimal_poly() unit tests for 0-D scalars 4879587 Add more characteristic_poly() unit tests for matrices 8147946 Add more characteristic_poly() unit tests for 0-D scalars b6abfc2 Add more multiplicative_order() unit tests a00e496 Add more additive_order() unit tests 5a002d4 Rename field fixtures for unit tests 767588c Move unit test LUT folders bf6d120 Make each unit test LUT reproducible with unique seed a5e6386 Resolve NumbaIRAssumptionWarning 70dc6e2 Support polynomial scalar multiplication 0a37672 Add unit tests for Galois field class properties 2eea839 Add back erroneously-deleted multiplicative_inverse.pkl generation 9904f57 Use poly comparison with 0 and 1 throughout library 51135fd Support Poly equals comparison with scalars 21b2487 Change np.sqrt() error to ArithmeticError 82b938e Add unit tests for np.sqrt() eaad6da Support np.sqrt() on Galois field arrays a41cd7c Fix other type hints for shape 14a1547 Add unit tests for quadratic residues c26143c Add FieldClass.quadratic_non_residues ef7f9b7 Add FieldClass.quadratic_residues 8c00cb2 Add FieldArray.is_quadratic_residue() 3c49aa7 Fix shape type hint ce0ad6b Speed up FieldArray.multiplicative_order() when LUTs are available 89ad6a5 Support prev_prime(n) for arbitrarily-large n a1fc17d Support next_prime(n) for arbitrarily-large n 50eb7e8 Fix bug in field trace/norm tests 1ee3f8e Add unit tests for FieldArray.additive_order() 5cf3082 Add FieldArray.additive_order() 8d989dd Add unit tests for FieldArray.multiplicative_order() 8a247a9 Add FieldArray.multiplicative_order() 04539f7 Fix type hint for NumPy integer types 54e99b7 Move galois.minimal_poly() to FieldArray.minimal_poly() db133a6 Add unit tests for characteristic poly of finite field elements f2e5492 Add ability to compute characteristic polynomial of a finite field element b57d6e9 Add ability to evaluate polynomials at square matrices 0bd8b61 Add __len__ special method to docs 5cc3560 Add __call__ special method to docs 29aa072 Add missing dependency to min-requirements.txt f3d9984 Add unit tests for lagrange_poly() 1b63538 Add lagrange_poly function f78cb64 Add non constant-time disclaimer to README

- Python
Published by github-actions[bot] over 4 years ago

galois - galois v0.0.23

Changes

Add support for Python 3.10.
Add support for NumPy 1.21.
Add support for Numba 0.55.
Add type hints to library API.
Add FieldArray.characteristic_poly() method to return the characteristic polynomial of a square matrix.
Add Poly.coefficients() method to return the coefficient array with fixed size and order.
Fix bug in Poly.Degrees() when duplicate degrees were present.
Fix bug in Reed-Solomon decode when c != 1.
Various other bug fixes.

Contributors

Matt Hostetter (@mhostetter)

Commits

696315b Version bump to 0.0.23 a828748 Add release notes for v0.0.23 6812dc4 Remove unneeded variable a3bb6fc Remove unnecessary pytest markers 3a55b36 Add support for NumPy 1.21 e76b77e Support Python 3.10 c7ef695 Add unit tests for FieldArray.characteristic_poly() b6dc38c Add FieldArray.characteristic_poly() 0105045 Hide type hints from sphinx docs signatures c44082b Fix bug in Miller-Rabin primality test when n=3 69dc22f Move _polys/ into _fields/ folder for less circular dependence 7ce772f Add type hints to FEC codes 7d5b71f Add type hints for misc functions 9fa4736 Add type hints to polynomial classes bd28afe Add type hints to field classes b13980b Add type hints to general functions 4a498ba Add typing_extensions dependency 0548e00 Add unit tests for RS decode with c != 1 302dd69 Fix RS decode when c != 1 f54aef7 Make RS decoding more efficient 280a3e9 Ensures Poly.Degrees has unique degree inputs a89fd86 Add unit tests for Poly.coefficients() d3f2974 Add Poly.coefficients() method accessor 8704354 Fix display of logo in README on PyPI 74bd34c Bump allowable Numba version to 0.54.x 28ce919 Add workaround for #178 eb427c3 Delete table of contents in README

- Python
Published by github-actions[bot] over 4 years ago

galois - galois v0.0.22

Breaking Changes

Random integer generation is handled using new style random generators. Now each .Random() call will generate a new seed rather than using the NumPy "global" seed used with np.random.randint().
Add a seed=None keyword argument to FieldArray.Random() and Poly.Random(). A reproducible script can be constructed like this:

python rng = np.random.default_rng(123456789) x = GF.Random(10, seed=rng) y = GF.Random(10, seed=rng) poly = galois.Poly.Random(5, seed=rng, field=GF)

Changes

Official support for Python 3.9.
Major performance improvements to "large" finite fields (those with dtype=np.object_).
Minor performance improvements to all finite fields.
Add the Number Theoretic Transform (NTT) in ntt() and intt().
Add the trace of finite field elements in FieldArray.field_trace().
Add the norm of finite field elements in FieldArray.field_norm().
Support len() on Poly objects, which returns the length of the coefficient array (polynomial order + 1).
Support x.dot(y) syntax for the expression np.dot(x, y).
Minimum NumPy version bumped to 1.18.4 for new style random usage.
Various bug fixes.

Contributors

Iyán Méndez Veiga (@iyanmv)
Matt Hostetter (@mhostetter)

Commits

63760c3 Version bump to 0.0.22 5ecae0a Make Poly.Random() outputs consistent with GF.Random() ba779a9 Add release notes for v0.0.22 1d144e2 Minor documentation tweaks e1b499c Fix typo in docs build instructions e4618a9 Add seed kwarg to Poly.Random() ffe78b4 Add unit tests Random constructor with seed 6b00496 Use new numpy.random.defaultrng() 7ecf8ec Bump NumPy to 1.18.4 ab0f108 Prevent other x**np.arange() overflow errors with improper dtype 817ad94 Fix #205 158f5ff Support ndarray.dot() usage 3e8ee35 Add tests for ndarray.dot() usage 976d2a4 Allow caching of constants in lambda functions f1d2f6e Do not re-verify the type/value of FieldArray instances d79332e Compute FieldClass.dtypes only once 9316409 Add unit test len(galois.Poly) 79f6dc2 Add _len__ method to Poly class ba217ff Add unit test with example from #194 48a4ad7 Fix #194 4b9c521 Add field_norm() method e7d0590 Add field_trace() method 74171dc Fix typos 23ab9ed Fix #188 b08920c Fix #186 69d4a56 Support Python 3.9 c294e5c Add initial implementation of the NTT and INTT e42a0eb Fix linter suggestions f9ea821 Merge lint and test dependencies into requirements-dev.txt 271882e Move docs requirements file into docs/ folder 2ed51c2 Update VS Code settings for newer versions 4d25b08 Explicitly specify pylint config file for VS Code

- Python
Published by github-actions[bot] over 4 years ago

galois - galois v0.0.21

Changes

Fix docstrings and code completion for Python classes that weren't rendering correctly in an IDE.
Various documentation improvements.

Contributors

Matt Hostetter (@mhostetter)

Commits

a23bff6 Version bump to 0.0.21 69672c2 Add release notes for v0.0.21 803c872 Clarify warnings in FieldClass and FieldArray docstrings eff2ce7 Fix FieldClass and FieldArray class docstrings 743a265 Fix LFSR class docstrings 32f0b1f Fix Reed Solomon creation and docstring placement 1f6e582 Fix BCH creation and docstring placement ded3e3a Update Twitter badge style in README 354f221 Fix display of logo on PyPI's website

- Python
Published by github-actions[bot] almost 5 years ago

galois - galois v0.0.20

Breaking Changes

Move poly_gcd() functionality into gcd().
Move poly_egcd() functionality into egcd().
Move poly_factors() functionality into factors().

Changes

Fix polynomial factorization algorithms. Previously only parital factorization was implemented.
Support generating and testing irreducible and primitive polynomials over extension fields.
Support polynomial input to is_square_free().
Minor documentation improvements.
Pin Numba dependency to <0.54

Contributors

Matt Hostetter (@mhostetter)

Commits

6bf7b2f Version bump to 0.0.20 e32180b Add release notes for v0.0.20 c14f2ca Pin Numba less than 0.54 until warnings resolved 9efc6e5 Clean-up Galois field array JIT functions 60f83fd Add CITATION file e57e2d3 Add extra PyPI project URLs e3c8ff2 Add Twitter badge 16645b5 Remove known mirrors from PyPI downloads badge 7571004 Link galois object to API reference in docs 902e6e6 Greatly clean-up Galois field arithmetic functions/classes 5e5c6a8 Fix linter warning 0722d5e Add v2 of logo with smaller Rubik's cube 8d810da Ignore abstract methods in code coverage 575354e Remove lint badge from README 1a459a7 Make is_square_free() work on polynomials b286baa Add polymorphic functions for ints and polys 41d6784 Add <meta> HTML tag to README e486eaa Reset display mode to integer representation in docs dcabb11 Increase code coverage for poly constructors efcb9a9 Make poly_factors() work over extension fields ffea5b7 Fix bug in p-th root of polynomial 7688cc2 Support primitive polynomials over extension fields 4f7cbd1 Support irreducible polynomials over extension fields c5f7056 Fix poly_factors() for prime fields 53f3b37 Fix bug in equal-degree factorization eb4ed74 Make unit tests require successful lint stage 510864b Restructure fields and polys subpackages defea3d Restructure code and clean-up circular dependencies bf0b27a Fix field docstring in Poly.Degrees() cee6904 Add polynomial equal-degree factorization c84e09a Add polynomial distinct-degree factorization 5d7ab83 Add polynomial square-free factorization 3ce5fd9 Fix display of logo on PyPI's website

- Python
Published by github-actions[bot] almost 5 years ago

galois - galois v0.0.19

Breaking Changes

Remove unnecessary is_field() function. Use isinstance(x, galois.FieldClass) or isinstance(x, galois.FieldArray) instead.
Remove log_naive() function. Might be re-added later through np.log() on a multiplicative group array.
Rename mode kwarg in galois.GF() to compile.
Revert np.copy() override that always returns a subclass. Now, by default it does not return a sublcass. To return a Galois field array, use x.copy() or np.copy(x, subok=True) instead.

Changes

Improve documentation.
Improve unit test coverage.
Add benchmarking tests.
Add initial LFSR implementation.
Add display kwarg to galois.GF() class factory to set the display mode at class-creation time.
Add Poly.reverse() method.
Allow polynomial strings as input to galois.GF(). For example, galois.GF(2**4, irreducible_poly="x^4 + x + 1").
Enable np.divmod() and np.remainder() on Galois field arrays. The remainder is always zero, though.
Fix bug in bch_valid_codes() where repetition codes weren't included.
Various minor bug fixes.

Contributors

Matt Hostetter (@mhostetter)

Commits

84806de Version bump to 0.0.19 bd4ab58 Add release notes for v0.0.19 def6a4d Increase LFSR code coverage 3f25531 Increase prime functions' code coverage 0e615d8 Rework unit testing of prime factorization ec2b862 Reconfigure format of test vector LUTs 39c81e2 Rework unit testing of polynomial derivatives 5549e83 Rework unit testing of computing polynomial roots cea9c68 Fix error in Poly docstring of optional field kwarg 6e556e9 Fix ipython syntax highlighting in sphinx .md files e51d9e4 Remove is_field() function ce3f36b Add BCH repetition codes in bch_valid_codes() d764b4b Use latest docs badge in README 1c1be4c Add features section to docs 660f566 Add versioning section to docs 731e3a4 Add acknowledgements section to docs 960fb02 Add citation style 627b489 Add GitHub social media logo 62d687f Increase logo resolution a19bde7 Remove nbsphinx docs dependency 489244a Make TOC in README have only one level 69a2b4d Update basic usage examples 882fc27 Allow polynomial strings as input to galois.GF() ce17e4a Rework unit testing of FEC codes f1a7c73 Fix literal file includes in docs a9cd379 Add first version of project logo 24477b0 Disable code coverage on JIT-compiled functions 4c2ce95 Rework unit testing of Galois field class factory function f1ba17d Use polynomial indeterminate "x" for repr_table() 772d95e Don't update ufunc mode of a Galois field class with defaults bb1fdc6 Don't update display mode of a Galois field class with defaults d9fc631 Rework unit testing of number theoretic functions 11532ad Rework unit testing of polynomial factorization 6237b19 Add downloads badge to README bec80bc Rework unit testing of poly_pow() a19dfb6 Rework unit testing of polynomial GCDs 3cb9d27 Rework testing primitive elements b354f58 Rework testing minimal polynomials 1179dcd Update irreducible and primitive poly unit tests b6d8927 Fix docstring formatting issues for the display() method 2f82555 Hide "Constructor" and "Special Methods" section if they are empty 275f208 Add docstrings to arithmetic dunder methods and include in API reference b50e6ad Refer GF2 docs to FieldArray 78d08b4 Support np.divmod() and np.remainder() ufuncs for Galois field arrays c995199 Remove log_naive() function 95445fb Change syntax highlighting style in docs c65b971 Fix typos in tutorials cc72ffa Re-order functions in API reference e6db491 Clean-up docstrings across the library cef5016 Do not allow non-iterable coeffs to Poly constructor 41b59e5 Ensure copies of LFSR states are returned, not a reference 96a6f74 Ensure single-step LFSR outputs are 0-D arrays fd6b056 Add hyperlinks to API reference in features section of README 0c89fac Re-arrange API order 24b95cd Clean-up raised exceptions 29e1895 Clean-up docstrings for Galois field array classes 4af4c36 Add display kwarg to GF() class factory e7a17ca Rename mode kwarg to compile 84b583a Optionally specify x and y values for arithmetic tables 36377e0 Add sorting of rows in repr_table() 798fa2d Add irreducible poly and primitve element to properties of prime fields c3efa00 In properties string, represent the primitive element as a polynomial 7edc23b Use primes() instead of PRIMES throughout the library aadbee1 Move developer installation notes to "Installation" page 7ad6c9c Cache output from primes() function 23e05d9 Cleanup polynomial class property references b267a42 Add reverse() method to polynomials 9a3a88c Add more detail in the LFSR notes section fb5f108 Add Galois LFSR unit tests 6a53d37 Add Berlekamp-Massey algorithm example in docstring 0d05605 Add Berlekamp-Massey algorithm unit tests 8254a2c Add initial LFSR implementation 1cc5c35 Add protected-access to pylint ignore cc6fd29 Remove cryptographic ciphers from roadmap d165351 Revert np.copy() view casting override 6de731d Fix hyperlinks in README a7c87aa Fix basic usage not being included in generated docs 40cc8d1 Ensure polynomial coefficients can't be modified 4e8204b Make arithmetic_table() use the current display_mode c32ba4a Add examples to Reed-Solomon properties cdda540 Add examples to BCH properties 973b3f9 Fix ASCII table border characters 08cb5bb Hide source links in sphinx docs 8e836c4 Add benchmarking info to documentation 2fb7239 Add .benchmarks/ to gitignore cd9617f Add FEC benchmarking a1b962c Add Galois field array benchmark tests

- Python
Published by github-actions[bot] almost 5 years ago

galois - galois v0.0.18

Breaking Changes

Make API more consistent with software like Matlab and Wolfram:
- Rename galois.prime_factors() to galois.factors().
- Rename galois.gcd() to galois.egcd() and add galois.gcd() for conventional GCD.
- Rename galois.poly_gcd() to galois.poly_egcd() and add galois.poly_gcd() for conventional GCD.
- Rename galois.euler_totient() to galois.euler_phi().
- Rename galois.carmichael() to galois.carmichael_lambda().
- Rename galois.is_prime_fermat() to galois.fermat_primality_test().
- Rename galois.is_prime_miller_rabin() to galois.miller_rabin_primality_test().
Rename polynomial search method keyword argument values from ["smallest", "largest", "random"] to ["min", "max", "random"].

Changes

Clean up galois API and dir() so only public classes and functions are displayed.
Speed-up galois.is_primitive() test and search for primitive polynomials in galois.primitive_poly().
Speed-up galois.is_smooth().
Add Reed-Solomon codes in galois.ReedSolomon.
Add shortened BCH and Reed-Solomon codes.
Add error detection for BCH and Reed-Solomon with the detect() method.
Add general cyclic linear block code functions.
Add Matlab default primitive polynomial with galois.matlab_primitive_poly().
Add number theoretic functions:
- Add galois.legendre_symbol(), galois.jacobi_symbol(), galois.kronecker_symbol().
- Add galois.divisors(), galois.divisor_sigma().
- Add galois.is_composite(), galois.is_prime_power(), galois.is_perfect_power(), galois.is_square_free(), galois.is_powersmooth().
- Add galois.are_coprime().
Clean up integer factorization algorithms and add some to public API:
- Add galois.perfect_power(), galois.trial_division(), galois.pollard_p1(), galois.pollard_rho().
Clean up API reference structure and hierarchy.
Fix minor bugs in BCH codes.

Contributors

Matt Hostetter (@mhostetter)

Commits

5ca778e Version bump to 0.0.18 8a2adff Add release notes for v0.0.18 3a84c38 Hide implementation details from galois namespace 213f0ab Clean up integer arithmetic docstrings c4138ab Add trial division factorization to public API fb6e509 Add Pollard rho algorithm ba742c6 Add Pollard's p-1 algorithm 9c72502 Disable too-many-branches in pylint 20fe5ed Speed-up is_smooth() b4e5dc5 Fix erroneous pylint complaints aef9b25 Add is_powersmooth() 995dc80 Add perfect_power() to the public API 134c286 Clean up backslashes in LaTeX in docstrings a006bea Clean up the Miller-Rabin primality test be55733 Clean up Fermat's primality test f710153 Speed up is_smooth() test b03c5bc Add are_coprime() to test if integers are pairwise coprime 8418e1a Add is_perfect_power() 3ea43a4 Add Legendre, Jacobi, and Kronecker symbols 0da1449 Rename is_prime_miller_rabin() to miller_rabin_primality_test() b9ed28f Rename is_prime_fermat() to fermat_primality_test() 4d1e3f8 Add poly_gcd() for non-extended GCD c21c1c7 Rename poly_gcd() to poly_egcd() cfe8190 Move integer arithmetic routines to separate file a2b47a4 Restructure docs hierarchy c8d35c9 Add gcd() to find the greatest common divisor of two integers c72b1c3 Rename gcd() to egcd() 7a1f5b0 Restructure API reference 77e01c0 Remove Oakley Galois fields 3e48a13 Add is_square_free() d6b78b4 Add is_prime_power() d0aad9d Add is_composite() f102cd7 Rename prime_factors() to factors() b2770f6 Add divisor_sigma() to implement the sum of divisors functions 2e29c6b Add divisors() to find all integer divisors of n 46bb848 Rename carmichael() to carmichael_lambda() e57d7ec Rename euler_totient() to euler_phi() a34f4bf Fix numpy API reference efbce45 Fix is_primitive() test for degree-1 polynomials 0a3aa6e Greatly speed up is_primitive() 0a6debb Cache prime_factors() output 7b418f1 Rearrange conway poly database code 94eca9e State incompatibility with numpy v1.21 037850b Add tests for number of irreducible and primitive polynomials over GF(2) 2563b20 Add tests for matlab_primitive_poly() a9ffd87 Make poly search method arguments consistent fc89ae1 Speed-up creation of cyclic generator matrices c5ecb59 Add linear block code functions c8259f2 Remove superfluous FEC functions a3c7563 Rename generator_poly_to_matrix() to poly_to_generator_matrix() 4821550 Add error detection to RS codes b9db515 Add error detection to BCH codes d77c493 Add shortened RS codes 0adda4c Add shortened BCH codes a09bce4 Add design distance property f90450c Add FEC encode/decode unit tests cd97abd Increase primitive polynomial test coverage 8c65c4d Update README with FEC basic usage 9ae3910 Cleanup BCH comments and improve testing f6013b2 Add ReedSolomon class f803bfe Add polynomial evaluation JIT function 1f9d33c Fix error message in GF() class factory 998aa7a Prevent modification of input argument to poly_roots JIT function 9c88843 Enable Poly str/repr with display mode "power" ed4e63f Cleanup FEC docstrings cf6a57d Add matlab_primitive_poly() function 040df1d Add Reed-Solomon functions 28b42c2 Fix BCH default primitive poly for GF(2^7) d53e2e3 Fix bug in computation of t in bch_generator_poly() 185a425 Add bch_parity_check_matrix() and common cyclic code functions dd2a252 Fix sphinx docs for FieldArray

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.17

Breaking Changes

Rename FieldMeta to FieldClass.
Remove target keyword from FieldClass.compile() until there is better support for GPUs.
Consolidate verify_irreducible and verify_primitive keyword arguments into verify for the galois.GF() class factory function.
Remove group arrays until there is more complete support.

Changes

Speed-up Galois field class creation time.
Speed-up JIT compilation time by caching functions.
Speed-up Poly.roots() by JIT compiling it.
Add BCH codes with galois.BCH.
Add ability to generate irreducible polynomials with irreducible_poly() and irreducible_polys().
Add ability to generate primitive polynomials with primitive_poly() and primitive_polys().
Add computation of the minimal polynomial of an element of an extension field with minimal_poly().
Add display of arithmetic tables with FieldClass.arithmetic_table().
Add display of field element representation table with FieldClass.repr_table().
Add Berlekamp-Massey algorithm in berlekamp_massey().
Enable ipython tab-completion of Galois field classes.
Cleanup API reference page.
Add introduction to Galois fields tutorials.
Fix bug in is_primitive() where some reducible polynomials were marked irreducible.
Fix bug in integer<-->polynomial conversions for large binary polynomials.
Fix bug in "power" display mode of 0.
Other minor bug fixes.

Contributors

Dominik Wernberger (@Werni2A)
Matt Hostetter (@mhostetter)

Commits

0134648 Version bump to 0.0.17 ec0009b Update release notes for v0.0.17 288526f Fix contributors in release notes cca0e91 Fix bug in power representation of constant elements 6a3fcb1 Improve code coverage 8d46346 Remove target keyword until there is better support a5f9f16 Rename FieldMeta to FieldClass 1e73ca9 Fix syntax highlighting of sphinx markdown document 92be9bd Enable tab-completion of Galois field classes 22e581b Restructure FieldMeta and FieldArray 87f6013 Remove group arrays until there is better support 8c5fab2 Allow poly coefficients for irreducible_poly and primitive_element in galois.GF 746576a Unify verify arguments to class constructor galois.GF 49f8f1d Make prime factoring of perfect powers efficient 1ecbd56 Add primitive binary BCH codes af54a87 Make GF._poly_divmod() support 2-D dividends 22b1fd9 Re-architect JIT compilation and caching process 856a47a Make GitHub releases drafts 747672f Ensure GF2 has a ufunc for each arithmetic type 1025738 Unify JIT keyword arguments 32532f6 Add Berlekamp-Massey algorithm 649280d JIT compile Poly.roots() bbeac79 Add irreducible_polys() function bc61bea Add primitive_polys() function 3577ae5 Add input checking for irreducible_poly() and primitive_poly() 0f4315f Minor cleanup 54459b7 Fix bug preventing instantiating a large prime field in its extension field 677218b Reduce JIT compile times 1e79bb9 Add Intro to Galois Fields tutorials 840d479 Add arithmetic_table() method 944dcdf Add repr_table() method d7f544a Suppress erroneous pylint warnings ee66cc2 Fix bug in degree of large binary polynomials 59bc0cc Fix bug in "power" representation display mode 4af9bf1 Consolidate functions in modular.py 04605b7 Fix bug in Roots constructors with FieldArray roots 209b8d5 Hide classes flyweights 5504b71 Fix typos in README 1701467 Remove functions from bottom of API reference page 8f060e8 Fix typo 08aa24f Fix math representation 97c35af Add generation of minimal polynomials ef1e778 Enable irreducible and primitive tests of degree-1 polynomials b37f811 Add ability to generate a primitive polynomial ec3c66b Fix bug in is_primitive where some reducible polynomials were marked as primitive 0e96460 Add ability to generate an irreducible polynomial c5cd6b6 Fix bug in integer-poly conversions due to math.log inaccuracy 96211b4 Fix broken hyperlinks in README

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.16

Changes

Add Field() alias of GF() class factory.
Add finite groups modulo n with Group() class factory.
Add is_group(), is_field(), is_prime_field(), is_extension_field().
Add polynomial constructor Poly.String().
Add polynomial factorization in poly_factors().
Add np.vdot() support.
Fix PyPI packaging issue from v0.0.15.
Fix bug in creation of 0-degree polynomials.
Fix bug in poly_gcd() not returning monic GCD polynomials.

Contributors

Matt Hostetter (@mhostetter)

Commits

37060cb Version bump to 0.0.16 cd812c8 Add release notes for v0.0.16 a113001 Add subpackages to wheel build f1eb439 Fix unit testing against wheel not source code d9f0ba2 Add Poly.String constructor 555f696 Add poly_factors functions ace826a Fix bug in poly_gcd not returning monic gcd polynomial 5f1a057 Add vdot linear algebra function 23efd8e Add unit test coverage 33ed685 Support out keyword-argument for linalg functions 2f8194f Don't compute primitive root for large prime fields ab7341c Cache results of Pollard's rho factorization ee1bf67 Support arbitrarily-large degrees array a8b90aa Add tests of algebraic structure 8497816 Fix occasional bug in linear algebra on object arrays a5ab270 Add exponentiation to groups 14ba4d8 Fix bug in creation of 0-degree polynomials 58fa8a5 Update pytest markers fde8f51 Prevent equality bug with object arrays 5a9107e Add release notes to docs ebba567 Use the cutom class template for the API reference 04420c6 Update the docstring for iscyclic() 1bd1b65 Add GF(p^m) examples in FieldMeta 519c15f Prevent generation of singular matrix in building the docs 7e99551 Add basic finite groups of integers mod n c2ee03f Add isfield() function 7baa72b Rename GFArray/GFMeta to FieldArray/FieldMeta 3e1d333 Add Field() as an alias of GF() f0f6f8b Reorganize field unit tests 2d65f60 Reset CHANGELOG

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.15

Breaking Changes

Rename poly_exp_mod() to poly_pow() to mimic the native pow() function.
Rename fermat_primality_test() to is_prime_fermat().
Rename miller_rabin_primality_test() to is_prime_miller_rabin().

Changes

Massive linear algebra speed-ups. (See #88)
Massive polynomial speed-ups. (See #88)
Various Galois field performance enhancements. (See #92)
Support np.convolve() for two Galois field arrays.
Allow polynomial arithmetic with Galois field scalars (of the same field). (See #99), e.g.

```python

GF = galois.GF(3)

p = galois.Poly([1,2,0], field=GF) Poly(x^2 + 2x, GF(3))

p * GF(2) Poly(2x^2 + x, GF(3)) ```

Allow creation of 0-degree polynomials from integers. (See #99), e.g.

```python

p = galois.Poly(1) Poly(1, GF(2)) ```

Add the four Oakley fields from RFC 2409.
Speed-up unit tests.
Restructure API reference.

Contributors

Matt Hostetter (@mhostetter)

Commits

c4c04d2 Version bump to 0.0.15 dcc3598 Add CHANGELOG 170841c Support poly and scalar field element arithmetic 65db10c Allow polynomial creation from single integers 5e263a1 Only allow polynomial equality comparison with other polynomials 41e0a35 Support poly and single field element arithmetic bb8bf7f Reorganize API reference 4c44bb0 Create base classes Array, Meta, Ufunc, and Func for use by other algebraic structures 8029a5e Move Galois field modules into field/ folder a0407d7 Add naive algorithm for discrete logarithms 67864fb Add Oakley groups 368d0a4 Rename primality test functions 5358495 Add Mersenne prime functions to API reference 73b3fb5 Add alias of pow for modular exponentiation 588af9f Organize API reference into sections 6b02e94 Speed-up GF(p^m) arithmetic by working with vectors in GF(p) 656671f Minor README updates 32adea6 Disable reduction ufunc methods on "power" and "log" 878444e Verify ufunc method for unary operators cfb58d1 Add np.positive ufunc support ec683c0 Use XOR ufuncs on object arrays for GF(2^m) 5bb3721 Remove "negative" ufunc for characteristic-2 fields 6d36014 Use explicit calculation when faster than lookup tables for GF(2^m) 275848d Use explicit calculation when faster than lookup tables for GF(p) f69ad89 Fix newline in release notes ea6e6a8 Reorganize functions that compile ufuncs f3bf3fe Update performance examples in docs e89b839 Add linear algebra performance to docs 2aca943 Add JIT-compiled matmul function for massive speed-up bea1d6e Use native np.convolve for extremely large prime fields 03791e5 Avoid strange bug with LAPACK linear algebra 00c873f Clean up input checking for a few functions 9375606 Suppress verbose mode in pytest f11dba2 Add np.convolve() support and speed-up for prime fields 0cfa1fe Speed-up poly arithmetic with JIT-compiled functions 88812d7 Add performance analysis script for poly implementations a0be93c Speed up poly eval constant unit test 663eac1 Fix bug where BinaryPoly fast arithmetic wasn't getting invoked c137488 Better instantiate dictionaries a3581c7 Remove unnecessary test fixture that wastes time 740fa46 Speed up slow logarithm test 738503d Make separate test file for modular arithmetic functions a4d5d7e Rename polyexpmod() to poly_pow() c2cf712 Run GF arithmetic unit tests over random dtype, not all dtypes

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.14

Breaking Changes

Rename GFArray.Eye() to GFArray.Identity().
Rename chinese_remainder_theorem() to crt().

Changes

Lots of performance improvements
Additional linear algebra support
Various bug fixes

Contributors

Baalateja Kataru (@BK-Modding)
Matt Hostetter (@mhostetter)

Commits

fb977d5 Version bump to 0.0.14 30c110d Fix bug in multiply.outer unit test 9e10d56 Update pypi metadata c43123c Remove explicit scalarmultiply ufunc 179972c Make prime factorization more robust 1567312 Use native numpy bitwisexor for add/subtract in GF(2^m) 5a514c5 Remove unnecessary view of inputs to ndarray e02c69f Move exception raising into numba ufuncs for speed-up 517eeee Reduce exponents mod p-1 in GF(p) for a speed-up 142396d Make crt() support arbitrarily-large integers 013d83a Rename chineseremaindertheorem() to crt() 859115b Make multiplicative inverse in prime fields faster 7f6cfff Greatly speed up isprimitive() by only checking prime factors of p^n - 1 e7a74bb Minor documentation updates bcc5d76 Add abstract class section in API reference d836910 Add list of contributors in release b0404d3 Add future roadmap to README 6982345 Make linear algebra more efficient in prime fields 42481e3 Further numba optimzations for GF(2) 5b2ca0d Additional polygcd() bug fix e7a8688 Unit test added for modified polygcd() and fixed linting errors 5f5fb4a Return weighted coefficient polynomials from galois.polygcd() ba659b2 Standardized output datatype of galois.polygcd() to only return galois.DensePoly objects 73c2598 Add unit tests for numpy functions on Galois field arrays ae7af2b Fix bug in poly copy method f381cfc Fix bug in calculating degree of a binary polynomial 0d88ad4 Add GF(p^m) fields 7645b75 Ensure exponents are not field elements bb5d9d0 Rename test data folder 5f5abc4 Disable more unsupported numpy functions a29b6be Add Galois quote to doc homepage 5461c17 Rename Eye() to Identity() 0f63f30 Support np.outer() 56e628d Support np.inner() 0a76b53 Support np.dot() dfe4160 Add methods to convert between Galois field vector spaces 2587f29 Remove convolution for multiplying GF(2) polys in place of BinaryPoly 0f3a970 Set the module of public functions/classes to the their public signature bd5fcc4 Rename multipleadd to scalarmultiply 059db9c Rename groundfield to primesubfield 7a7b9c1 Add unit tests for GF(2^8) with non-primitive polynomial 7ef9ea0 Replace np.all with np.arrayequal 23dc9e7 Fix bug in log of Galois field arrays with objects 66d3132 Add check if an integer is B-smooth 9c0cfd2 Add Vandermonde matrix GFArray constructor 28b460e Add function to generate random prime of given bit length f1dd0ec Add power representation display mode to README 12689db Add BinaryPoly implementation for speed-ups of poly arithmetic in GF(2) 5706f32 Ensure matrices are invertible so linalg docs build 81af4b7 Rearrange polynomial inheritance fc8f062 Remove some modulo operations for speed ups in prime fields 153b051 Add power representation display mode 6f8e77b Fix bug where log was returning field elements not integers 2cac803 Speed up GF(2^m) lookup table construction ef14e17 Multiply polys over GF(2) using FFT-based convolution d4dd3e0 Fix bug in multiplication over GF(2^m) with alpha != 2 98d8c44 Make GCD more compact

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.13

Contributors

@mhostetter

Commits

364d510 Version bump to 0.0.13 cd80d90 Remove erroneous print statement 53b0d6c Update basic usage documentation 5546f81 Rename target() to compile() 3898bc1 Add linear algebra routines 7f267a9 Add matmul ufunc eacc4d8 Add performance speed tests 11870d3 Clean up some docstrings b88030a Hide class inheritance from docs c516d79 Update performance section in README 98bd78e Rework GFArray ufuncs for better performance 8555567 Rework method of retargeting Galois field arrays 12375f9 Add polynomial monic check function 7e6c383 Add identity matrix constructor 1bf7a97 Add reciprocal ufunc 96c418c Allow polynomial string inputs for Galois field arrays d78997d Cleanup build lookup table process 0e244da Add LCM function for arbitrarily-large integers d070b36 Use metaclasses to refactor Galois field arrays 0ab8b79 Move math routines in _math module 06a26f7 Make alpha the default polynomial indeterminate e201c05 Add class property that displays all GF properties in one formatted string 4e1ff40 Rename some GF array modules 462db39 Remove factors() 22d0842 Protect GFArray class attributes 2704ffa Have SparsePoly arithmetic return either dense or sparse polys b6a0668 Cleanup documentation and various docstrings 0da73b8 Run tests against wheels not source code

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.12

94c893e Version bump to 0.0.12 884f2a8 Fix packaging of database and version.txt file a4b4601 Add multiplicities kwarg to Roots constructor 292599d Speed up Rabin's irreducibility test 075a420 Support integer square root of python long integers c4cd323 Add Mersenne primes 9569cd3 Add polynomial irreducibility test 4020938 Fix math typos 0d0e4c9 Fix bug in polygcd() of 1 3ac0489 Add polyexpmod() function a4f36ca Refactor unit testing of GFArray construction 8e29fca Update Poly docstrings 9d45faa Add docs build github workflow 9f2c495 Refactor Poly into DensePoly and SparsePoly 3d06e78 Ensure object GFArrays are written to with ints 436f4d3 Update test vectors for better power and divmod coverage 0cc102e Make field kwargs consistent fa63608 Add ability to set Poly.field 2aaee4f Improve poly coeffs property getters/setters 082e28e Fix bug in prime factorization of 1 5f3edf3 Cleanup conwaypoly() function 61db57b Use square and multiply algorithm for poly exponentiation 11c3941 Cleanup poly arithmetic methods cd77684 Make polynomials hashable 77551db Add polynomial GCD function 3086b10 Move autosummary build folder 8930f74 Remove GCD function and just keep extended GCD 317d154 Rearrange algorithms for modular arithmetic c9b0e24 Rename gcd() functions 16a8674 Rename GFfactory() to GF() c589f8b Add versioning info to README 8d2deb7 Make GF array class string mimic np.ndarray a42fdc7 Use single argument order for GFfactory() d21a8b8 Fix singleton use with Conway poly database 905e39c Add ability to compute the multiplicity of polynomial roots aca6b0a Add method to calculate the formal derivative of a polynomial 0a05299 Clarify polynomial docstrings 0f37c4b Use GF(2^8) for polynomial examples 931e7f9 Add random polynomial constructor 1682497 Add method to compute the roots of a polynomial e9b66a3 Add prime sieve and remove static lookup table d54a6a3 Test for exceptions in package functions 4b5ef0a Cleanup exception messages 25e6a6a Add totatives() function 79aefd8 Add isprimitiveroot() function b123272 Generalize finding primitive roots 1f7d70b Remove modularexp() in favor of native pow() 7f68ea7 Add image of Evariste Galois to docs homepage de77b48 Rename API reference page fc18310 Add development guide 7bbfb81 Use python3 -m pip instead of pip3 282c006 Add explicit requirements files for linting, testing, and docs 2bdde9b Add more detail to README 73eee12 Increase code coverage on primitiveroot() 6813b91 Increase code coverage on galois.Poly d3c56fa Increase code coverage on conwaypoly() 73e6035 Increase code coverage on GFfactory() 2f2903c Increase code coverage in algorithms.py 760d6e3 Add optional numpy keywords to array creation

- Python
Published by github-actions[bot] about 5 years ago

galois - galois v0.0.11

ba6d89a Version bump to 0.0.11 d18b7e3 Make display() method a context manager a6051d0 Add more examples to documentation 4ee9d77 Hide GF2m and GFp abstract classes from documentation 2c04b2f Rename Poly.NonZero() to Poly.Degrees() 4a8e16a Rename poly "decimal" representation to "integer" representation 2585cf0 Add constructors to galois.Poly 7c9fc67 Additional workaround for strange equality inconsistency in #37 eb10b1e Workaround for strange equality inconsistency in #37 c7a94f5 Instruct pytest-cov to not cover JIT-ed functions 276f923 Place examples in sphinx admonition 3012094 Add Range() method to GF fields 25b7d7d Add fields/ and polys/ test folders 477ee1c Update package's pypi keywords

- Python
Published by github-actions[bot] over 5 years ago

galois - galois v0.0.10

c6881a0 Version bump to 0.0.10 ba585f2 Refactor sphinx documentation 3d1f7cf Organize the unit tests db74ffe Add support for arbitrarily-large fields using dtype=object ndarrays 5b0e4d3 Suppress superfluous overflow warning ded4d55 Greatly improve algorithm for finding a primitive root mod prime n 3d43a81 Add efficient primality tests 3c1682c Change pygments style for sphinx docs ff79062 Rename GFBase to GF 1898d4e Add tutorial on field element display modes fa6f254 Add ability to display field elements as integers or polynomials

- Python
Published by github-actions[bot] over 5 years ago

galois - galois v0.0.9

6ece68c Version bump to 0.0.9 ce3eec4 Minor update to tutorials 4aed791 Enable intersphinx mapping to python and numpy docs 1697ce4 Set default role in sphinx to be inline literals 5b45e71 Add example usage to functions 52a255b Store Conway polynomials in sqlite database, not global dict 0819f13 Fix bug where squaring scalar returns 1d array, not scalar d6c4230 Explicitly use 64-bit integers in test cases d570e00 Fix bizarre bug in Windows where polynomial decimal representation was wrong 93eab2b Prevent numpy unsafe type casting 2ebce36 Fix bug in list of valid dtypes for finite fields 4691763 Prevent CI from running twice on pull requests e4fd5d1 Reduce size of pickled test vectors 8429665 Add explicit calculation modes, i.e. no lookup tables 19cf5aa Use Zech logs for addition/subtraction in "lookup" ufuncs ef21b45 Add unit testing against minimum package dependencies c02f850 Improve documentation 89817dc Enable CI workflows on pull requests

- Python
Published by github-actions[bot] over 5 years ago

galois - galois v0.0.8

da1fe62 Version bump to 0.0.8 627e80d Add some tutorials to readthedocs documentation 592e14f Add basic implementation of GF(2^m) arrays 982c6eb Add list of Frank Luebek Conway polynomials f2ff374 Differentiate between field multiplication and "multiple addition" 23cbd19 Cleanup pytest fixture lookup table use 3b30011 Numba JIT compile factorization functions 7b2ed09 Fix typos in README

- Python
Published by github-actions[bot] over 5 years ago

galois - galois v0.0.7

79f31db Version bump to 0.0.7 00ef00a Add some basic usage examples to documentation 96403bf Support GF arrays of any signed or unsigned integer type 2733c1d Add the ability to retarget numba ufuncs on-the-fly aa730a0 Fix broken sphinx table of contents 6f24cae Add unit tests for numpy ufunc methods f9bc809 Convert GF polynomial evaluation to a numba gufunc for an 8000x speed-up 008edff Add sparse lookup tables for a large GF(p) field for unit testing 0560ca3 Rename some pytest fixtures 884fafe Add function to find the first primitive root of unity 15441ff Add performance metrics to README daa7df1 Refactor _GF base class and ufunc invocation

- Python
Published by github-actions[bot] over 5 years ago

galois - galois v0.0.6

b97c165 Version bump to 0.0.6 de1d168 Update sphinx autodoc styling 8f40b9f Ensure the GFp abstract base class can't be instantiated 23433d4 Add python supported versions to README 2635f86 Update README to point to stable docs, not latest c1a5549 Add class factory for GF(p) fields 30ca81f Remove verbosity from codecov action 95cde9a Add various algorithms/functions necessary for finite field construction 4393bd0 Add lookup table of primes up to 2^16 74e968a Fix mardownlint errors f720fa0 Add codecov config file setting it to inform-only mode 0a1e3b2 Add unit tests for polynomial objects 075448a Cleanup polynomial strings for x^1 and x^0 008b88f Add testing coverage report with codecov d19fe8b Refactor _GF, GF2, and field unit tests f06f61a Add initial implementation of polynomial class e184418 Use sagemath to generate unit test vectors e6b774e Add example code block in sphinx b328099 Prevent array assignment with values outside the field 34659cd Fix dependent numpy version d27012f Verify field arithmetic is performed on arrays with "valid" elements a5b224f Add GF2 class 1852001 Add pytest config to setup.cfg b4a9205 Add an example jupyter notebook to the docs 100b3fb Add vs code config for pytest and pylint

- Python
Published by github-actions[bot] over 5 years ago

Recent Releases of galois

galois - galois v0.4.6

Changes

Contributors

galois - galois v0.4.5

Changes

Contributors

galois - galois v0.4.4

Changes

Contributors

galois - galois v0.4.3

Changes

Contributors

galois - galois v0.4.2

Changes

Contributors

galois - galois v0.4.1

Changes

Contributors

galois - galois v0.4.0

Changes

Contributors

galois - galois v0.3.10

Changes

Contributors

galois - galois v0.3.9

Changes

Contributors

galois - galois v0.3.8

Changes

Contributors

galois - galois v0.3.7

Changes

Contributors

galois - galois v0.3.6

Changes

Contributors

galois - galois v0.3.5

Changes

Contributors

Commits

galois - galois v0.3.4

Changes

Contributors

Commits

galois - galois v0.3.3

Changes

Contributors

Commits

galois - galois v0.3.2

Changes

v0.3.1

Took forever...

v0.3.2

v0.3.1

v0.3.2

Contributors

Commits

galois - galois v0.3.1

Changes

v0.3.0

Never returns...

v0.3.1

Contributors

Commits

galois - galois v0.3.0

Breaking changes

Changes

v0.2.0

v0.3.0

v0.2.0

v0.3.0

Contributors

Commits

galois - galois v0.2.0

Breaking changes

Changes

Contributors

Commits

galois - galois v0.1.2