Référence de la classe DSPython.polynomial.Term

Terme (tuple de Number ou de None représentant les exposants pour chaque variable) Plus de détails...

Liste de tous les membres

Fonctions membres publiques
def	__repr__
	Renvoie le terme sous forme de string "'Term(tuple des exposants)'".
def	__str__
	Renvoie le terme sous forme de string.
def	cmp_order
	??? Compare les exposants (d'après l'ordre déterminé par order) des 2 Term
def	deriv
	Renvoie la ke dérivée partielle pour la variable d'indice i.
def	eval
	Renvoie le terme évalué en fonction des valeurs de values.
def	partialeval
	Renvoie une "évaluation partielle" du terme sous forme de (coef, Term) en fonction des valeurs de values.

---

Description détaillée

Terme (tuple de Number ou de None représentant les exposants pour chaque variable)

Terme(tuple de Number ou de None
représentant les exposants pour chaque variable)

Définition à la ligne 40 du fichier polynomial.py.

---

Documentation des fonctions membres

def DSPython.polynomial.Term.__repr__

(

self

)

Renvoie le terme sous forme de string "'Term(tuple des exposants)'".

Renvoie le terme sous forme de string "'Term(tuple des exposants)'"

Result: string

O() = ...

Définition à la ligne 45 du fichier polynomial.py.

Références DSPython.polynomial.Term.__str__().

def DSPython.polynomial.Term.__str__	(		self,
			varsstr = ALPHA,
			nonestr = '?',
			mulstr = '*',
			expstr = '^',
			exprstr = '',
			simplify = True
	)

Renvoie le terme sous forme de string.

Renvoie le terme sous forme de string.
varsstr spécifie le caractère des variables utilisées
nonestr spécifie la chaîne de caractères
  représentant les valeurs indéterminées None
Les facteurs sont séparés par multstr.
expstr est placé à gauche de chaque exposant et exprstr à droite.
Si simplify alors chaque élément sera présent dans le résultat,
    sinon passe les variables d'exposant 0
          et passe les exposants 1.
Si le résultat ne contient aucun élément
  alors finalement renvoie '1'.

Pre: varsstr: string assez grand
        pour que chaque variable ait un caractère
     nonestr: string
     multstr: string
     expstr: string
     exprstr: string
     simplify: boolean

Result: string

O() = ...

Définition à la ligne 56 du fichier polynomial.py.

Référencé par DSPython.polynomial.Term.__repr__().

def DSPython.polynomial.Term.cmp_order	(		self,
			other,
			order = None
	)

??? Compare les exposants (d'après l'ordre déterminé par order) des 2 Term

Compare les exposants (d'après l'ordre déterminé par order)
des 2 Term et renvoie -1 si self <  other
               0         ==
               1         >
Si order == None alors utilise l'ordre normal

Pre: other: Term
     order: None
    ou tuple de naturels assez grand
       pour que chaque variable ait un indice

Result: -1, 0 ou 1

O() = ...

Définition à la ligne 103 du fichier polynomial.py.

def DSPython.polynomial.Term.deriv	(		self,
			i = 0,
			k = 1
	)

Renvoie la k^e dérivée partielle pour la variable d'indice i.

Renvoie la kème dérivée partielle pour la variable d'indice i
Si k > 0 alors pour le terme (..., n, ...)
  renvoie (n(n - 1)...(n - k + 1), Term((..., n - k, ...)))
  En particulier si k == 1
    alors renvoie (n, Term((..., n - 1, ...)))
Si k == 0 alors renvoie (1, Term(self))
Si k < 0 alors pour le terme (..., n, ...)
  renvoie (1/((n + 1)...(n - k)), Term((..., n - k, ...)))
  (Si k <= n < 0 alors renvoie (None, Term((..., n - k, ...))))
Si n == None alors renvoie (None, Term((..., n, ...)))
Donc pour (..., n, ...) renvoie toujours
  (numbernone.falling_factorial_pow(n, k), Term((..., n - k, ...)))

Pre: i: natural < len(self)
     k: Integral

Result: (Number ou None, Term)

O() = ...

Définition à la ligne 141 du fichier polynomial.py.

Références DSPython.natural_is().

def DSPython.polynomial.Term.eval	(		self,
			values = 1
	)

Renvoie le terme évalué en fonction des valeurs de values.

Renvoie le terme évalué en fonction des valeurs de values
Pour le terme (a, b, c, ...)
si values est un Number
  alors renvoie values^a * values^b * values^c * ...
si values est une séquence
  alors renvoie values[0]^a * values[1]^b * values[2]^c * ...
Si un des ces Number est None alors renvoie None

Pre: value: Number ou None
    ou tuple (de Number ou de None) assez grand
       pour que chaque variable ait une valeur
    ou list (de Number ou de None) assez grand
       pour que chaque variable ait une valeur

Result: Number ou None

O() = ...

Définition à la ligne 171 du fichier polynomial.py.

def DSPython.polynomial.Term.partialeval	(		self,
			values
	)

Renvoie une "évaluation partielle" du terme sous forme de (coef, Term) en fonction des valeurs de values.

Renvoie une "évaluation partielle" du terme
sous forme de (coef, Term) en fonction des valeurs de values.
Pour chaque Number de values,
  la variable correspondante est évaluée,
  le résultat multiplie coef et l'exposant est réinitialisé à 0,
alors que pour chaque None de values,
  la variable correspondante est ignorée
  et son exposant conservé.
Si le terme est vide alors renvoie (1, Term())
Si le terme contient un exposant None qui doit être évalué
  alors renvoie (None, Term) où les exposants None sont conservés

Pre: value: tuple de Number ou de None assez grand
       pour que chaque variable ait une valeur
    ou list de Number ou de None assez grand
       pour que chaque variable ait une valeur

Result: (Number ou None, Term)

O() = ...

Définition à la ligne 222 du fichier polynomial.py.

---

La documentation de cette classe a été générée à partir du fichier suivant :

• DSPython/polynomial.py