[转载] python反三角函数arctan_Python numpy.arctan() 使用实例

计胤
2023-12-01

参考链接: Python中的numpy.arcsin

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

 Example 1

 def get_polar_t(self):

 mag = self.get_magnitude()

 sizeimg = np.real(self.imgfft).shape

 pol = np.zeros(sizeimg)

 for x in range(sizeimg[0]):

 for y in range(sizeimg[1]):

 my = y - sizeimg[1] / 2

 mx = x - sizeimg[0] / 2

 if mx != 0:

 phi = np.arctan(my / float(mx))

 else:

 phi = 0

 r = np.sqrt(mx**2 + my **2)

 ix = map_range(phi, -np.pi, np.pi, sizeimg[0], 0)

 iy = map_range(r, 0, sizeimg[0], 0, sizeimg[1])

 if ix >= 0 and ix < sizeimg[0] and iy >= 0 and iy < sizeimg[1]:

 pol[x][y] = mag.data[int(ix)][int(iy)]

 pol = MyImage(pol)

 pol.limit(1)

 return pol

 Example 2

 def calc_IndCurrent_cos_range(self,f,t):

 """Induced current over a range of times"""

 Bpx = self.Bpx

 Bpz = self.Bpz

 a2 = self.a2

 azm = np.pi*self.azm/180.

 R = self.R

 L = self.L

 w = 2*np.pi*f

 Ax = np.pi*a2**2*np.sin(azm)

 Az = np.pi*a2**2*np.cos(azm)

 Phi = (Ax*Bpx + Az*Bpz)

 phi = np.arctan(R/(w*L))-np.pi # This is the phase and not phase lag

 Is = -(w*Phi/(R*np.sin(phi) + w*L*np.cos(phi)))*np.cos(w*t + phi)

 Ire = -(w*Phi/(R*np.sin(phi) + w*L*np.cos(phi)))*np.cos(w*t)*np.cos(phi)

 Iim = (w*Phi/(R*np.sin(phi) + w*L*np.cos(phi)))*np.sin(w*t)*np.sin(phi)

 return Ire,Iim,Is,phi

 Example 3

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 4

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 5

 def effect(self, point):

 res = []

 # print(self.centers)

 for center in self.centers:

 center_x, center_y = center

 src_x, src_y = point.pos

 # Check angle

 angle = np.arctan((center_x - src_x) / (center_y - src_y))

 if np.abs(angle) > self.angle / 2:

 continue

 angle = np.deg2rad(90) + angle

 u_len = np.sqrt((center_x - src_x) ** 2 + (center_y - src_y) ** 2)

 reverse_v = (self.r_index - 1) / self.radius - self.r_index / u_len

 v_len = 1 / reverse_v

 if v_len > 0:

 p_type = 'real'

 else:

 p_type = 'fake'

 target = line_end(point.pos, angle, u_len + v_len)

 p = Point(target, p_type, 1)

 # point.passed.append(self)

 res.append(p)

 return tuple(res)

 Example 6

 def _radian_direction(dy,dx):

 '''

 function:

 - based on given dy and dx it calculates direction in radian.

 - used in feature_eng_pt3

 input:

 dy = change in y

 dx = change in x

 output:

 returns radian value (0 to 6.28)

 '''

 if dy < 0.0 and dx > 0.0:

 return (2*np.pi + np.arctan(dy/dx))

 elif dy >=0.0 and dx > 0.0:

 return (np.arctan(dy/dx))

 else:

 return np.pi + np.arctan(dy/dx)

 Example 7

 def flow(self, Kc, Ks, Kz, Ka, numexpr):

 zeros = np.zeros

 where = np.where

 min = np.minimum

 max = np.maximum

 abs = np.absolute

 arctan = np.arctan

 sin = np.sin

 center = (slice( 1, -1,None),slice( 1, -1,None))

 rock = self.center

 ds = self.scour[center]

 rcc = rock[center]

 rock[center] = rcc - ds * Kz

 # there isn't really a bottom to the rock but negative values look ugly

 rock[center] = where(rcc<0,0,rcc)

 Example 8

 def fixOffset(self, offset, img):

 size = img.shape

 finalImg = np.ndarray(size)

 indices = np.indices((self.videoSize[0],self.videoSize[1])).swapaxes(0,2).swapaxes(0,1)

 indices = np.around(indices, decimals=1)

 indices.shape = (self.videoSize[1] * self.videoSize[0], 2)

 phi = 2 * np.arctan(np.exp(indices[:, 1] / self.videoSize[1])) - 1/2 * np.pi - offset[0]

 lamb = indices[:, 0] - offset[1]

 x = lamb

 y = np.log(np.tan(np.pi / 4 + 1/2 * phi)) * self.videoSize[1]

 finalIdx = np.ndarray((self.videoSize[1] * self.videoSize[0], 2))

 finalIdx = np.around(finalIdx, decimals=1).astype(int)

 finalIdx[:, 1] = y % self.videoSize[1]

 finalIdx[:, 0] = x % self.videoSize[0]

 finalImg[indices[:,1], indices[:,0]] = img[finalIdx[:,1], finalIdx[:,0]]

 return finalImg

 Example 9

 def _dip_slip_y(self, y1, y2, ang_dip, q):

 """

 Based on Okada's paper (1985)

 y = down-dip direction

 """

 sn = numpy.sin(ang_dip)

 cs = numpy.cos(ang_dip)

 d_bar = y2*sn - q*cs;

 r = numpy.sqrt(y1**2 + y2**2 + q**2)

 xx = numpy.sqrt(y1**2 + q**2)

 y_bar = y2*cs + q*sn

 a5 = 4.*poisson/cs*numpy.arctan((y2*(xx+q*cs)+xx*(r+xx)*sn)/y1/(r+xx)/cs)

 a1 = 2.0*poisson*(-y1/(cs*(r+d_bar))) - sn/cs * a5

 f = -(y_bar*q/r/(r+y1) + cs*numpy.arctan(y1*y2/q/r) - a1*sn*cs)/(2.0*3.14159)

 return f

 Example 10

 def _dip_slip_x(self, y1, y2, ang_dip, q):

 """

 Based on Okada's paper (1985)

 Added by Xiaoming Wang

 """

 sn = numpy.sin(ang_dip)

 cs = numpy.cos(ang_dip)

 d_bar = y2*sn - q*cs;

 r = numpy.sqrt(y1**2 + y2**2 + q**2)

 xx = numpy.sqrt(y1**2 + q**2)

 #a5 = 4.*poisson/cs*numpy.arctan((y2*(xx+q*cs)+xx*(r+xx)*sn)/y1/(r+xx)/cs)

 a4 = 2.0*poisson/cs*(numpy.log(r+d_bar) - sn*numpy.log(r+y2))

 ytilde = y2*cs + q*sn

 a3 = 2.0*poisson*(ytilde/(cs*(r+d_bar)) - numpy.log(r+y2)) + a4*sn/cs

 f = -(q/r - a3*sn*cs)/(2.0*3.14159)

 return f

 Example 11

 def _dip_slip_x(self, y1, y2, ang_dip, q):

 """

 Based on Okada's paper (1985)

 Added by Xiaoming Wang

 """

 sn = numpy.sin(ang_dip)

 cs = numpy.cos(ang_dip)

 d_bar = y2*sn - q*cs;

 r = numpy.sqrt(y1**2 + y2**2 + q**2)

 xx = numpy.sqrt(y1**2 + q**2)

 #a5 = 4.*poisson/cs*numpy.arctan((y2*(xx+q*cs)+xx*(r+xx)*sn)/y1/(r+xx)/cs)

 a4 = 2.0*poisson/cs*(numpy.log(r+d_bar) - sn*numpy.log(r+y2))

 ytilde = y2*cs + q*sn

 a3 = 2.0*poisson*(ytilde/(cs*(r+d_bar)) - numpy.log(r+y2)) + a4*sn/cs

 f = -(q/r - a3*sn*cs)/(2.0*3.14159)

 return f

 Example 12

 def get_q_per_pixel(self):

 '''Gets the delta-q associated with a single pixel. This is computed in

 the small-angle limit, so it should only be considered approximate.

 For instance, wide-angle detectors will have different delta-q across

 the detector face.'''

 if self.q_per_pixel is not None:

 return self.q_per_pixel

 c = (self.pixel_size_um/1e6)/self.distance_m

 twotheta = np.arctan(c) # radians

 self.q_per_pixel = 2.0*self.get_k()*np.sin(twotheta/2.0)

 return self.q_per_pixel

 # Maps

 ########################################

 Example 13

 def reset_model(self):

 self._min_strike_dist = np.inf

 self._striked = False

 self._strike_pos = None

 qpos = self.init_qpos

 self.ball = np.array([0.5, -0.175])

 while True:

 self.goal = np.concatenate([

 self.np_random.uniform(low=0.15, high=0.7, size=1),

 self.np_random.uniform(low=0.1, high=1.0, size=1)])

 if np.linalg.norm(self.ball - self.goal) > 0.17:

 break

 qpos[-9:-7] = [self.ball[1], self.ball[0]]

 qpos[-7:-5] = self.goal

 diff = self.ball - self.goal

 angle = -np.arctan(diff[0] / (diff[1] + 1e-8))

 qpos[-1] = angle / 3.14

 qvel = self.init_qvel + self.np_random.uniform(low=-.1, high=.1,

 size=self.model.nv)

 qvel[7:] = 0

 self.set_state(qpos, qvel)

 return self._get_obs()

 Example 14

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 15

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 16

 def angularpixelarea(self):

 # get the first instrument element

 instruments = self.tree.xpath("//instruments/*[1]")

 if len(instruments) != 1: raise ValueError("No instruments in ski file")

 instrument = instruments[0]

 # get the distance in m

 d = self.units().convert(instrument.get("distance"), to_unit='m', quantity='distance')

 # get the field of view in m

 fovx = self.units().convert(instrument.get("fieldOfViewX"), to_unit='m', quantity='length')

 fovy = self.units().convert(instrument.get("fieldOfViewY"), to_unit='m', quantity='length')

 # get the number of pixels

 nx = int(instrument.get("pixelsX"))

 ny = int(instrument.get("pixelsY"))

 # calculate the angular pixel area

 sx = 2 * arctan(fovx / nx / d / 2)

 sy = 2 * arctan(fovy / ny / d / 2)

 return sx * sy

 ## This function returns a list of instrument names, in order of occurrence in the ski file.

 Example 17

 def orientation_angle(self):

 """

 This function ...

 :return:

 """

 diag_a = self.pixel_scale_matrix[0,1]

 diag_b = self.pixel_scale_matrix[1,0]

 if not np.isclose(diag_a, diag_b, rtol=0.05):

 warnings.warn("The diagonal elements of the pixel scale matrix are not equal: " + repr(diag_a) + " and " + repr(diag_b))

 first = self.pixel_scale_matrix[0,0]

 radians = np.arctan(diag_a / first)

 degrees = radians / math.pi * 180.

 return Angle(degrees, "deg")

 # -----------------------------------------------------------------

 Example 18

 def angularpixelarea(self):

 # get the first instrument element

 instruments = self.tree.xpath("//instruments/*[1]")

 if len(instruments) != 1: raise ValueError("No instruments in ski file")

 instrument = instruments[0]

 # get the distance in m

 d = self.units().convert(instrument.get("distance"), to_unit='m', quantity='distance')

 # get the field of view in m

 fovx = self.units().convert(instrument.get("fieldOfViewX"), to_unit='m', quantity='length')

 fovy = self.units().convert(instrument.get("fieldOfViewY"), to_unit='m', quantity='length')

 # get the number of pixels

 nx = int(instrument.get("pixelsX"))

 ny = int(instrument.get("pixelsY"))

 # calculate the angular pixel area

 sx = 2 * arctan(fovx / nx / d / 2)

 sy = 2 * arctan(fovy / ny / d / 2)

 return sx * sy

 ## This function returns a list of instrument names, in order of occurrence in the ski file.

 Example 19

 def orientation_angle(self):

 """

 This function ...

 :return:

 """

 diag_a = self.pixel_scale_matrix[0,1]

 diag_b = self.pixel_scale_matrix[1,0]

 if not np.isclose(diag_a, diag_b, rtol=0.05):

 warnings.warn("The diagonal elements of the pixel scale matrix are not equal: " + repr(diag_a) + " and " + repr(diag_b))

 first = self.pixel_scale_matrix[0,0]

 radians = np.arctan(diag_a / first)

 degrees = radians / math.pi * 180.

 return Angle(degrees, "deg")

 # -----------------------------------------------------------------

 Example 20

 def conferenceWakeOverlap(X, Y, R):

 n = np.size(X)

 # theta = np.zeros((n, n), dtype=np.float) # angle of wake from fulcrum

 f_theta = np.zeros((n, n), dtype=np.float) # smoothing values for smoothing

 for i in range(0, n):

 for j in range(0, n):

 if X[i] < X[j]:

 z = R/np.tan(0.34906585)

 # print z

 theta = np.arctan((Y[j] - Y[i]) / (X[j] - X[i] + z))

 # print 'theta =', theta

 if -0.34906585 < theta < 0.34906585:

 f_theta[i][j] = (1 + np.cos(9*theta))/2

 # print f_theta

 # print z

 # print f_theta

 return f_theta

 Example 21

 def conferenceWakeOverlap_tune(X, Y, R, boundAngle):

 n = np.size(X)

 boundAngle = boundAngle*np.pi/180.0

 # theta = np.zeros((n, n), dtype=np.float) # angle of wake from fulcrum

 f_theta = np.zeros((n, n), dtype=np.float) # smoothing values for smoothing

 q = np.pi/boundAngle # factor inside the cos term of the smooth Jensen (see Jensen1983 eq.(3))

 # print 'boundAngle = %s' %boundAngle, 'q = %s' %q

 for i in range(0, n):

 for j in range(0, n):

 if X[i] < X[j]:

 # z = R/tan(0.34906585)

 z = R/np.tan(boundAngle) # distance from fulcrum to wake producing turbine

 # print z

 theta = np.arctan((Y[j] - Y[i]) / (X[j] - X[i] + z))

 # print 'theta =', theta

 if -boundAngle < theta < boundAngle:

 f_theta[i][j] = (1. + np.cos(q*theta))/2.

 # print f_theta

 # print z

 # print f_theta

 return f_theta

 Example 22

 def get_cosine_factor_original(X, Y, R0, bound_angle=20.0):

 n = np.size(X)

 bound_angle = bound_angle*np.pi/180.0

 # theta = np.zeros((n, n), dtype=np.float) # angle of wake from fulcrum

 f_theta = np.zeros((n, n), dtype=np.float) # smoothing values for smoothing

 q = np.pi/bound_angle # factor inside the cos term of the smooth Jensen (see Jensen1983 eq.(3))

 for i in range(0, n):

 for j in range(0, n):

 if X[i] < X[j]:

 z = R0/np.tan(bound_angle) # distance from fulcrum to wake producing turbine

 theta = np.arctan((Y[j] - Y[i]) / (X[j] - X[i] + z))

 if -bound_angle < theta < bound_angle:

 f_theta[i][j] = (1. + np.cos(q*theta))/2.

 return f_theta

 Example 23

 def rotate(self,rotation_method='RTZ'):

 ####################################################################################

 #rotate-------------------------------------------------------------------------

 for i in range(0,len(self.rf_st)):

 self.rf_st[i].stats.back_azimuth = self.tr_e.stats.sac['baz']

 self.rf_st.rotate(method='NE->RT')

 if rotation_method == 'LQT':

 r_amp = np.amax(np.amax(self.rf_st[1].data))

 z_amp = np.amax(np.amax(self.rf_st[2].data))

 incidence_angle = np.arctan(r_amp/z_amp) * (180.0/np.pi)

 for i in range(0,len(self.rf_st)):

 self.rf_st[i].stats.inclination = incidence_angle

 self.rf_st.rotate(method='RT->NE')

 self.rf_st.rotate(method='ZNE->LQT')

 ####################################################################################

 Example 24

 def test_branch_cuts(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1

 Example 25

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 26

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 27

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 28

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 29

 def arrow(img,p1,p2):

 cv2.line(s1,p1,p2,(100,255,100),thickness=2)

 cv2.line(s2,p1,p2,(100,255,100),thickness=2)

 dy,dx= np.array(p2)-np.array(p1)

 theta= np.arctan(dy/dx) + (0 if dx>0 else np.pi) if dx!=0 else (1 if dy>0 else -1) * np.pi/2

 phy1=theta+ np.pi*7/6

 phy2=theta+ np.pi*5/6

 R=0.4*np.linalg.norm([dx,dy])

 dx1,dx2= (R*np.cos([phy1,phy2])).astype(np.int)

 dy1,dy2= (R*np.sin([phy1,phy2])).astype(np.int)

 if R<=2:return

 Y1,X1=p1

 Y2,X2=p2

 cv2.line(s1,(dy1+Y2,dx1+X2),p2,(100,255,100),thickness=1)

 cv2.line(s1,(dy2+Y2,dx2+X2),p2,(100,255,100),thickness=1)

 cv2.line(s2,(dy1+Y2,dx1+X2),p2,(100,255,100),thickness=1)

 cv2.line(s2,(dy2+Y2,dx2+X2),p2,(100,255,100),thickness=1)

 #????????????????

 Example 30

 def convertToOpenGLCameraMatrix(K, framebufferSize, near, far):

 """ Convert a camera calibration matrix into OpenGL format. """

 width, height = framebufferSize

 # print 'framebufferSize:', framebufferSize

 fx = K[0,0]

 fy = K[1,1]

 fovy = 2*np.arctan(0.5*height/fy)#*180/np.pi

 aspect = (width*fy)/(height*fx)

 # define the near and far clipping planes

 # near = 0.1

 # far = 100.0

 # fx = 10.0

 # fy = 10.0

 # fovy = 90*(np.pi/180.0)

 # aspect = (width*fy)/(height*fx)

 proj = openGLPerspectiveMatrix(fovy,aspect,near,far)

 return proj

 Example 31

 def test_auto_size_bits_list():

 pytest.skip()

 a = [0.5, 1.2, 3.2]

 b = Sfix.auto_size(a, 18)

 for x, y in zip(a, b):

 np.isclose(y.val, x)

 assert y.left == 2

 assert y.right == -15

 a = [np.arctan(2 ** -i) for i in range(8)]

 b = Sfix.auto_size(a, 18)

 for x, y in zip(a, b):

 np.isclose(y.val, x)

 assert y.left == 0

 assert y.right == -17

 a = [np.arctan(2 ** -i) for i in range(8, 12)]

 b = Sfix.auto_size(a, 18)

 for x, y in zip(a, b):

 np.isclose(y.val, x)

 assert y.left == -8

 assert y.right == -25

 Example 32

 def load(self, ips):

 if ips.imgtype in ('8-bit', 'rgb'):

 self.para = {'bright':0, 'contrast':45}

 self.view = [('slide', (-100,100), 'Brightness', 'bright', ''),

 ('slide', (1,89), 'Contrast', 'contrast', '')]

 if 'not_slice' in self.note:

 self.note.remove('not_slice')

 else :

 self.arange = minv, maxv = ips.img.min(), ips.img.max()

 self.para = {'bright':np.mean(ips.range) - np.mean(self.arange),

 'contrast':round(np.arctan((maxv-minv)/(ips.range[1]-ips.range[0]))/np.pi*180)}

 self.view = [('slide', (-(maxv-minv)/2, (maxv-minv)/2), 'Brightness', 'bright', ''),

 ('slide', (1,89), 'Contrast', 'contrast', '')]

 if not 'not_slice' in self.note:

 self.note.append('not_slice')

 return True

 Example 33

 def reset_model(self):

 self._min_strike_dist = np.inf

 self._striked = False

 self._strike_pos = None

 qpos = self.init_qpos

 self.ball = np.array([0.5, -0.175])

 while True:

 self.goal = np.concatenate([

 self.np_random.uniform(low=0.15, high=0.7, size=1),

 self.np_random.uniform(low=0.1, high=1.0, size=1)])

 if np.linalg.norm(self.ball - self.goal) > 0.17:

 break

 qpos[-9:-7] = [self.ball[1], self.ball[0]]

 qpos[-7:-5] = self.goal

 diff = self.ball - self.goal

 angle = -np.arctan(diff[0] / (diff[1] + 1e-8))

 qpos[-1] = angle / 3.14

 qvel = self.init_qvel + self.np_random.uniform(low=-.1, high=.1,

 size=self.model.nv)

 qvel[7:] = 0

 self.set_state(qpos, qvel)

 return self._get_obs()

 Example 34

 def FitPCA(self, hPCA_Proj):

 '''

 Determine the timing of the inflation event.

 Uses the first component of the pca projection and

 fits A * arctan( (t - t0) / c ) + B to the first pca projection.

 @param hPCA_Proj: The sklearn PCA projection

 @return [t0, c]

 '''

 fitfunc = lambda p,t: p[0]*np.arctan((t-p[1])/p[2])+p[3]

 errfunc = lambda p,x,y: fitfunc(p,x) - y

 dLen = len(hPCA_Proj[:,0])

 pA, success = optimize.leastsq(errfunc,[1.,dLen/2.,1.,0.],args=(np.arange(dLen),hPCA_Proj[:,0]))

 ct = pA[1:3]

 return ct, pA[0]

 Example 35

 def FitPCA(self, hPCA_Proj):

 '''

 Determine the timing of the inflation event from the first component of the pca projection

 fits A * arctan( (t - t0) / c ) + B to the first pca projection, in order to estimate

 source amplitude parameters

 @param hPCA_Proj: The sklearn PCA

 @return ct: the t0, c, and B parameters from the fit

 @return pA[0]: the fitted amplitude parameter

 '''

 fitfunc = lambda p,t: p[0]*np.arctan((t-p[1])/p[2])+p[3]

 errfunc = lambda p,x,y: fitfunc(p,x) - y

 dLen = len(hPCA_Proj[:,0])

 pA, success = optimize.leastsq(errfunc,[1.,dLen/2.,1.,0.],args=(np.arange(dLen),hPCA_Proj[:,0]))

 ct = pA[1:3]

 return ct, pA[0]

 Example 36

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 37

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 38

 def compute_pd_control(self):

 if self.received_data:

 # given the computed wall slope, compute theta, avoid divide by zero error

 if np.abs(self.m) < EPSILON:

 theta = np.pi / 2.0

 x_intercept = 0

 else:

 theta = np.arctan(1.0/self.m)

 # solve for y=0 in y=mx+c

 x_intercept = self.c / self.m

 # x axis is perp. to robot but not perpindicular to wall

 # cosine term solves for minimum distance to wall

 wall_dist = np.abs(np.cos(theta)*x_intercept)

 # control proportional to angular error and distance from wall

 distance_term = self.direction_muliplier * KP * (wall_dist - TARGET_DISTANCE)

 angle_term = KD * theta

 control = angle_term + distance_term

 # avoid turning too sharply

 self.control = (np.clip(control, -0.3, 0.3), SPEED)

 Example 39

 def rotate_image(img_src, angle,scale ,crop=True):

 img_src,size_dest= pad_image(img_src,scale)

 size = tuple(np.array([img_src.shape[1], img_src.shape[0]]))

 org_h=size[1]

 org_w=size[0]

 src_r = np.sqrt((size[0]/2.0)**2+(size[1]/2.0)**2)

 org_angle =np.arctan(float(org_h)/org_w)

 dest_h = size_dest[0]

 dest_w = size_dest[1]

 center = tuple(np.array([img_src.shape[1] * 0.5, img_src.shape[0] * 0.5]))

 dsize= (dest_w,dest_h)

 rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)

 img_rot = cv2.warpAffine(img_src, rotation_matrix, size, flags=cv2.INTER_CUBIC)

 if crop:

 x,y,w,h = cv2.boundingRect(img_rot[:,:,3])

 return img_rot[y:y+h, x:x+w,:]

 else:

 return img_rot

 Example 40

 def rotate_image(img_src, angle,scale ):

 img_src,size_dest= pad_image(img_src,scale)

 size = tuple(np.array([img_src.shape[1], img_src.shape[0]]))

 org_h=size[1]

 org_w=size[0]

 src_r = np.sqrt((size[0]/2.0)**2+(size[1]/2.0)**2)

 org_angle =np.arctan(float(org_h)/org_w)

 dest_h = size_dest[0]

 dest_w = size_dest[1]

 center = tuple(np.array([img_src.shape[1] * 0.5, img_src.shape[0] * 0.5]))

 dsize= (dest_w,dest_h)

 rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)

 img_rot = cv2.warpAffine(img_src, rotation_matrix, size, flags=cv2.INTER_CUBIC)

 x,y,w,h = cv2.boundingRect(img_rot[:,:,3])

 return img_rot[y:y+h, x:x+w,:]

 Example 41

 def test_branch_cuts_complex64(self):

 # check branch cuts and continuity on them

 yield _check_branch_cut, np.log, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log2, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log10, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.log1p, -1.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.sqrt, -0.5, 1j, 1, -1, True, np.complex64

 yield _check_branch_cut, np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64

 yield _check_branch_cut, np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64

 yield _check_branch_cut, np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64

 # check against bogus branch cuts: assert continuity between quadrants

 yield _check_branch_cut, np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64

 yield _check_branch_cut, np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64

 Example 42

 def test_against_cmath(self):

 import cmath

 points = [-1-1j, -1+1j, +1-1j, +1+1j]

 name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',

 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

 atol = 4*np.finfo(np.complex).eps

 for func in self.funcs:

 fname = func.__name__.split('.')[-1]

 cname = name_map.get(fname, fname)

 try:

 cfunc = getattr(cmath, cname)

 except AttributeError:

 continue

 for p in points:

 a = complex(func(np.complex_(p)))

 b = cfunc(p)

 assert_(abs(a - b) < atol, "%s %s: %s; cmath: %s" % (fname, p, a, b))

 Example 43

 def arctan_func(xvals, a, b, c):

 '''

 --------------------------------------------------------------------

 This function generates predicted ability levels given data (xvals)

 and parameters a, b, and c, from the following arctan function:

 y = (-a / pi) * arctan(b * x + c) + (a / 2)

 --------------------------------------------------------------------

 INPUTS:

 xvals = (N,) vector, data inputs to arctan function

 a = scalar, scale parameter for arctan function

 b = scalar, curvature parameter for arctan function

 c = scalar, shift parameter for arctan function

 OTHER FUNCTIONS AND FILES CALLED BY THIS FUNCTION: None

 OBJECTS CREATED WITHIN FUNCTION:

 yvals = (N,) vector, predicted values (output) of arctan function

 RETURNS: yvals

 --------------------------------------------------------------------

 '''

 yvals = (-a / np.pi) * np.arctan(b * xvals + c) + (a / 2)

 return yvals

 Example 44

 def arctan_func(xvals, a, b, c):

 '''

 --------------------------------------------------------------------

 This function generates predicted ability levels given data (xvals)

 and parameters a, b, and c, from the following arctan function:

 y = (-a / pi) * arctan(b * x + c) + (a / 2)

 --------------------------------------------------------------------

 INPUTS:

 xvals = (N,) vector, data inputs to arctan function

 a = scalar, scale parameter for arctan function

 b = scalar, curvature parameter for arctan function

 c = scalar, shift parameter for arctan function

 OTHER FUNCTIONS AND FILES CALLED BY THIS FUNCTION: None

 OBJECTS CREATED WITHIN FUNCTION:

 yvals = (N,) vector, predicted values (output) of arctan function

 RETURNS: yvals

 --------------------------------------------------------------------

 '''

 yvals = (-a / np.pi) * np.arctan(b * xvals + c) + (a / 2)

 return yvals

 Example 45

 def fov(self):

 """

 Returns the field of view for each axis

 """

 return np.float32([np.arctan(self.shape[1] * 0.5 / self.fx),

 np.arctan(self.shape[0] * 0.5 / self.fy)]) * 2.0

 Example 46

 def dynamics(q, u, p):

 """

 Returns state derivative qdot.

 Takes current state q, motor input torque u, and disturbance torque p.

 See (rederived with incline).

 """

 # Angle of pendulum in incline frame

 ang = q[2] - incline

 # Mass matrix

 M = np.array([

 [(mass_wheel + mass_pend)*radius**2 + inertia_wheel, mass_pend*radius*cw_to_cm[1]*np.cos(ang)],

 [mass_pend*radius*cw_to_cm[1]*np.cos(ang), inertia_pend + mass_pend*cw_to_cm[1]**2]

 ])

 # Gravity effect

 g = np.array([

 -mass_pend*radius*cw_to_cm[1]*q[3]**2*np.sin(ang) + mass_wheel*radius*gravity[1]*np.sin(incline),

 mass_pend*gravity[1]*cw_to_cm[1]*np.sin(q[2])

 ])

 # Friction force

 d = np.array([

 -friction_wheel * (q[1] + np.arctan(q[1])),

 friction_pend * q[3]

 ])

 # Dynamics

 accel_wheel_neg, accel_pend = npl.inv(M).dot(np.array([-u, p+u]) - g - d)

 return np.array([q[1], -accel_wheel_neg*radius, q[3], accel_pend])

 ################################################# SIMULATION

 # Define time domain

 Example 47

 def cart2sph(x, y, z):

 """ Convert cartesian to spherical coordinates.

 Attributes

 ----------

 x : float

 x-coordinate

 y : float

 y-coordinate

 z : float

 z-coordinate

 Returns

 -------

 float

 radius

 float

 aziumth

 float

 elevation

 """

 r = np.sqrt(x**2 + y**2 + z**2)

 if x > 0 and y > 0:

 az = np.arctan(y / x)

 elif x > 0 and y < 0:

 az = 2*np.pi - np.arctan(-y / x)

 elif x < 0 and y > 0:

 az = np.pi - np.arctan(-y / x)

 elif x < 0 and y < 0:

 az = np.pi + np.arctan(y / x)

 elif x == 0 and y > 0:

 az = np.pi / 2

 elif x == 0 and y < 0:

 az = 3 * np.pi / 2

 elif y == 0 and x > 0:

 az = 0

 elif y == 0 and x < 0:

 az = np.pi

 elev = np.arccos(z / r)

 return r, az, elev

 Example 48

 def ellipse_angle_of_rotation( a ):

 b,c,d,f,g,a = a[1]/2, a[2], a[3]/2, a[4]/2, a[5], a[0]

 return 0.5*NP.arctan(2*b/(a-c))

 Example 49

 def ellipse_angle_of_rotation2( a ):

 b,c,d,f,g,a = a[1]/2, a[2], a[3]/2, a[4]/2, a[5], a[0]

 if b == 0:

 if a > c:

 return 0

 else:

 return NP.pi/2

 else:

 if a > c:

 return NP.arctan(2*b/(a-c))/2

 else:

 return NP.pi/2 + NP.arctan(2*b/(a-c))/2

 Example 50

 def radial_filter(order, freq, array_configuration, amp_maxdB=40):

 """Generate modal radial filter of specified order and frequency

 Parameters

 ----------

 order : array_like

 order of filter

 freq : array_like

 Frequency of modal filter

 array_configuration : ArrayConfiguration

 List/Tuple/ArrayConfiguration, see io.ArrayConfiguration

 amp_maxdB : int, optional

 Maximum modal amplification limit in dB [Default: 40]

 Returns

 -------

 dn : array_like

 Vector of modal frequency domain filter of shape [nOrders x nFreq]

 """

 array_configuration = ArrayConfiguration(*array_configuration)

 extrapolation_coeffs = array_extrapolation(order, freq, array_configuration)

 extrapolation_coeffs[extrapolation_coeffs == 0] = 1e-12

 a_max = 10 ** (amp_maxdB / 20)

 limiting_factor = 2 * a_max / _np.pi * _np.abs(extrapolation_coeffs) * _np.arctan(_np.pi / (2 * a_max * _np.abs(extrapolation_coeffs)))

 return limiting_factor / extrapolation_coeffs

 类似资料: