numpy.arctan2() em Python

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

Sintaxe

numpy.arctan2(x1, x2, /, out=Nenhum, *, onde=True >, cast=`same_kind`, ordem=`K`, dtype =Nenhum, subok=Verdadeiro[, assinatura, extobj]) = ufunc `arctan2`

Parâmetros
x1 array_like, valor real

y-coordenadas.

x2 array_like, valor real

x-coordenadas. Se x1.shape != x2. shape , eles devem ser transmitidos para uma forma comum (que se torna a forma da saída).

out ndarray, Nenhum, ou tupla de ndarray e Nenhum, opcional

Um local no qual o resultado é armazenado. Se fornecido, deve ter uma forma para a qual as entradas sejam transmitidas. Se não for fornecido ou Nenhum, uma matriz recém-alocada será retornada. Uma tupla (possível apenas como um argumento de palavra-chave) deve ter comprimento igual ao número de saídas.

onde array_like, opcional

Esta condição é transmitida pela entrada. Em locais onde a condição é True, o array out será definido para o resultado ufunc. Em outros lugares, o array out manterá seu valor original. Observe que, se um array out não inicializado for criado por meio do padrão out=None, os locais dentro dele onde a condição for False permanecerão não inicializados.

**kwargs

Para outros argumentos somente de palavras-chave, consulte os documentos ufunc .

Retorno
ângulo ndarray

Matriz de ângulos em radianos, no intervalo [-pi, pi]. Este é um escalar se x1 e x2 forem escalares.


Vamos cobrir NumPy arctan2. Junto com isso, para um melhor entendimento geral, também veremos sua sintaxe e seus parâmetros. Em seguida, veremos a aplicação de toda a parte teórica através de alguns exemplos. Mas primeiro, vamos tentar analisar a função através de sua definição. Primeiro, arctan significa o inverso de uma função tan. Agora a função NumPy arctan2 nos ajuda a calcular o valor do arco tan entre X1 e X2 em radianos. Aqui, X1 e 2 são parâmetros que discutiremos mais tarde. À medida que avançamos neste artigo, as coisas ficarão mais claras para você. Em seguida, vamos ver a sintaxe associada a ele.
O método numpy.arctan2() calcula o arco tangente elemento de arr1 / arr2 e seleciona o quadrante corretamente. O quadrante é escolhido de forma que arctan2(x1, x2) seja o ângulo com sinal em radianos entre o raio que termina na origem e passa pelo ponto (1, 0) e o raio que termina na origem e passa pelo ponto (x2, x1).
Arctan2 é uma função inversa de 4 quadrantes. Levando isso em consideração, dá um valor entre 0 e 2pi. O intervalo desta função é de -180 a 180 graus. Estes são os 2 pontos-chave que distinguem Arctan2 dos recursos do arctan.

Diferença entre Arctan e Arctan2

Nesta seção, discutiremos a diferença entre 2 funções Numpy.

< td>arctan é uma função inversa de 2 quadrantes.
NumPy arctan< /td>NumPy arctan2
arctan2 é uma função inversa de 4 quadrantes.
O intervalo da função arctan é de -90 a 90 graus.O intervalo para arctan2 é de -180 a 180 graus.
Esta função aceita uma única matriz.Esta função A função como discutido leva 2 arrays de entrada.
Agora terminamos com a parte teórica para NumPy arctan2. Esta seção explora como esse recurso funciona e como ele nos ajuda a obter a saída que desejamos. Começaremos com um exemplo elementar e gradualmente passaremos para um exemplo mais complicado.

Exemplo de NumPy Arctan2

importar numpy como ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 
Acima vemos um exemplo simples da nossa função arctan2. Agora vamos andar linha por linha e entender como chegamos ao resultado. Primeiro, importamos a função NumPy. Então definimos nossos 2 conjuntos do array. Usando a sintaxe de nossa função e a instrução print, obtemos o resultado que queremos. Aqui ambos os valores ‚Äã‚Äãsão dados em radianos. Agora, se você quiser verificar o resultado até certo ponto. Para fazer isso, precisamos usar este método específico:
Ângulo em graus = ângulo em radianos * 180/pi

