Bonjour,

Je travaille actuellement avec des polynômes. J'ai, à un moment, besoin de faire une division euclidienne de polynômes. J'utilise donc la fonction proposée par Numpy. Voici le bout de code correspondant:

def restediv(Polynome): 
    poly = Polynome
    degre = nppol.Polynomial.degree(Generateur)
    multi = nppol.polypow(nppol.polyx, degre)
    dividende = nppol.polymul(poly, multi)

    
    result = nppol.polydiv(dividende, gen)

    return result

Ce code ci retourne, à la ligne 'result = ...' une erreur (""" unsupported operand types for /: "nd_array" and "polynomials" """). Cependant, nppol.polymul renvoie bien un array (vérifié avec print(type(dividende)) ) et gen est défini comme ceci :

Generateur = nppol.Polynomial([1, 0, 1, 1])
gen = np.array(Generateur)

C'est donc bien un array, ce qui a aussi été vérifié via un print(type(gen)).

La documentation Numpy précise qu'il faut fournir des array_like.

Lorsque les deux arguments sont des array, il y a donc l'erreur (cf. titre). Mais lorsque les deux arguments sont des polynômes, il y a la même erreur. Lorsque j'ai un polynôme et un array, toujours la même erreur. La seule chose qui m'a permis de bouger a été de recopier l'exemple de la documentation, soit quelque chose comme ça :

result = nppol.polydiv((2,2,2), (1,3))

Il me semble alors que les arguments sont des tuples. Or, si je convertis mes tableaux précédents en tuples, j'obtiens l'erreur "operand does not support ufuncs".

Autrement dit, rien ne semble fonctionner, à part rentrer les chiffres à la main entre des parenthèses, ce qui ne me sert à rien.

Pouvez-vous m'aider ?

Merci

je pense que tu n'a pas besoin de faire "gen = np.array(Generateur)" (tu as un array de Polynomial)

mais plutôt gen=Generateur.coeff qui permet d'avoir un array des coefficients 

Merci, mais alors le problème revient à l'erreur : '''operand 'Polynomials' does not support ufuncs''', alors même que rien dans la ligne 8 n'est du type Polynomials. Je ne trouve aucune documentation sur cette erreur ni comment la résoudre (cela m'inquiète un peu même). Une idée des causes, voire d'une solution ?

si, gen comme je l'ai dit est un array de polynomials
tu as un exemple de paramètre Polynome de ta fonction restdiv?

Bonjour,

Je voulais dire qu'en définissant gen comme ceci :

gen = nppol.Polynomial._get_coefficients(Generateur, Generateur)

qui est la seule syntaxe que j'ai trouvée pour renvoyer les coefficients d'un polynôme (Generateur.coeff semble ne pas exister), l'erreur passe de 'unsupported type...' à '''operand 'Polynomials' does not support ufuncs'''.

Je compte fournir à restediv le polynôme renvoyé par cette fonction :

def poly(string):
    coeffs = []
    for i in range(len(string)):
        coeffs.append(string[i])
    
    coeffinv = coeffs[::-1]          #on inverse la liste à cause de l'ordre des coeffs dans nppol.Polynomial
    
    for i in range(len(coeffinv)):
        coeffinv[i] = int(coeffinv[i])
    
    poly_message = nppol.Polynomial(coeffinv)
    
    return poly_message             #retourne le polynôme contenant le message

b = poly(a)

b est alors bien du type Polynomial.
Mais normalement, les paramètres fournis à polydiv sont bien des arrays.

Archerlite a écrit:

gen est défini comme ceci :

Generateur = nppol.Polynomial([1, 0, 1, 1])
gen = np.array(Generateur)

C'est donc bien un array, ce qui a aussi été vérifié via un print(type(gen)).

ok, c'est un array... mais elle contient le seul objet polynome (et pas directement ses coefficients)

Pour le reste, assurez vous que vous passez le même type d'arguments à chaque opération.

Par exemple à la ligne 5, dividende = nppol.polymul(poly, multi) on a un polynome et un ndarray. dividende = nppol.polymul(poly.coef, multi) devrait être mieux.

Bonsoir à tous,

Je viens de résoudre le problème en question.

mps vos messages m'ont fait réfléchir sur ma méthode et j'ai contrôlé tous les types de tous les éléments, tels que poly, multi et autres, mais aussi poly[0] et multi[3] par exemple, pour toutes les variables du programmes.

Il y avait bien une erreur de type concernant le type des coefficients des polynômes présents dans mes arrays. Ils n'étaient pas les mêmes partout. Résoudre cela n'a cependant pas résolu le problème.

Dans ce code :

	
def restediv(Polynome):
    poly = Polynome
    degre = nuppol.Polynomial.degree(Generateur)
    multi = nuppol.polynomial.polypow(nuppol.polynomial.polyx, degre)
    dividende = nuppol.polynomial.polymul(poly, multi)
    result = nuppol.polynomial.polydiv(dividende, Generateur)
 
    return result[1]

Il se trouve queles fonctions de numpy.polynomial(nuppol).polynomial génèrent à chaque fois un polynôme à partir des coefficients d'un array, et retournent un array des coefficients de ce polynome.Autrement dit, lorsque vous voulez faire une division polynomiale, il faut faire la division polynomiale de deux matrices. Je me permets de préciser que c'est TRES CON.

Il me semblait que les objets de type Polynomial étaient des array_like, mais pas du tout. Bref, si jamais cela intéresse quelqu'un, pour faire des calculs entre polynomes, ne jamais utiliser de Polynomials, toujours des arrays.

Archerlite a écrit:

Il me semblait que les objets de type Polynomial étaient des array_like, mais pas du tout. Bref, si jamais cela intéresse quelqu'un, pour faire des calculs entre polynomes, ne jamais utiliser de Polynomials, toujours des arrays.

Polynomial remplace poly1d.

Et si on traduit votre code avec Polynomlial, ça devrait se réduire à:

def restediv(p):
    m = Polynomial([0,1]) * G.degree()
    d = p * m
    return divmod(d, G)


G = Polynomial([1, 0, 1, 1])
P = Polynomial([1, 1])
print(restediv(P))

Il n'est pas interdit de vouloir mélanger la mouture poly1d avec Polynomial mais si on ne fait pas gaffe, c'est juste inconsistant (ce qui n'est pas anormal).