Python conversion entre les coordonnées

Sont là des fonctions de conversion entre les différents systèmes de coordonnées?

Par exemple, Matlab a [rho,phi] = cart2pol(x,y) pour la conversion de cartésiennes en coordonnées polaires. Semble comme il devrait être dans numpy ou scipy.

InformationsquelleAutor cpc333 | 2014-01-04

coordinate-systems python

66

Utilisation de numpy, vous pouvez définir les éléments suivants:
```
import numpy as np

def cart2pol(x, y):
    rho = np.sqrt(x**2 + y**2)
    phi = np.arctan2(y, x)
    return(rho, phi)

def pol2cart(rho, phi):
    x = rho * np.cos(phi)
    y = rho * np.sin(phi)
    return(x, y)
```
- Dans le cas où l'on n'a pas x et y séparément, mais à l'intérieur d'un tableau numpy, numpy.linalg.norm(arr) est très pratique comme solution de rechange à np.sqrt(arr[:, 0]**2....)
- Alternativement arr**2 sera place tous les éléments de manière indépendante, à côté, vous np.somme(arr,axis=1) les lignes, puis enfin **.5 à sqrt il ainsi.
- et puis quoi? que faites-vous avec x,y?
InformationsquelleAutor nzh
13

Les questions /réponses peut être simplifiée:
```
from numpy import exp, abs, angle

def polar2z(r,theta):
    return r * exp( 1j * theta )

def z2polar(z):
    return ( abs(z), angle(z) )
```
Ou encore:
```
polar2z = lambda r,θ: r * exp( 1j * θ )
z2polar = lambda z: ( abs(z), angle(z) )
```
Remarque également le travail sur les tableaux!
```
rS, thetaS = z2polar( [z1,z2,z3] )
zS = polar2z( rS, thetaS )
```
- J'aime bien, mais depuis que la question commence par x et y (pas z), je voudrais ajouter la ligne simple z = x + 1j * y
- comment cela fonctionne? polar2z renvoie un seul argument!
- polar2z(r,theta) puis x = np.real(z) et y = np.imag(z) Aussi, np.angle() a un deg option qui renvoie degrés au lieu de radians. Vous pouvez simplement passer que par le biais de z2polar() si vous voulez degrés.
- Cela semble supposer que z est exprimée comme un nombre complexe. Pour les autres formes, vous devez d'abord convertir complexes, puis d'appliquer cette fonction.
InformationsquelleAutor P i

Si vous ne pouvez pas le trouver dans numpy ou scipy, ici sont un couple de fonctions rapides et une classe point:

import math
def rect(r, theta):
"""theta in degrees
returns tuple; (float, float); (x,y)
"""
x = r * math.cos(math.radians(theta))
y = r * math.sin(math.radians(theta))
return x,y
def polar(x, y):
"""returns r, theta(degrees)
"""
r = (x ** 2 + y ** 2) ** .5
if y == 0:
theta = 180 if x < 0 else 0
elif x == 0:
theta = 90 if y > 0 else 270
else:
theta = math.degrees(math.atan(float(y) / x))
return r, theta
class Point(object):
def __init__(self, x=None, y=None, r=None, theta=None):
"""x and y or r and theta(degrees)
"""
if x and y:
self.c_polar(x, y)
elif r and theta:
self.c_rect(r, theta)
else:
raise ValueError('Must specify x and y or r and theta')
def c_polar(self, x, y, f = polar):
self._x = x
self._y = y
self._r, self._theta = f(self._x, self._y)
self._theta_radians = math.radians(self._theta)
def c_rect(self, r, theta, f = rect):
"""theta in degrees
"""
self._r = r
self._theta = theta
self._theta_radians = math.radians(theta)
self._x, self._y = f(self._r, self._theta)
def setx(self, x):
self.c_polar(x, self._y)
def getx(self):
return self._x
x = property(fget = getx, fset = setx)
def sety(self, y):
self.c_polar(self._x, y)
def gety(self):
return self._y
y = property(fget = gety, fset = sety)
def setxy(self, x, y):
self.c_polar(x, y)
def getxy(self):
return self._x, self._y
xy = property(fget = getxy, fset = setxy)
def setr(self, r):
self.c_rect(r, self._theta)
def getr(self):
return self._r
r = property(fget = getr, fset = setr)
def settheta(self, theta):
"""theta in degrees
"""
self.c_rect(self._r, theta)
def gettheta(self):
return self._theta
theta = property(fget = gettheta, fset = settheta)
def set_r_theta(self, r, theta):
"""theta in degrees
"""
self.c_rect(r, theta)
def get_r_theta(self):
return self._r, self._theta
r_theta = property(fget = get_r_theta, fset = set_r_theta)
def __str__(self):
return '({},{})'.format(self._x, self._y)

Ce qui se passe avec polar() quand x = 0?
bonne prise.

InformationsquelleAutor wwii

6

Vous pouvez utiliser le cmath module.

Si le nombre est converti en un complexe de format, puis il devient plus facile de simplement appeler le polar méthode sur le nombre.
```
import cmath
input_num = complex(1, 2) # stored as 1+2j
r, phi = cmath.polar(input_num)
```
InformationsquelleAutor CR Vinay Kumar
5

Il y a une meilleure manière d'écrire du polar(), elle est ici:
```
def polar(x,y):
`returns r, theta(degrees)`
return math.hypot(x,y),math.degrees(math.atan2(y,x))
```
- Pourquoi devrait-il être mieux? Il n'est pas vectorisé.
- Ok, puis utilisez np.hypot. Le point est que vous ne devriez jamais écrire sqrt(x2+y2). hypot existe pour une raison.
- De KeithB commentaire, return np.hypot(x, y), np.arctan2(y, x)
InformationsquelleAutor KeithB
4

Si vos coordonnées sont enregistrées comme des nombres complexes, vous pouvez utiliser cmath

InformationsquelleAutor alcio
-3

De réflexion à ce sujet en général, je vais considérer la clandestinité coordonner le système bien conçu de l'abstraction. Citant l'Oncle Bob et son livre:
```
class Point(object)
def setCartesian(self, x, y)
def setPolar(self, rho, theta)
def getX(self)
def getY(self)
def getRho(self)
def setTheta(self)
```
Avec interface de ce genre n'importe quel utilisateur de la classe Point peut choisir la pratique de la représentation, explicite pas les conversions sont effectuées. Tout cela laid sinus, cosinus, etc. seront cachés dans un seul endroit. Classe Point. Le seul endroit où vous devriez les soins de la représentation est utilisée dans la mémoire de l'ordinateur.
- Pas besoin pour les getters et les setters en Python. Suffit d'utiliser les propriétés.
- Je crois qu'il parle de surcharge de l'initialiseur, et à l'aide de méthodes pour convertir les attributs de classe sous le capot. Je n'ai pas, il a réalisé la question est à propos de la conversion des attributs sous le capot.
InformationsquelleAutor Łukasz Rogalski

Vous devez vous connecter pour publier un commentaire.