Discussion :

[BBouille]

Bonjour les amis,
J'ai sûrement mal recherché ici et sur le net mais je ne trouve pas de méthode "propre" pour développer les facteurs d'un polynôme.
Ex: (x+1)*(x+2) = x²+3x+2
Existe-t-il une méthode pour un nombre quelconque de facteurs à part celle de développer par boucles successives comme on le ferait à la main?
Si vous aviez un lien je vous en serais drôlement reconnaissant.

[tbc92]

Je suis un bricoleur, plus qu'un utilisateur d'outils existants, donc je ne vais pas beaucoup t'aider.
Mais dans ta recherche d'outils, ...
- as tu trouvé des outils qui traitent des polynômes ? ( et du coup, comment un polynôme sera-t-il stocké, sous forme de tuple, ou autre ...)
- as-tu trouvé des outils pour faire la multiplication de 2 polynômes ?
- Pour faire le produit de 20 ou 30 polynômes, faire les produits 'en chaine', comme on ferait à la main, c'est une formalité, que ce soit en temps de traitement, en terme de programmation (alors que ce serait une plaie à faire à la main!)
En terme de performance, si on veut s'amuser, ça peut être un exercice amusant de se demander si on doit multiplier d'abord les polynômes de degrés 1 entre eux, 2 à 2, puis les polynômes de degré 2 entre eux etc etc.
Ou bien, on prend le premier qu'on multiplier par le 2ème , puis on multiplie le résultat par le 3ème, etc etc.
Mais à moins d'être vraiment obsédé par la performance, ça me paraît très secondaire.

[BBouille]

Je n'ai rien trouvé et je sais qu'il y a toujours mieux que ce que je veux faire, plus mathématique ou élégant.
Si je ne trouve rien j'essaierai de faire comme à la main.
Je comptais utiliser une classe, un type indicé, comportant un coefficient et un exposant tels que dans un polynôme.
Je multiplie par boucle chaque terme de chaque facteur au polynôme formé petit à petit, si c'est une constante on la multiplie par le coefficient du terme en cours sinon (si c'est x) on incrémente l'exposant.
Au fur et à mesure le polynôme en cours s'allonge.
Et à la fin on trie tout et on additionne les coefficients des différents x selon leur exposant.
Je verrais bien des sommes et des produits ou des sommes de produits ou des produits de sommes mais je ne vois pas comment les arranger.

[tbc92]

Tu peux largement simplifier la multiplication.

Voici un code que je viens de faire, je pense qu'on peut encore simplifier un petit peu la boucle sur jj1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
type polynome struct {
	degre   int
	tbCoeff []float64
}
 
func (a polynome) mult(b polynome) polynome {
	var c polynome
	c.degre = a.degre + b.degre
	for i := 0; i <= c.degre; i++ {
		kk := 0.0
		for jj1 := 0; jj1 <= a.degre; jj1++ {
			jj2 := i - jj1
			if jj2 >= 0 && jj2 <= b.degre {
				kk = kk + a.tbCoeff[jj1]*b.tbCoeff[jj2]
			}
		}
		c.tbCoeff = append(c.tbCoeff, kk)
	}
	return c
}

L'idée, c'est qu'on sait que le coeff du terme de degré d, il vient de (0 , d), (1, d-1), (2, d-2) ...
On le sait d'entrée, donc pas besoin de tout calculer, puis de partir à la pêche pour retrouver ce qu'on doit additionner.

[User]

Bonjour,

Pour des polynômes à une seule variable, on peut aussi initialiser la liste des coefs de p de dimension longueur(p1.coefs) + longueur(p2.coefs) - 1, en Python ça ferait :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

p.coefs = [0]*(len(p1.coefs)+len(p2.coefs)-1) # exemple : [0]*3 -> [0, 0, 0]

Puis on boucle sur les termes des polynômes de p1 et p2 pour réaliser le produit p = p1*p2 :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# parcours des indices de p1.coefs
for i1 in range(len(p1.coefs)):
    # parcours des indices de p2.coefs
    for i2 in range(len(p2.coefs)):
         # i1 degré du terme de p1, i2 degré du terme de p2, i1+i2 correspond au degré du terme de p (produit des 2 termes)
	 p.coefs[i1+i2] = p.coefs[i1+i2] + p1.coefs[i1]*p2.coefs[i2] # mise à jour du coef du terme de degré i1+i2

On obtient ainsi les coefs de p :

ex. : [1, 2, 3] -> 1 + 2X + 3X^2

Cela dit c'est une version proche de Python car normalement tout ça se définit à l'aide d'une classe Polynome

Cdlt,

[Guesset]

Bonjour,

Pour la plupart des logiciels et bibliothèques manipulant des expressions (calcul formel notamment), la fonction qui fait le travail se nomme expand.

Salutations