numpy.arctan2 () en Python

| | | | | | | | | | | | | | | | | | | |

Sintaxis

numpy.arctan2(x1, x2, /, out=Ninguno, *, donde=Verdadero, transmisión=`mismo_tipo`, orden=`K`, tipo de d =Ninguno, subok=Verdadero[, firma, extobj]) = ufunc `arctan2`

Parámetros
x1 tipo matriz, valor real

y-coordenadas.

x2 tipo matriz, valor real

x-coordenadas. Si x1.shape != x2. forma , deben poder transmitirse a una forma común (que se convierte en la forma de la salida).

out ndarray, Ninguno o tupla de ndarray y Ninguno, opcional

Una ubicación en la que se almacena el resultado. Si se proporciona, debe tener una forma a la que transmitan las entradas. Si no se proporciona o Ninguno, se devuelve una matriz recién asignada. Una tupla (posible solo como argumento de palabra clave) debe tener una longitud igual al número de salidas.

donde array_like, opcional

Esta condición se transmite a través de la entrada. En las ubicaciones donde la condición es verdadera, la matriz out se establecerá en el resultado de ufunc. En otros lugares, la matriz out conservará su valor original. Tenga en cuenta que si se crea una matriz out no inicializada a través del valor predeterminado out=None, las ubicaciones dentro de él donde la condición sea Falsa permanecerán sin inicializar.

**kwargs

Para otros argumentos de solo palabras clave, consulte los ufunc docs .

Devoluciones
ángulo ndarray

Matriz de ángulos en radianes, en el rango [-pi, pi]. Este es un escalar si tanto x1 como x2 son escalares.


Cubriremos NumPy arctan2. Junto con eso, para una mejor comprensión general, también veremos su sintaxis y parámetro. A continuación, veremos la aplicación de toda la parte teórica a través de algunos ejemplos. Pero primero, intentemos analizar la función a través de su definición. Primero, arctan significa el inverso de una función tan. Ahora la función NumPy arctan2 nos ayuda a calcular el valor de arctan entre X1 y X2 en radianes. Aquí, X1 y 2 son parámetros que discutiremos más adelante. A medida que avancemos en este artículo, las cosas se le aclararán. A continuación, veamos la sintaxis asociada con él.
El método numpy.arctan2() calcula la arcotangente elemento-sabio de arr1 / arr2 y selecciona el cuadrante correctamente. El cuadrante se elige de modo que arctan2(x1, x2) sea el ángulo con signo en radianes entre el rayo que termina en el origen y pasa por el punto (1, 0) y el rayo que termina en el origen y pasa por el punto (x2, x1).
Arctan2 es una función inversa de 4 cuadrantes. Teniendo esto en cuenta, da un valor entre 0 y 2pi. El rango de esta función es de -180 a 180 grados. Estos son los 2 puntos clave que distinguen Arctan2 de las funciones arctan.

Diferencia entre Arctan y Arctan2

En esta sección discutiremos la diferencia entre 2 funciones Numpy.

< td>arctan es una función inversa de 2 cuadrantes.
NumPy arctan< /td>NumPy arctan2
arctan2 es una función inversa de 4 cuadrantes.
El rango de la función arctan es de -90 a 90 grados.El rango para arctan2 es de -180 a 180 grados.
Esta función acepta una sola matriz.Este función como se discutió toma 2 matrices de entrada.
Ahora hemos terminado con la parte teórica para NumPy arctan2. Esta sección explora cómo funciona esta función y cómo nos ayuda a obtener el resultado que queremos. Comenzaremos con un ejemplo elemental y poco a poco pasaremos a un ejemplo más complicado.

Ejemplo NumPy Arctan2

