Discussion :

[anthonystaltaro]

Bonjour, j'ai un probleme concernant les operations avec les "Decimal". En fait j'ai besoin d'utiliser "Decimal" pour pouvoir utiliser des nombres tels que exp(1800) par exemple. Mais je ne parvient pas à multiplier un decimal par un complex....Python (V2.4.4) n'accepte pas ce type de multiplication :

decimal*exp(1j*450) (par exemple)

Il me dit alors'unsupported operand type(s) for *:'complex' and 'Decimal'


Kkun aurait il une idee pour multiplier un decimal et un complex???

MERCI

[tyrtamos]

Bonjour,

Le type complex intégré à python est pratique, parce qu'il permet des calculs de base déjà prévus (addition, multiplication, etc...), et même des calculs plus élaborés avec le module cmath.

Par contre, créer un nouveau nombre complexe avec des grands nombres type "Decimal" est accepté à condition que la conversion en flottant reste possible:

Code :

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

1
2
3
4
 
z = complex(Decimal("27182818284590452353602874"), Decimal("7"))
print z
(2.71828182846e+025+7j)

Donc, dès que tu utilises le type de donnée complex, ses composantes réelles et imaginaires sont réduites aux flottants.

Cela veut dire que si tu veux traiter des complexes avec des parties réelles et imaginaire énormes dépassant les limites des flottants (env. 1.0E300), il te reste à les traiter comme des listes x = (reel,imag), et à créer les quelques fonctions de calculs de complexes. Si tu veux aller plus loin, Python permet d'ailleurs pas mal de possibilités pour créer un nouveau type de données sous forme de classe, et pour définir les opérateurs de calculs correspondants.

Tyrtamos

[rambc]

Cela veut dire que si tu veux traiter des complexes avec des parties réelles et imaginaire énormes dépassant les limites des flottants (env. 1.0E300), il te reste à les traiter comme des listes x = (reel,imag), et à créer les quelques fonctions de calculs de complexes. Si tu veux aller plus loin, Python permet d'ailleurs pas mal de possibilités pour créer un nouveau type de données sous forme de classe, et pour définir les opérateurs de calculs correspondants.

Un exemple ? J'aurais voulu créer des quaternions. Si tu montres comment redéfinir les complexes, cela m'aiderait. J'imagine que l'on surclasse et on redéfinit les opérations __add,... etc. C'est bien cela.

[tyrtamos]

Un exemple ? J'aurais voulu créer des quaternions. Si tu montres comment redéfinir les complexes, cela m'aiderait. J'imagine que l'on surclasse et on redéfinit les opérations __add,... etc. C'est bien cela.

Oui, c'est bien à cela que je pense.

Voilà un tout petit exemple de création d'un nouveau type de nb complexe:

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
 
class compl(object):
 
    def __init__(self, x, y=0):
        self.x = x
        self.y = y
 
    def __str__(self):
        return "(%s,%si)" % (self.x,self.y)
 
    def __add__(self,autre):
        return self.__class__(self.x+autre.x, self.y+autre.y)
 
    def __mul__(self,autre):
        return self.__class__(self.x*autre.x-self.y*autre.y, self.x*autre.y+self.y*autre.x)

Utilisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
x = compl(1,3)
print x
(1,3i)
 
y = compl(4,7)
print y
(4,7i)
 
print x+y
(5,10i)
 
print x*y
(-17,19i)

On peut vérifier les résultats avec le code suivant:

Code :

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

1
2
3
4
5
 
x = complex(1,3)
y = complex(4,7)
print x+y
print x*y

Mais bon. Pour traiter le cas complet, il y a du boulot...

Tyrtamos

[rambc]

Merci.

[rambc]

Mais bon. Pour traiter le cas complet, il y a du boulot...

Je viens de tester cela et c'est effectivement très simple à utiliser. Par contre, pourquoi dis-tu qu'il y a du boulot ?

[tyrtamos]

Bonjour rambc,

Cela fait du boulot si on veut faire l'intégration complète du nouveau type dans python. Par exemple, je pensais à un nouveau type de nb complexes utilisant uniquement des grands nombres "Decimal()". Si on veut traiter complètement un cas comme celui-là, on peut s'inspirer de toutes les méthodes déjà associées à complex:

Code :

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

1
2
3
 
dir(complex)
['__abs__', '__add__', '__class__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__int__', '__le__', '__long__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__nonzero__', '__pos__', '__pow__', '__radd__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__str__', '__sub__', '__truediv__', 'conjugate', 'imag', 'real']

Je pense que certaines méthodes comme __coerce__ ou __float__ permettent d'intégrer les mécanismes de conversion automatiques dans les calculs d'expression python.

Et il en manque. Par exemple, il manque une méthode "argument()" qui nécessite une fonction de type "atan2" qui n'existe pas dans le module "decimal" et qu'il faut donc refaire...

On peut aller plus loin en recréant le contenu du module cmath avec les Decimal():

Code :

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

1
2
3
 
dir(cmath)
['__doc__', '__name__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'log', 'log10', 'pi', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Mais bon. Pour traiter un problème ponctuel, il n'est peut-être pas nécessaire d'en faire autant.

Il n'empêche que cette méthode marche très bien, et que je ne connais pas beaucoup de langages dans lesquels c'est possible aussi facilement...

Tyrtamos