Se fizermos cálculos em nossos resultados, obteremos 45 e 30 - grau de resposta. Aqui consideramos pi para 3,14. As respostas correspondem e, portanto, o resultado é verificado.

Numpy Arctan() Exemplo #2

Agora suponha que também queremos obter os valores ‚Äã‚Äãem graus. É um processo simples e pode ser feito com a ajuda do loop for e da fórmula discutida acima. Vamos ver como:
import numpy as ppool degree=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) for vals in b: degree= vals*(180/3.14) print(degree) 

Saída:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 
Veja como obtemos os valores ‚Äã‚Äãem radianos e graus. Todas as etapas são semelhantes ao primeiro exemplo. A única diferença que usamos um "for loop". Se você quiser algo mais simples, também podemos usar outro método
import numpy as ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 
Aqui tudo que você precisa fazer é multiplicar o valor (180 / 3,14) ou (180 / ppool.pi) pelo array. Você definitivamente pode usar esse método no método de loop for. Mas de qualquer forma, você obterá a saída desejada, que é um valor de grau.

Saída:

[-26.57852536 60.02970472] 

NumPy Arctan2 Exemplo #3

def doa(self, receiver, source): ``` Calcula a direção de chegada wrt uma fonte e um receptor ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # vetor do receptor para a fonte v = self.X[:,s_ind] - self.X[: ,r_ind] azimute = np.arctan2(v[1], v[0]) elevação = np.arctan2(v[2], la.norm(v[ :2])) azimute = azimute + 2*np.pi se azimute < 0. else azimute elevação = elevação + 2*np.pi se elevação < 0. else elevação return np.array([azimute, elevação]) 

NumPy Arctan2 Exemplo #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ construa a matriz que mapeia a série de Fourier para a visibilidade:param M: a expansão da série de Fourier é limitado de -M a M:param p_mic_x: um vetor que contém microfones x coordenadas:param p_mic_y: um vetor que contém microfones y coordenadas:retorno: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(- M , M + 1, step=1), (1, -1), order=`F`) G = np.zeros((num_mic * (num_mic - 1), 2 * M + 1), dtype=complex, order =`C`) count_G = 0 for q in range(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] for qp in range(num_mic): se não 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 Exemplo #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) fornece o ângulo entre os dois vetores u e v. O argumento opcional direction é por padrão None, que especifica que o menor possível ângulo entre os vetores deve ser relatado; se os vetores u e v são vetores 2D e os parâmetros de direção True e False especificam as direções no sentido horário ou anti-horário, respectivamente; se os vetores são vetores 3D, então a direção pode ser um ponto 3D que não está no plano que contém u, v e a origem, e especifica em torno de qual direção (uxv ou vxu) o ângulo anti-horário de u a v deve ser relatado (o vetor de produto vetorial que tem um produto escalar positivo com o argumento de direção é usado como eixo de rotação). ``` se a direção for Nenhum: retornar np.arccos(vector_angle_cos(u, v)) elif direção for Verdadeiro: retornar np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif direction is False: 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(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 Example #6

def __init__(self, line): 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 = data[1]+data[3] self.ymax = data[2]+data[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 = data[8] self.l = data[9] self.h = data[10] self.orientation = np.zeros((3,)) self.orientation[0] = data[11 ] auto.orientação[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Exemplo #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 o erro de título theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corrige o erro de cross track theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Controle de direção delta = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Exemplo #8

def calcTargetIndex(state, cx, cy): """:param state: (objeto de estado):param cx: [float]:param cy: [float]:return: (int, float) """ # Calcula a posição do eixo dianteiro fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Procura o índice do ponto mais próximo dx = [fx - icx para icx em cx] dy = [fy - gelado para gelado em cy] d = [np. sqrt(idx ** 2 + idy ** 2) para (idx, idy) em 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={}): # Obtém os valores dos parâmetros b = params.get(`wheelbase`, 3.) # Cria um vetor para armazenar o estado e as entradas x = np.zeros(3) u = np.zeros(2) # Dadas as variáveis planas, resolva para o estado x[ 0] = zflag[0][0] # x posição x[1] = zflag[1][0] # y posição x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # E em seguida resolva para as 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 # Função para calcular o RHS da dinâmica do sistema 

np.arctan2 Exemplo #10

def GetNeighborCells(self, p, nr, dp = Nenhum): ``` Retorna todas as células não mais do que uma determinada distância em qualquer direção de uma célula especificada p: A célula da qual obter os vizinhos nr: Raio do vizinho dp: Preferência de direção ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) para i no intervalo(-nr, nr + 1) para j no intervalo(-nr, nr + 1)] se dp não for Nenhum: #Ordenar pontos com base na preferência de direção dpa = np.arctan2(dp[1], dp[0]) #Obter ângulo de direção preferido #Preferir direções em a direção de dp; classificar com base na magnitude do ângulo da última direção nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Obtém a posição 3d atual do player 
Neste artigo, abordamos o arctan2 do NumPy. Além disso, também vimos sua sintaxe e parâmetros. Para melhor compreensão, vimos alguns exemplos. Ao final, podemos concluir que NumPy arctan2 é uma função que esta função nos ajuda a encontrar o valor inverso de tan entre 2 pontos. Por padrão, ele retorna o valor em radianos, mas podemos convertê-lo em graus usando os métodos discutidos acima. Esperamos que este artigo tenha esclarecido todas as suas dúvidas. Mas caso você tenha alguma dúvida não resolvida, sinta-se à vontade para escrevê-la na seção de comentários. Tendo lido isso, por que não ler sobre a seguinte matriz de identidade.

Python atan ou atan2, o que devo usar?

Pergunta do StackOverflow

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

Existem duas opções :

Opção 1 (atan):

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

Opção 2 (atan2)

>>> f=math.atan2(y,x) >>> f -2.3229313016619604 

Por que esses dois resultados são diferentes?

Resposta: h3>

Atan recebe um único argumento e Atan2 recebe dois argumentos. O objetivo de usar dois argumentos em vez de um é coletar informações sobre os sinais das entradas para retornar o quadrante apropriado do ângulo calculado, o que não é possível para o argumento único Atan

atan2 resulta para cada x,y

O resultado de Atan2 está sempre entre -pi e pi.

Referência: https://en.wikipedia.org/wiki/Atan2

Versão arquivada

numpy.arctan2 (arr1, arr2, elenco = & # 39; mesmo_tipo & # 39 ;, ordem = & # 39; K & # 39 ;, dtype = Nenhum, ufunc & # 39; arctan & # 39;):
Calcula o arco-tangente elementar de arr1 / arr2 escolhendo o quadrante correto.¬†O quadrante é escolhido de modo que arctan2 (x1, x2) é o sinal de ângulo em radianos entre um raio que termina na origem e passa pelo ponto (1, 0) e um raio que termina na origem e passa pelo ponto (x2) x1).

Parâmetros:

arr1: [array_like] valor real;  coordenadas y
arr2: [array_like] valor real;¬†coordenadas x.¬†Deve corresponder à forma das coordenadas y.
out: [ndarray, array_like [ OPCIONAL ]] array da mesma forma que x .
onde: [array_like, opcional] True value significa calcular as funções universais (ufunc) naquela posição, False value significa deixar o valor na saída sozinho.

Nota:
2pi Radianos = 360 graus
A convenção é retornar o ângulo z cuja parte real está em [-pi / 2 , pi / 2].

Retorno: Elemento-a-arco tangente de arr1 / arr2.¬†Os valores ‚Äã‚Äãestão no intervalo fechado [-pi / 2, pi / 2].

Código # 1: Trabalho

# programa Python3 explicando
# arctan2 () função

 

import numpy as np

 

arr1 = [ - 1 , + 1 , + 1 , - 1 ]

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

  

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

 

print ( "x- coordenadas:" , arr1)

print ( "y-coordin ates: " , arr2)

  

print ( "arctan2 valores:" , ans )

Saída:

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

Código # 2: Trabalho

# Programa Python3 mostrando
# arctan2 () funções

 

import numpy as np

 

a = np.arctan2 ([ 0. , 0. , np.inf ], [ + 0. , - 0. , np. inf])

 

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

 

print ( " a: " , a)

  

print ( "b:" , b )

Saída:

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

Links:
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