Return Poly.coeffs in the oder that were provided

I think it would be useful to get the coefficients in the order that were provided to the constructor.

For example,

import galois
from galois import GF2

# 1 + x^4 + x^6
poly = galois.Poly([1, 0, 1, 0, 0, 0, 1], field=GF2, order="asc")
poly.coeffs

I would expect to respect the order="asc" and return

GF([1, 0, 1, 0, 0, 0, 1], order=2)

instead of

GF([1, 0, 0, 0, 1, 0, 1], order=2)

A bit offtopic, but why is descending order the default and preferred one (for __str__, Poly.string, etc.)? Would it make sense to use same order as numpy.polynomial.polynomial.Polynomial.coef, which is ascending?

[mhostetter]

Hey. To be candid, the polynomial coefficient ordering was something I debated quite a bit. I settled on something and decided to wait for feedback from users.

I do think it’s a good idea to allow preservation of the coefficient ordering. Perhaps that could be accomplished by adding a Poly.order property that holds the order kwarg value used at construction, either "asc" or "desc". Then, Poly.coeffs would return the coefficients in Poly.order order.

Are you also suggesting that if the new property Poly.order = "asc" that str() and Poly.string should return the string representation of the polynomial with ascending degrees? For instance, Poly(1 + x^4 + x^6, GF(2)) and 1 + x^4 + x^6 when Poly.order = "asc"?

As to the default, again I debated that. I’m open to changing the default to ascending. I’ve seen that in other libraries ascending is common.

To be clear up a typo (I think) from your example… Since you specified order="asc", that polynomial is 1 + x^2 + x^6 not 1 + x^4 + x^6. Do you agree?

In [1]: import galois

In [2]: poly = galois.Poly([1, 0, 1, 0, 0, 0, 1], order="asc")

In [3]: poly
Out[3]: Poly(x^6 + x^2 + 1, GF(2))

# Currently, coefficients are always in descending order
In [4]: poly.coeffs
Out[4]: GF([1, 0, 0, 0, 1, 0, 1], order=2)

[iyanmv]

Yes, I think so. Thanks!