importar numpy como ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Arriba vemos un ejemplo simple de nuestra función arctan2. Ahora caminemos línea por línea y comprendamos cómo obtuvimos el resultado. Primero, importamos la función NumPy. Luego definimos nuestros 2 conjuntos de la matriz. Usando la sintaxis de nuestra función y la declaración de impresión, obtenemos el resultado que queremos. Aquí ambos valores ‚Äã‚Äãse dan en radianes. Ahora, si desea verificar el resultado hasta cierto punto. Para hacer esto, necesitamos usar este método en particular:
Ángulo en grados = ángulo en radianes * 180/pi

Si hacemos cálculos sobre nuestros resultados, obtenemos 45 y 30 respuesta de grado. Aquí consideramos pi a 3.14. Las respuestas coinciden y por lo tanto se verifica el resultado.

Numpy Arctan() Ejemplo #2

Ahora supongamos que también queremos obtener los valores ‚Äã‚Äãen grados. Es un proceso simple y se puede hacer con la ayuda del ciclo for y la fórmula discutida anteriormente. Veamos cómo:
importar numpy como ppool grado=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) para vals en b: grado= vals*(180/3.14) print(degree) 

Output:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Vea cómo obtenemos los valores ‚Äã‚Äãen radianes y grados. Todos los pasos son similares al primer ejemplo. La única diferencia que usamos es un "bucle for". Si quiere algo más simple, también podemos usar otro método
importar numpy como ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Aquí todo lo que necesita hacer es multiplicar el valor (180 / 3.14) o (180 / ppool.pi) por la matriz. Definitivamente puede usar este método en el método de bucle for. Pero de cualquier manera, obtendrá el resultado deseado, que es un valor de grado.

Salida:

[-26.57852536 60.02970472] 

NumPy Arctan2 Ejemplo #3

def doa(self, receiver, source): ``` Calcula la dirección de llegada con una fuente y un receptor ``` s_ind = self.key2ind(fuente) r_ind = self.key2ind(receptor) # vector del receptor a la fuente v = self.X[:,s_ind] - self.X[: ,r_ind] acimut = np.arctan2(v[1], v[0]) elevación = np.arctan2(v[2], la.norm(v[ :2])) acimut = acimut + 2*np.pi si acimut < 0. de lo contrario acimut elevación = elevación + 2*np.pi si elevación < 0. de lo contrario elevación return np.array([acimut, elevación]) 

NumPy Arctan2 Ejemplo #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ construye la matriz que mapea la serie de Fourier a la visibilidad:param M: la expansión de la serie de Fourier es limitado de -M a M:param p_mic_x: un vector que contiene las coordenadas x de los micrófonos:param p_mic_y: un vector que contiene las coordenadas y de los micrófonos:return: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(- METRO , M + 1, paso=1), (1, -1), orden=`F`) G = np.zeros((num_mic * (num_mic - 1), 2 * M + 1), dtype=complejo, orden =`C`) count_G = 0 para q en rango(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] para qp en rango(num_mic): si no q == qp: p_x_qqp = p_x_outer - p_mic_x[qp ] p_y_qqp = p_y_outer - p_mic_y[qp] norm_p_qqp = np. sqrt(p_x_qqp ** 2 + p_y_qqp ** 2) phi_qqp = np.arctan2(p_y_qqp, p_x_qqp) G[count_G,:] = ( -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Ejemplo #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) produce el ángulo entre los dos vectores u y v. El argumento opcional direction es por defecto None, que especifica que el menor posible se informe el ángulo entre los vectores; si los vectores u y v son vectores 2D y los parámetros de dirección True y False especifican las direcciones en sentido horario o antihorario, respectivamente; si los vectores son vectores 3D, entonces la dirección puede ser un punto 3D que no está en el plano que contiene u, v y el origen, y especifica alrededor de qué dirección (uxv o vxu) el ángulo en sentido antihorario de u a v debe informarse (el vector de producto cruzado que tiene un producto escalar positivo con el argumento de dirección se usa como eje de rotación). ``` si la dirección es Ninguna: devuelve np.arccos(vector_angle_cos(u, v)) elif la dirección es Verdadera: devuelve np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) la dirección elif es falsa: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: axis1 = normalize(u) axis2 = normalize(np.cross(u, v)) if np.dot(axis2, direction) < 0: axis2 = -axis2 return np.arctan2(np.dot(eje2, v), np.dot(eje1, v)) 

NumPy Arctan2 Ejemplo #6

def __init__(self, línea): data = line.split(` `) data[1:] = [float(x) for x in data[1:]] self.classname = data[0] self.xmin = data[1] self.ymin = data[2 ] self.xmax = datos[1]+datos[3] self.ymax = datos[2]+datos[4] self.box2d = np.array([self.xmin,self.ymin,self.xmax,self. ymax]) self.centroid = np.array([data[5],data[6],data[7]]) self.unused_dimension = np.array([data[8],data[9],data[10 ]]) self.w = datos[8] self.l = datos[9] self.h = datos[10] self.orientation = np.zeros((3,)) self.orientation[0] = data[11 ] auto.orientación[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Ejemplo #7

def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param state: (State object):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (float, int, float) """ # Cross track error current_target_idx, error_front_axle = calcTargetIndex(state, cx, cy) if last_target_idx >= current_target_idx: current_target_idx = last_target_idx # theta_e corrige el error de rumbo theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corrige el error de seguimiento transversal theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Delta del control de dirección = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Ejemplo #8

def calcTargetIndex(state, cx, cy): """:param state: (Objeto de estado):param cx: [float]:param cy: [float]:return: (int, float) """ # Calcular la posición del eje delantero fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Buscar el índice del punto más cercano dx = [fx - icx para icx en cx] dy = [fy - icy para icy en cy] d = [np. sqrt(idx ** 2 + idy ** 2) para (idx, idy) en zip(dx, dy)] error_front_axle = min(d) target_idx = d.index(error_front_axle) target_yaw = normalizeAngle(np.arctan2(fy - cy[target_idx], fx - cx[target_idx]) - state.yaw ) if target_yaw > 0.0: error_front_axle = - error_front_axle return target_idx, error_front_axle 

NumPy Arctan2 Example #9

def vehicle_flat_reverse(zflag, params={}): # Obtener los valores de los parámetros b = params.get(`wheelbase`, 3.) # Crea un vector para almacenar el estado y las entradas x = np.zeros(3) u = np.zeros(2) # Dadas las variables planas, resuelve el estado x[ 0] = zflag[0][0] # posición x x[1] = zflag[1][0] # posición y x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # Y luego resuelve para las entradas u[0] = zflag[0][1] * np.cos(x[2]) + zflag[1][1] * np.sin(x[2]) thdot_v = zflag[1][2 ] * np.cos(x[2]) - zflag[0][2] * np.sin(x[2]) u[1] = np.arctan2(thdot_v, u[0 ]**2 / b) return x, u # Función para calcular el RHS de la dinámica del sistema 

np.arctan2 Ejemplo #10

def GetNeighborCells(self, p, nr, dp = Ninguno): ``` Devuelve todas las celdas a no más de una distancia dada en cualquier dirección desde una celda específica p: La celda de la que obtener los vecinos nr: Radio del vecino dp: Preferencia de dirección ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) for i in range(-nr, nr + 1) for j in range(-nr, nr + 1)] si dp no es Ninguno: #Ordenar puntos según la preferencia de dirección dpa = np.arctan2(dp[1], dp[0]) #Obtener el ángulo de dirección preferido #Preferir direcciones en la dirección de dp; ordenar según la magnitud del ángulo desde la última dirección nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Obtiene la posición 3d actual del jugador 
En este artículo, cubrimos el arctan2 de NumPy. Además, también vimos su sintaxis y parámetros. Para una mejor comprensión, vimos algunos ejemplos. Al final, podemos concluir que NumPy arctan2 es una función que nos ayuda a encontrar el valor de tan inversa entre 2 puntos. Por defecto devuelve el valor en radianes, pero podemos convertirlo a grados usando los métodos discutidos anteriormente. Esperamos que este artículo haya aclarado todas tus dudas. Pero en caso de que tenga alguna pregunta sin resolver, no dude en escribirla en la sección de comentarios. Habiendo leído eso, ¿por qué no leer sobre la siguiente matriz de identidad?

Python atan o atan2, ¿qué debo usar?

Pregunta de StackOverflow

Mi fórmula f=arctan(ImZ/ReZ)

Hay dos opciones :

Opción 1 (atan):

ImZ=-4.593172163003 ImR=-4.297336384845 >>> z=y/x >>> f1=matemáticas.atan(z) >>> f1 0.8186613519278327 

Opción 2 (atan2)

>>> f=matemáticas.atan2(y,x) >>> f -2.3229313016619604 

¿Por qué estos dos resultados son diferentes?

Respuesta:

Atan toma un solo argumento y Atan2 toma dos argumentos. El propósito de usar dos argumentos en lugar de uno es recopilar información sobre los signos de las entradas para devolver el cuadrante apropiado del ángulo calculado, lo cual no es posible para el argumento único Atan

Resultados de atan2 para cada x,y

El resultado de Atan2 siempre está entre -pi y pi.

Referencia: https://en.wikipedia.org/wiki/Atan2

Versión archivada

numpy.arctan2 (arr1, arr2, fundición = & # 39; mismo_tipo & # 39 ;, pedido = & # 39; K & # 39 ;, dtype = Ninguno, ufunc & # 39; arctan & # 39;):
Calcula el arcotangente elemento-sabio de arr1 / arr2 eligiendo el cuadrante correcto.¬†El cuadrante se elige de modo que arctan2 (x1, x2) es el signo del ángulo en radianes entre un rayo que termina en el origen y pasa por el punto (1, 0) y un rayo que termina en el origen y pasa por el punto (x2) x1).

Parámetros:

arr1: [array_like] valor real;  coordenadas y
arr2: [array_like] valor real; coordenadas x. Debe coincidir con la forma de las coordenadas y.
fuera: [ndarray, array_like [ OPCIONAL ]] matriz de la misma forma que x .
donde: [array_like, opcional] El valor verdadero significa calcular las funciones universales (ufunc) en esa posición, el valor falso significa dejar el valor en la salida solo.

Nota:
2pi Radianes = 360 grados
La convención es devolver el ángulo z cuya parte real está en [-pi/2, pi/ 2].

Retorno: Arco tangente elemento a elemento de arr1 / arr2.¬†Los valores ‚Äã‚Äãestán en el intervalo cerrado [-pi / 2, pi / 2].

Código # 1: Trabajo

# Explicación del programa Python3
# arctan2 () función

 

importar numpy como np

 

arr1 = [ - 1 , + 1 < clase de código = "simple">, + 1 , - 1 ]

arr2 = [ - 1 , - 1 , + 1 , + 1 ]

  

ans = np.arctan2 (arr2, arr1) * 180 / np.pi

 

print ( "x- coordenadas:" , arr1)

print ( "coordenadas y: " , arr2)

  

print ( "arctan2 valores:" , ans )

Salida:

coordenadas x: [-1, 1, 1 , -1] coordenadas y: [-1, -1, 1, 1] arctan2 valores: [-135 . -45. 45. 135.] 

Código n.º 2: Trabajo

# Programa Python3 mostrando
# arctan2 () funciones

 

importar numpy as np

 

a = np.arctan2 ([ 0. , 0. < /código> , np.inf ], [ + 0. < clase de código = "simple">, - 0. , np. inf])

 

b = np .arctan2 ([ 1. , - 1. ], [ 0. , 0. ])

 

imprimir ( < clase de código ="cadena ">" a: " , a)

  

imprimir ( "b:" < /código> , b )

Salida:

a: [0. 3.14159265 0.78539816] b: [1.57079633 -1.57079633] 

Enlaces:
arctan2.html#numpy.arctan2>https://docs.scipy.org/doc/numpy-1.13.0/reference/g enerated / numpy.arctan2.html # numpy.arctan2
,

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method