def test_acosh(self): import math self.ftest(math.acosh(1), 0) self.ftest(math.acosh(2), 1.3169578969248168) assert math.isinf(math.asinh(float("inf"))) raises(ValueError, math.acosh, 0)
def test_funcs_multi(self): pi = math.pi # sin family self.assertQuantity(data.sin(Quantity( (0,pi/2), (2,2))), (0,1), (2,0)) self.assertQuantity(data.sinh(Quantity((0,1), (2,2))), (0, math.sinh(1)), (2, math.cosh(1)*2)) self.assertQuantity(data.asin(Quantity((0,0.5), (2,2))), (0,math.asin(0.5)), (2,2/math.sqrt(1-0.5**2))) self.assertQuantity(data.asinh(Quantity((0,1), (2,2))), (0,math.asinh(1)), (2,2/math.sqrt(1+1**2))) # cos family self.assertQuantity(data.cos(Quantity((0,pi/2), (2,2))), (1,0), (0,-2)) self.assertQuantity(data.cosh(Quantity((0,1), (2,2))), (1,math.cosh(1)), (0,math.sinh(1)*2)) self.assertQuantity(data.acos(Quantity((0,0.5), (2,2))), (math.acos(0),math.acos(0.5)), (-2,-2/math.sqrt(1-0.5**2))) self.assertQuantity(data.acosh(Quantity((2,3), (2,2))), (math.acosh(2), math.acosh(3)), (2/math.sqrt(2**2-1),2/math.sqrt(3**2-1))) # tan family self.assertQuantity(data.tan(Quantity((0,1), (2,2))), (0,math.tan(1)), (2,2/math.cos(1)**2)) self.assertQuantity(data.tanh(Quantity((0,1), (2,2))), (0,math.tanh(1)), (2,2/math.cosh(1)**2)) self.assertQuantity(data.atan(Quantity((0,1), (2,2))), (0, math.atan(1)), (2,2/(1+1**2))) self.assertQuantity(data.atan2(Quantity((0,1), (2,2)), Quantity((1,1), (0,0))), (0,math.atan(1)), (2,2/(1+1**2))) self.assertQuantity(data.atanh(Quantity((0,0.5), (2,2))), (0,math.atanh(0.5)), (2,2/(1-0.5**2))) #misc self.assertQuantity(data.sqrt(Quantity((1,4), (2,2))), (1,2), (1,1/2)) self.assertQuantity(data.exp(Quantity((1,4), (2,2))), (math.e, math.e**4), (2 * math.e,2*math.e**4)) self.assertQuantity(data.log(Quantity((1,4), (2,2))), (0, math.log(4)), (2,1/2))
def cheb(f,n,e): if abs(f)<1: t=math.cos(float(n)*math.acos(float(f))) elif f>=1: t=math.cosh(float(n)*math.acosh(float(f))) elif f<=-1: t=-1**n*math.cosh(float(n)*math.acosh(float(-f))) return 1.0/(float(float(1.0+float(e**2)*float(t**2)))**.5)
def testAcosh(self): self.assertRaises(TypeError, math.acosh) self.ftest('acosh(1)', math.acosh(1), 0) self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) self.assertRaises(ValueError, math.acosh, 0) self.assertRaises(ValueError, math.acosh, -1) self.assertEquals(math.acosh(INF), INF) self.assertRaises(ValueError, math.acosh, NINF) self.assert_(math.isnan(math.acosh(NAN)))
def hexagon_sides(a, b, c): cosha, coshb, coshc = map(math.cosh, [a, b, c]) sinha, sinhb, sinhc = map(math.sinh, [a, b, c]) sides = [a, math.acosh((cosha * coshb + coshc) / (sinha * sinhb)), b, math.acosh((coshb * coshc + cosha) / (sinhb * sinhc)), c, math.acosh((coshc * cosha + coshb) / (sinhc * sinha))] return sides
def __init__(self, S, a, metal, dielec): '''\n S: center-to-center conductor separation, [unit: m]\n a: conductor radius, [unit: m]\n metal: conductor material, [unit: material]\n dielec: dielectric material between conductors, [unit: material]''' self.S = S self.a = a self.sigma = cond(metal) self.eps = dielec_const(dielec) self.mu = 1*spc.mu_0 # mu_r = 1 self.L = self.mu*math.acosh(S/(2*a))/math.pi self.C = math.pi*self.eps.real/math.acosh(S/(2*a))
def hyperbolic_fun_cal(inp_val1, opn_type): oprn_dic = { '1': 'inverse hyperbolic cosine of x', '2':'inverse hyperbolic sine of x', '3':' inverse hyperbolic tangent of x', '4':'hyperbolic cosine of x', '5':'hyperbolic sine of x', '6':'hyperbolic tangent of x'} if int(opn_type) == 1: output = math.acosh(float(inp_val1)) return str(output) if int(opn_type) == 2: output = math.asinh(float(inp_val1)) return str(output) if int(opn_type) == 3: output = math.atanh(float(inp_val1)) return str(output) if int(opn_type) == 4: output = math.cosh(float(inp_val1)) return str(output) if int(opn_type) == 5: output = math.sinh(float(inp_val1)) return str(output) if int(opn_type) == 6: output = math.tanh(float(inp_val1)) return str(output) else: return "Invalid Operation"
def cosh_const_effective_mass_errors(self, dt): jkasv = self.jackknife_average_sub_vev() jkemass = {} for cfg in self.configs: asvc = jkasv[cfg] emass = {} asvct = {t: asvc[t+dt] - asvc[t] for t in self.times[:-dt]} for t in self.times[dt:-(dt+1)]: if t in self.emass_skip_times: emass[t] = 0.0 continue try: emass[t] = (1.0 / float(dt))*math.acosh((asvc[t+dt] + asvc[t-dt])/(2.0*asvc[t])) except ValueError: #logging.debug("invalid argument to log, setting to zero") emass[t] = 0.0 except ZeroDivisionError: logging.debug("div by zero, setting to zero") emass[t] = 0.0 except KeyError: logging.error("index out of range") jkemass[cfg] = emass jkemassobj = configtimeobj.Cfgtimeobj.fromDataDict(jkemass) effmass_dt = self.cosh_const_effective_mass(dt) return {t: jackknife.errorbars(effmass_dt[t], jkemassobj.get(time=t)) for t in self.times[dt:-(dt+dt)]}
def cosh_effective_mass_errors(self, dt, fast=True, period=None): if fast: logging.info("cosh emass computed fast method") period = self.period T = self.period_check(period) jkasv = self.jackknife_average_sub_vev() jkemass = {} for cfg in self.configs: asvc = jkasv[cfg] emass = {} for t in self.times[dt:-dt]: if t in self.emass_skip_times: emass[t] = 0.0 continue try: guess = (1.0 / float(dt))*math.acosh((asvc[t+dt] + asvc[t-dt])/(2.0*asvc[t])) if fast: emass[t] = guess else: emass[t] = newton.newton_cosh_for_m(t,t+dt,asvc, guess,T) except ValueError: #logging.debug("invalid argument to log, setting to zero") emass[t] = 0.0 except ZeroDivisionError: logging.debug("div by zero, setting to zero") emass[t] = 0.0 except KeyError: logging.error("index out of range") jkemass[cfg] = emass jkemassobj = configtimeobj.Cfgtimeobj.fromDataDict(jkemass) effmass_dt = self.cosh_effective_mass(dt, fast=fast, period=period) return {t: jackknife.errorbars(effmass_dt[t], jkemassobj.get(time=t)) for t in self.times[dt:-dt]}
def compute(self, plug, data): # Check if output value is connected if plug == self.aOutputVaue: # Get input datas operationTypeHandle = data.inputValue(self.aOperationType) operationType = operationTypeHandle.asInt() inputValueHandle = data.inputValue(self.aInputValue) inputValue = inputValueHandle.asFloat() # Math Cosinus outputValue = 0 if operationType == 0: outputValue = math.acos(inputValue) if operationType == 1: outputValue = math.cos(inputValue) if operationType == 2: outputValue = math.acosh(inputValue) if operationType == 3: outputValue = math.cosh(inputValue) # Output Value output_data = data.outputValue(self.aOutputVaue) output_data.setFloat(outputValue) # Clean plug data.setClean(plug)
def cosh_effective_mass(self, dt, fast=True, period=None): if fast: logging.info("cosh emass computed fast method") T = self.period_check(period) asv = self.average_sub_vev() emass = {} for t in self.times[dt:-dt]: if t in self.emass_skip_times: emass[t] = 0.0 continue try: guess = (1.0 / float(dt))*math.acosh((asv[t+dt] + asv[t-dt])/(2.0*asv[t])) if fast: emass[t] = guess else: emass[t] = newton.newton_cosh_for_m(t,t+dt,asv, guess, T) except ValueError: logging.debug("invalid argument to acosh, setting to zero") emass[t] = float('NaN') except KeyError: logging.error("index out of range") except ZeroDivisionError: logging.error("Div by zero either dt:{} or average value sub vev {}".format(dt,asv[t])) emass[t] = float('NaN') return emass
def pmuboost3d(jets, met, lep): mw = 80.385 wwwtlv = ROOT.TLorentzVector(1e-9,1e-9,1e-9,1e-9) mettlv = ROOT.TLorentzVector(1e-9,1e-9,1e-9,1e-9) leptlv = ROOT.TLorentzVector(1e-9,1e-9,1e-9,1e-9) for jet in jets: # if(e.jetPt[ij] > 30.): tlvaux = ROOT.TLorentzVector(1e-9,1e-9,1e-9,1e-9) tlvaux.SetPtEtaPhiM(jet['pt'],0.,jet['phi'],0.) wwwtlv -= tlvaux mettlv.SetPtEtaPhiM(met['pt'],0.,met['phi'],0.) leptlv.SetPtEtaPhiM(lep['pt'],lep['eta'],lep['phi'], 0.) # leptlv.SetPtEtaPhiM(e.muPt[0],e.muEta[0],e.muPhi[0],0.) # calculate eta(W) estimate; take the + solution ptl = (wwwtlv - mettlv).Pt() ptn = mettlv.Pt() ptw = wwwtlv.Pt() etal = leptlv.Eta() A = (mw*mw + ptw*ptw - ptl*ptl - ptn*ptn) / (2.*ptl*ptn) if(A<1.): A=1. etaw = asinh((ptl*sinh(etal)+ptn*sinh(etal+acosh(A)))/ptw) if(abs(etaw)>10.): etaw=10*etaw/abs(etaw) # avoid too large values wwwtlv.SetPtEtaPhiM(wwwtlv.Pt(),etaw,wwwtlv.Phi(),mw) # calulate boosted lepton momentum beta = wwwtlv.BoostVector() leptlv.Boost(-beta) return leptlv.P()
def test_arccosh(self): import math from _numpypy import arccosh for v in [1.0, 1.1, 2]: assert math.acosh(v) == arccosh(v) for v in [-1.0, 0, .99]: assert math.isnan(arccosh(v))
def chebyParam(n, r): n = float(n) r = float(r) iterator = math.cosh(1 / n * math.acosh(r)) a = ((iterator - 1) / 2).real b = ((iterator + 1) / 2).real # returns the list of chebyshev's parameters return [a, b]
def acosh(space, d): """ acosh - Inverse hyperbolic cosine """ try: return space.wrap(math.acosh(d)) except OverflowError: return space.wrap(rfloat.INFINITY) except ValueError: return space.wrap(rfloat.NAN)
def startingTime(self): angle = self.launchAngle F = math.acosh((self.e+math.cos(angle))/(1.0+self.e*math.cos(angle))) M = self.e*math.sinh(F)-F ht = pow(pow(self.apoapsis,3.0)/self.gm, .5) * M if angle>0: return -ht else: return ht
def testArithmeticFunctionsDeepcopy(self): data = {'x': 1} test = Exp('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.exp(data['x']), copied.value) test = Log('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.log(data['x']), copied.value) test = Sqrt('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.sqrt(data['x']), copied.value) data['x'] = -1. test = Pow('x', 2) test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(data['x']**2, copied.value) test = Abs('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(abs(data['x']), copied.value) test = Sign('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(-1., copied.value) data['x'] = 1. test = Acos('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.acos(data['x']), copied.value) test = Asin('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.asin(data['x']), copied.value) test = Acosh('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.acosh(data['x']), copied.value) test = Asinh('x') test.push(data) copied = copy.deepcopy(test) self.assertAlmostEqual(math.asinh(data['x']), copied.value)
def operator(self, tok): """ Return operator handler if tok is a valid operator. Otherwise return False. """ def stacksum(stack): """ Return sum of all elements on stack (++ operator). """ acc = 0 while stack: acc += stack.pop() return acc def stackproduct(stack): """ Return product of all elements on stack (** operator). """ acc = 1 while stack: acc *= stack.pop() return acc # Operator handlers. operators = { '++': stacksum, '**': stackproduct, '+': lambda stack: stack.pop(-2) + stack.pop(), '-': lambda stack: stack.pop(-2) - stack.pop(), '*': lambda stack: stack.pop(-2) * stack.pop(), '/': lambda stack: stack.pop(-2) / stack.pop(), '%': lambda stack: stack.pop(-2) % stack.pop(), '^': lambda stack: stack.pop(-2) ** stack.pop(), '!': lambda stack: math.factorial(stack.pop()), 'ln': lambda stack: math.log(stack.pop()), 'log': lambda stack: math.log(stack.pop(-2), stack.pop()), 'log2': lambda stack: math.log(stack.pop(), 2), 'log10': lambda stack: math.log(stack.pop(), 10), 'rand': lambda stack: random.random(), 'sqrt': lambda stack: math.sqrt(stack.pop()), 'exp': lambda stack: math.exp(stack.pop()), 'sin': lambda stack: math.sin(stack.pop()), 'cos': lambda stack: math.cos(stack.pop()), 'tan': lambda stack: math.tan(stack.pop()), 'sinh': lambda stack: math.sinh(stack.pop()), 'cosh': lambda stack: math.cosh(stack.pop()), 'tanh': lambda stack: math.tanh(stack.pop()), 'arcsin': lambda stack: math.asin(stack.pop()), 'arccos': lambda stack: math.acos(stack.pop()), 'arctan': lambda stack: math.atan(stack.pop()), 'arcsinh': lambda stack: math.asinh(stack.pop()), 'arccosh': lambda stack: math.acosh(stack.pop()), 'arctanh': lambda stack: math.atanh(stack.pop()), 'max': lambda stack: max(stack.pop(), stack.pop()), 'min': lambda stack: min(stack.pop(), stack.pop()), 'abs': lambda stack: abs(stack.pop()), 'ans': lambda stack: self.ans, } # Return operation handler if exists, otherwise return False. if tok in operators: return operators[tok] return False
def acosh(a=(DataTypes.Float, 0.0), Result=(DataTypes.Reference, (DataTypes.Bool, False))): ''' Return the inverse hyperbolic cosine of x ''' try: Result(True) return math.acosh(a) except: Result(False) return -1
def acosh(num): value = math.acosh(num.value) string = "\\text{arccosh} " + enclose(num.string) string_nums = "\\text{arccosh} " + enclose(rstr(num.value)) error = num.error / math.sqrt(num.value**2 - 1) error_vars = fraction("1", root(square(enclose(num.string)) + " - 1")) \ + PRODUCT + diff(num.string) error_nums = fraction("1", root(square(rstr(num.value)) + " - 1")) \ + PRODUCT + rstr(num.value) return Number(value, string, error, string_nums, error_vars, error_nums)
def native_disk_distance(r_1, theta_1, r_2, theta_2): if r_1 == r_2 and theta_1 == theta_2: return 0 d_phi = pi - abs(pi - abs(theta_1 - theta_2)) if d_phi == 0: return r_1 + r_2 elif d_phi == pi: return abs(r_2 - r_1) else: return acosh(cosh(r_1)*cosh(r_2) - sinh(r_1)*sinh(r_2)*cos(d_phi))
def ACOSH(value): """ Returns the inverse hyperbolic cosine of a number. >>> ACOSH(1) 0.0 >>> round(ACOSH(10), 7) 2.9932228 """ return _math.acosh(value)
def poincareDist(a, b): # print(a,b) try: sigma = norm(np.subtract(a, b))**2.0 / ((1 - np.dot(a, a)) * (1 - np.dot(b, b))) return math.acosh(1 + 2 * sigma) except ValueError as e: print(a) print(b) raise (e)
def acosh(column): i = 0 column = mt.convert_num_col(column) result = list() while i < len(column): if (column[i] >= 1): result.insert(i + 1, math.acosh(column[i])) else: result.insert(i + 1, "Error de dominio") i += 1 return result
def check_rapidity_allowed(S123,PperpSquared,y): """A function to check if the rapidity is in the allowed region of phase space.""" ##Using equation 49 of Initial-state showering based on colour dipoles connected to incoming parton lines. assert (type(S123) == float) assert (type(PperpSquared) == float) assert (type(y) == float) __yMagMax = math.acosh(math.sqrt(S123/PperpSquared)/2.0) if (abs(y) > __yMagMax): return False else: return True
def st_acosh(x): """Inverse hyperbolic cosine function. Parameters ---------- x : float, int, MissingValue instance, or None Returns ------- Inverse hyperbolic cosine when x is non-missing and x >= 1, MISSING (".") otherwise """ if isinstance(x, StataVarVals): return StataVarVals([ mv if _is_missing(v) or v < 1 else math.acosh(v) for v in x.values ]) if _is_missing(x) or x < 1: return mv return math.acosh(x)
def check_rapidity_allowed(S123, PperpSquared, y): """A function to check if the rapidity is in the allowed region of phase space.""" ##Using equation 49 of Initial-state showering based on colour dipoles connected to incoming parton lines. assert (type(S123) == float) assert (type(PperpSquared) == float) assert (type(y) == float) __yMagMax = math.acosh(math.sqrt(S123 / PperpSquared) / 2.0) if (abs(y) > __yMagMax): return False else: return True
def func_arcosh(x): """Return arcosh(x) where the answer is in radians""" # invalid cases if x < 1: raise CalcOperationError( "Inverse hyperbolic cosine is undefined for values less than 1", "arcosh", [x]) # use the function from the 'math' library return acosh(x)
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return math.acosh(exp) except ValueError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: Math domain error.')) except TypeError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not ' + str(type(exp)))) except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ACOSH() function argument error'))
def calcCubeExp(self, A, B, C): '''Решение кубического уравнения тригонометрической формулой Виета x^3+Ax^2+Bx+C=0 ''' def sgn(x): if x > 0: return 1 if x == 0: return 0 if x < 0: return -1 x1 = 'null' x2 = 'null' x3 = 'null' Q = (A * A - 3 * B) / 9 R = (2 * A * A * A - 9 * A * B + 27 * C) / 54 S = Q * Q * Q - R * R if S > 0: fi = 1 / 3 * math.acos(R / math.pow(Q, 3 / 2)) x1 = -2 * math.sqrt(Q) * math.cos(fi) - A / 3 if x1 < 0: x1 = 'null' x2 = -2 * math.sqrt(Q) * math.cos(fi + 2 / 3 * 3.14) - A / 3 if x2 < 0: x2 = 'null' x3 = -2 * math.sqrt(Q) * math.cos(fi - 2 / 3 * 3.14) - A / 3 if x3 < 0: x3 = 'null' if S < 0: if Q > 0: fi = 1 / 3 * math.acosh(abs(R) / math.pow(Q, 3 / 2)) x1 = -2 * sgn(R) * math.sqrt(Q) * math.cosh(fi) - A / 3 if x1 < 0: x1 = 'null' if Q < 0: sss = abs(R) / math.pow(abs(Q), 3 / 2) fi = 1 / 3 * math.asinh(sss) x1 = -2 * sgn(R) * math.sqrt(abs(Q)) * math.sinh(fi) - A / 3 if x1 < 0: x1 = 'null' if Q == 0: x1 = -math.pow(C - A * A * A / 27, 1 / 3) - A / 3 if x1 < 0: x1 = 'null' if S == 0: x1 = -2 * sgn(R) * math.sqrt(Q) - A / 3 if x1 < 0: x1 = 'null' x2 = sgn(R) * math.sqrt(Q) - A / 3 if x2 < 0: x2 = 'null' return x1, x2, x3
def acosh(input): """Coseno inverso hiperbólico Evalúa el coseno inverso hiperbólico a un número real enviado en input y arroja un resultado en radianes. Args: input(Number): valor real Returns: Number """ return math.acosh(input)
def kubik_uravn(a, b, c, d): div_a = a a = b / div_a b = c / div_a c = d / div_a # x^3 + a*x^2 + b*x + c q = (a**2 - 3 * b) / 9 r = (2 * a**3 - 9 * a * b + 27 * c) / 54 s = q**3 - r**2 if s > 0: fi = 1 / 3 * math.acos(r / (q**3)**(1 / 2)) x1 = -2 * q**(1 / 2) * math.cos(fi) - a / 3 x2 = -2 * q**(1 / 2) * math.cos(fi + 2 / 3 * math.pi) - a / 3 x3 = -2 * q**(1 / 2) * math.cos(fi - 2 / 3 * math.pi) - a / 3 print('S = %s, Q = %s, R = %s, sgn(R) = %s' % (s, q, r, sgn(r))) return x1, x2, x3 elif s < 0: if q > 0: fi = 1 / 3 * math.acosh(abs(r) / ((q**3)**(1 / 2))) x1 = -2 * sgn(r) * q**(1 / 2) * math.cosh(fi) - a / 3 x2 = complex( sgn(r) * q**(1 / 2) * math.cosh(fi) - a / 3, 3**(1 / 2) * q**(1 / 2) * math.sinh(fi)) x3 = complex( sgn(r) * q**(1 / 2) * math.cosh(fi) - a / 3, -3**(1 / 2) * q**(1 / 2) * math.sinh(fi)) print('S = %s, Q = %s, R = %s, sgn(R) = %s' % (s, q, r, sgn(r))) return x1, x2, x3 if q < 0: fi = math.asinh(abs(r) / (abs(q**3)**(1 / 2))) x1 = -2 * sgn(r) * abs(q)**(1 / 2) * math.sinh(fi) - a / 3 x2 = complex( sgn(r) * abs(q)**(1 / 2) * math.sinh(fi) - a / 3, 3**(1 / 2) * abs(q)**(1 / 2) * math.cosh(fi)) x3 = complex( sgn(r) * abs(q)**(1 / 2) * math.sinh(fi) - a / 3, -3**(1 / 2) * abs(q)**(1 / 2) * math.cosh(fi)) print('S = %s, Q = %s, R = %s, sgn(R) = %s' % (s, q, r, sgn(r))) return x1, x2, x3 if q == 0: x1 = -rootodd(c - a**3 / 27, 3) - a / 3 x2 = complex(-(a + x1) / 2, 1 / 2 * abs((a - 3 * x1) * (a + x1) - 4 * b)**(1 / 2)) x3 = complex( -(a + x1) / 2, -1 / 2 * abs((a - 3 * x1) * (a + x1) - 4 * b)**(1 / 2)) print('S = %s, Q = %s, R = %s, sgn(R) = %s' % (s, q, r, sgn(r))) return x1, x2, x3 elif s == 0: x1 = -2 * sgn(r) * q**(1 / 2) - a / 3 # -2*rootodd(r, 3) - a/3 x2 = sgn(r) * q**(1 / 2) - a / 3 # rootodd(r, 3) - a/3 print('S = %s, Q = %s, R = %s, sgn(R) = %s' % (s, q, r, sgn(r))) return x1, x2
def chebyParamOptimized(n, r, k0): n = float(n) r = float(r) iterator = math.cosh(1 / n * math.acosh(r)) a = ((iterator - 1) / 2).real b = ((iterator + 1) / 2).real optimized_dist = (2 * math.pi - math.acos((1 - a) / b)) / k0 output = open("valori_a_b.txt", "a") output.write(" a = " + str(a) + " b = " + str(b) + " N = " + str(n * 2 + 1) + "\n") output.close() print("N=" + str(n * 2 + 1) + " d=" + str(optimized_dist)) return [a, b, optimized_dist]
def chebyParamOptimized(n, r, k0): n = float(n) r = float(r) iterator = math.cosh(1 / n * math.acosh(r)) a = ((iterator - 1) / 2).real b = ((iterator + 1) / 2).real optimized_dist = (2 * math.pi - math.acos((1 - a) / b)) / k0 output = open("valori_a_b.txt", 'a') output.write(" a = " + str(a) + " b = " + str(b) + " N = " + str(n * 2 + 1) + "\n") output.close() print("N=" + str(n * 2 + 1) + " d=" + str(optimized_dist)) return [a, b, optimized_dist]
def acosh(self): ''' Method to perform element-wise inverse hyperbolic cosine in radians on the vector. @return: result vector as a list. ''' try: values = [math.acosh(x) for x in self.values] except: raise VectorError('Failure in Vector.acosh()') self.values = values return self.values
def chebyschev_lowpass(f_pass, f_stop, tol_pass, tol_stop): """ Returns the Chebyschev analog lowpass filter function corresponding to passband and stopband frequencies and tolerances. Inputs: - f_pass: The passband boundary frequency in Hz - f_stop: The stopband boundary frequency in Hz - tol_pass: The tolerance required in the passband - tol_stop: The tolerance required in the stopband. Returns a function that takes a frequency (in Hz) as input and returns the filter magnitude at that frequency as the output. """ if f_pass == f_stop: raise ValueError( 'The passband and stopband frequencies cannot be equal.') if tol_pass == 0 or tol_stop == 0: raise ValueError('Tolerance values cannot be zero.') D1 = 1 / (1 - tol_pass)**2 - 1 D2 = 1 / tol_stop**2 - 1 # Optimal epsilon to get minimum N possible # epsilon = math.sqrt(D1) # Minimum order of the filter that is required # (Note that D1 is the same as epsilon**2) N = math.acosh(D2 / D1) / math.acosh(f_stop / f_pass) N = math.ceil(N) def filter_func(f): # Note that D1 is the same as epsilon**2 mag2 = 1 / (1 + D1 * chebyshev_polynomial(f / f_pass, N)**2) return math.sqrt(mag2) return filter_func
def __init__(self, a: float, b: float, x_max: float, n: int): t_max = acosh(x_max / a) dt = t_max / (n - 1) cf = cosh(dt) sf = sinh(dt) a_b = float(a) / b sf_a_b = sf * a_b sf_b_a = sf / a_b super().__init__(1, 0, lambda x, y: x * cf + y * sf_a_b, lambda x, y: x * sf_b_a + y * cf, n, False)
def to_prolate_spheroidal(coords): focus = 0.3525E+02 x = coords[0] y = coords[1] z = coords[2] theta = math.atan(z / y) mu = math.acos(1 / (2 * focus) * ((y * y + z * z + (x + focus)**2)**0.5 - (y * y + z * z + (x - focus)**2)**0.5)) lam = math.acosh(1 / (2 * focus) * ((y * y + z * z + (x + focus)**2)**0.5 + (y * y + z * z + (x - focus)**2)**0.5)) return ([lam, mu, theta])
def hyperbola(a, b, begin, end, n): th_min = m.acosh(1.0 * begin / a) th_max = m.acosh(1.0 * end / a) delta_theta = (th_max - th_min) / (n - 1) start = [a * m.cosh(th_min), b * m.sinh(th_min)] points = [start] cosh = m.cosh(delta_theta) sinh = m.sinh(delta_theta) for i in range(1, n): xi, yi = points[i - 1] new_point = [ xi * cosh + yi * a / b * sinh, a / b * xi * sinh + yi * cosh ] points.append(new_point) points_rev = [[p[0], -p[1]] for p in reversed(points)] points = points_rev + points points_rev = [[-p[0], p[1]] for p in reversed(points)] return np.array(points + points_rev)
def acosh_click(self, event): try: self.txt_box1.SetForegroundColour('Default') self.txt_box1.SetValue( str(math.acosh(eval(self.txt_box.GetValue())))) except ZeroDivisionError: self.txt_box1.SetForegroundColour('red') self.txt_box1.SetValue(u'除数为0,请重新输入!') except SyntaxError: self.txt_box1.SetForegroundColour('red') self.txt_box1.SetValue(u'输入算式错误,请重新输入!') except ValueError: self.txt_box1.SetForegroundColour('red') self.txt_box1.SetValue(u'输入值错误,不能运算,请重新输入!')
def hyperbolicDistance(vector1, vector2): if (len(vector1) != num_dimensions): print("error vector1") if (len(vector2) != num_dimensions): print("error vector2") L2Distance = findL2Distance(vector1, vector2) vector1norm = findL2Norm(vector1) vector2norm = findL2Norm(vector2) inside = 1 + (2 * np.square(L2Distance)) / ((1 - np.square(vector1norm)) * (1 - np.square(vector2norm))) return math.acosh(inside)
def resolverFuncionTrigonometrica(self, nodo, resultado): if nodo.valor.lower() == 'acos': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.acos(a) resultado.append(c) elif nodo.valor.lower() == 'asin': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.asin(a) resultado.append(c) elif nodo.valor.lower() == 'atan': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.atan(a) resultado.append(c) elif nodo.valor.lower() == 'cos': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.cos(a) resultado.append(c) elif nodo.valor.lower() == 'sin': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.sin(a) resultado.append(c) elif nodo.valor.lower() == 'tan': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.tan(a) resultado.append(c) elif nodo.valor.lower() == 'sinh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.sinh(a) resultado.append(c) elif nodo.valor.lower() == 'cosh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.cosh(a) resultado.append(c) elif nodo.valor.lower() == 'tanh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.tanh(a) resultado.append(c) elif nodo.valor.lower() == 'asinh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.asinh(a) resultado.append(c) elif nodo.valor.lower() == 'acosh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) c = math.acosh(a) resultado.append(c) elif nodo.valor.lower() == 'atanh': a = self.expresion_aritmetica(nodo.hijos[0], [], [], []) print(a) c = math.atanh(a) resultado.append(c)
def calc_order(Apmax, Asmin, wp, ws): """ Parameters: Apmax - maximum passand loss Asmin - minimum stopband loss wp - passband frequency ws - stopband frequency ---- output: order of the required chebyshev filter """ n = 0 A = calc_epsilon(Asmin) / calc_epsilon(Apmax) omega = ws/wp if omega > 1: n = math.acosh(A)/math.acosh(omega) else: n = math.acos(A)/math.acos(omega) n = math.ceil(n) return n
def acosh(column): i = 0 column = mt.convert_num_col(column) result = list() while i < len(column): if isinstance(column[i], int) or isinstance(column[i], float): if column[i] >= 1: result.append(math.acosh(column[i])) else: result.append("Error de dominio") list_errors_tg.append("Error: 22003: la entrada esta fuera del dominio") else: result.append(column[i]) i += 1 return result
def compute_eff_energies(self, eff_en_type): for k in range(self.corrs.shape[0]): self.eff_energies.append( [] ) for j in range(self.corrs.shape[1]-1): #for j in range(self.corrs.shape[1]/2): if eff_en_type=="exp": self.eff_energies[len(self.eff_energies)-1].append( log( self.corrs[k,j]/self.corrs[k,j+1] ) ) elif eff_en_type=="3pt": self.eff_energies[len(self.eff_energies)-1].append( acosh( (self.corrs[k,j+1]+self.corrs[k,j-1]) / (2*self.corrs[k,j]) ) ) else: raise Exception("Effective energy type not available.") self.eff_energies = np.array(self.eff_energies)
def getHyperbolicDistance(sourceNode, destNode): """ Return hyperbolic or geohyperbolic distance between two nodes. The distance is computed on the basis of following algorithm/mathematics ref: https://en.wikipedia.org/wiki/Hyperbolic_geometry """ r1 = [key for key in sourceNode][0] r2 = [key for key in destNode][0] zeta = 1.0 dtheta = calculateAngularDistance(sourceNode[r1], destNode[r2]) hyperbolicDistance = (1. / zeta) * acosh(cosh(zeta * r1) * cosh(zeta * r2) - \ sinh(zeta * r1) * sinh(zeta * r2) * cos(dtheta)) debug("Distance from {} to {} is {}".format(sourceNode, destNode, hyperbolicDistance)) return hyperbolicDistance
def S_isothermal_pipe_eccentric_to_isothermal_pipe(D1, D2, Z, L=1.): r'''Returns the Shape factor `S` of a pipe of constant outer temperature and of outer diameter `D1` which is `Z` distance from the center of another pipe of outer diameter`D2`. Length `L` must be provided, but can be set to 1 to obtain a dimensionless shape factor used in some sources. .. math:: S = \frac{2\pi L}{\cosh^{-1} \left(\frac{D_2^2 + D_1^2 - 4Z^2}{2D_1D_2}\right)} Parameters ---------- D1 : float Diameter of inner pipe, [m] D2 : float Diameter of outer pipe, [m] Z : float Distance from the middle of inner pipe to the center of the other, [m] L : float, optional Length of the pipe, [m] Returns ------- S : float Shape factor [m] Examples -------- >>> S_isothermal_pipe_eccentric_to_isothermal_pipe(.1, .4, .05, 10) 47.709841915608976 Notes ----- L should be much larger than both diameters. D2 should be larger than D1. .. math:: Q = Sk(T_1 - T_2) \\ R_{\text{shape}}=\frac{1}{Sk} References ---------- .. [1] Kreith, Frank, Raj Manglik, and Mark Bohn. Principles of Heat Transfer. Cengage, 2010. .. [2] Bergman, Theodore L., Adrienne S. Lavine, Frank P. Incropera, and David P. DeWitt. Introduction to Heat Transfer. 6E. Hoboken, NJ: Wiley, 2011. ''' S = 2*pi*L/acosh((D2**2 + D1**2 - 4*Z**2)/(2*D1*D2)) return S
def computeTOF(self): mu = self.myUniverse.mu r = (self.periapseState[0]**2 + self.periapseState[1]**2 + self.periapseState[2]**2)**0.5 rSOI = self.myUniverse.r_SOI SMA = -mu / self.vMAG / self.vMAG ECC = 1 - r / SMA H = acosh(1.0 / ECC * (rSOI / -SMA + 1.0)) N = ECC * sinh(H) - H self.TOF = N / sqrt(mu / -(SMA * SMA * SMA)) self.DeltaTA = 2.0 * atan( ((ECC + 1.0) / (ECC - 1.0))**0.5 * tanh(0.5 * H)) DeltaTA2 = acos(1.0 / ECC * (SMA * (1 - ECC**2) / rSOI - 1.0))
def testAcoshFunction(self): ma5 = MovingAverage(5, 'close') holder = Acosh(ma5) sampleClose = np.cosh(self.sampleClose) for i, close in enumerate(sampleClose): data = {'close': close} ma5.push(data) holder.push(data) expected = math.acosh(ma5.result()) calculated = holder.result() self.assertAlmostEqual(calculated, expected, 12, "at index {0:d}\n" "expected: {1:f}\n" "calculated: {2:f}".format(i, expected, calculated))
def acosh(x): """ Return the inverse hyperbolic cosine of x. """ if isinstance(x,ADF): ad_funcs = list(map(to_auto_diff,[x])) x = ad_funcs[0].x ######################################## # Nominal value of the constructed ADF: f = acosh(x) ######################################## variables = ad_funcs[0]._get_variables(ad_funcs) if not variables or isinstance(f, bool): return f ######################################## # Calculation of the derivatives with respect to the arguments # of f (ad_funcs): lc_wrt_args = [1/sqrt(x**2 - 1)] qc_wrt_args = [-x/(x**2 - 1)**1.5] cp_wrt_args = 0.0 ######################################## # Calculation of the derivative of f with respect to all the # variables (Variable) involved. lc_wrt_vars,qc_wrt_vars,cp_wrt_vars = _apply_chain_rule( ad_funcs,variables,lc_wrt_args,qc_wrt_args, cp_wrt_args) # The function now returns an ADF object: return ADF(f, lc_wrt_vars, qc_wrt_vars, cp_wrt_vars) else: # try: # pythonic: fails gracefully when x is not an array-like object # return [acosh(xi) for xi in x] # except TypeError: if x.imag: return cmath.acosh(x) else: return math.acosh(x.real)
def acosh(*args): if args[0].__class__.__name__ == "vmath": self = args[0] else: self = vmath() arg = vmath.self_remove(args) if self.arg_type != None: arg[0] = self.arg_type(arg[0]) arg_name = arg[0].__class__.__name__ pn_class_much = [x for x in vmath.pn_class if x == arg_name] if len(pn_class_much) == 1: answer = arg[0].math.acosh(arg[0]) else: answer = math.acosh(arg[0]) if self.return_type != None: answer = self.return_type(answer) return answer
def S_isothermal_pipe_to_plane(D, Z, L=1): r'''Returns the Shape factor `S` of a pipe of constant outer temperature and of outer diameter `D` which is `Z` distance from an infinite plane. Length `L` must be provided, but can be set to 1 to obtain a dimensionless shape factor used in some sources. .. math:: S = \frac{2\pi L}{\cosh^{-1}(2z/D)} Parameters ---------- D : float Diameter of the pipe, [m] Z : float Distance from the middle of the pipe to the infinite plane, [m] L : float, optional Length of the pipe, [m] Returns ------- S : float Shape factor [m] Examples -------- >>> S_isothermal_pipe_to_plane(1, 100, 3) 3.146071454894645 Notes ----- L should be much larger than D. .. math:: Q = Sk(T_1 - T_2) \\ R_{\text{shape}}=\frac{1}{Sk} References ---------- .. [1] Kreith, Frank, Raj Manglik, and Mark Bohn. Principles of Heat Transfer. Cengage, 2010. .. [2] Bergman, Theodore L., Adrienne S. Lavine, Frank P. Incropera, and David P. DeWitt. Introduction to Heat Transfer. 6E. Hoboken, NJ: Wiley, 2011. ''' S = 2*pi*L/acosh(2*Z/D) return S
def add_fit_info(filename, ax=None): if not ax: ax = plt funmap = {"two_exp": two_exp, "single_exp": single_exp, "periodic_two_exp": periodic_two_exp, "fwd-back-exp": periodic_exp, "periodic_two_exp_const": periodic_two_exp_const, "fwd-back-exp_const": periodic_exp_const} try: fittype, function, tmin, tmax, fitparams, fiterrors, Nt = get_fit(filename) fun = funmap[function](Nt) massindex = fun.parameter_names.index("mass") mass = fitparams[massindex] masserror = fiterrors[massindex] if fittype == "#fit": logging.info("correlator fit info") xpoints = np.arange(tmin, tmax, 0.3) fitpoints = fun.formula(fitparams, xpoints) ax.plot(xpoints, fitpoints, ls="dashed", color="r", lw=2, zorder=5) if args.fitfunction: return fun.template.format(*fitparams) if fittype == "#fit_emass": xpoints = np.arange(tmin, tmax+1, 1.0) fitpoints = fun.formula(fitparams, xpoints) emassfit = [] dt = 3 for i in range(len(fitpoints))[:-dt]: try: #emass = (1.0 / float(dt)) * np.log(fitpoints[i] / fitpoints[i + dt]) emass = (1.0 / float(dt)) * math.acosh((fitpoints[i+dt] + fitpoints[i-dt])/(2.0*fitpoints[i])) emassfit.append(emass) except: emassfit.append(np.nan) if args.fit_errors: ax.plot(xpoints[:-dt], np.full_like(xpoints[:-dt],mass+masserror), ls="--", color="k", lw=2, zorder=50) ax.plot(xpoints[:-dt], np.full_like(xpoints[:-dt],mass-masserror), ls="--", color="k", lw=2, zorder=50) else: ax.plot(xpoints[:-dt], emassfit, ls="dashed", color="r", lw=2, zorder=5) if masserror == 0: return "{}".format(mass) digits = -1.0*round(math.log10(masserror)) formated_error = int(round(masserror * (10**(digits + 1)))) formated_mass = "{m:.{d}f}".format(d=int(digits) + 1, m=mass) #return "{m}({e})".format(m=formated_mass, e=formated_error) return print_paren_error(mass, masserror) except RuntimeError: logging.error("File {} had no fit into".format(filename))
def cosh_const_effective_mass(self, dt): asv = self.average_sub_vev() asvt = {t: asv[t+dt]-asv[t] for t in self.times[:-dt] } emass = {} for t in self.times[dt:-(dt+dt)]: if t in self.emass_skip_times: emass[t] = 0.0 continue try: emass[t] = (1.0 / float(dt))*math.acosh((asvt[t+dt] + asvt[t-dt])/(2.0*asvt[t])) except ValueError: logging.debug("invalid argument to acosh, setting to nan") emass[t] = float('NaN') except KeyError: logging.error("index out of range") except ZeroDivisionError: logging.error("Div by zero either dt:{} or average value sub vev {}".format(dt,asv[t])) emass[t] = 0.0 return emass
def taylor_win(n, sll): """ http://www.dsprelated.com/showcode/6.php from http://mathforum.org/kb/message.jspa?messageID=925929: A Taylor window is very similar to Chebychev weights. While Chebychev weights provide the tighest beamwidth for a given side-lobe level, taylor weights provide the least taper loss for a given sidelobe level. 'Antenna Theory: Analysis and Design' by Constantine Balanis, 2nd edition, 1997, pp. 358-368, or 'Modern Antenna Design' by Thomas Milligan, 1985, pp.141-148. """ def calculate_fm(m, sp2, a, nbar): n = np.arange(1, nbar) p = np.hstack([np.arange(1, m), np.arange(m + 1, nbar)]) num = np.prod((1 - (m**2 / sp2) / (a**2 + (n - 0.5)**2))) den = np.prod(1 - m**2 / p**2) return ((-1)**(m + 1) * num) / (2 * den) nbar = int(np.ceil(2.0 * (acosh(10**(-sll / 20.0)) / pi)**2 + 0.5)) n *= 2 a = np.arccosh(10**(-sll / 20)) / pi sp2 = nbar**2 / (a**2 + (nbar - 0.5)**2) w = np.ones(n) fm = np.zeros(nbar) summation = 0 k = np.arange(n) xi = (k - 0.5 * n + 0.5) / n for m in range(1, nbar): fm[m] = calculate_fm(m, sp2, a, nbar) summation += fm[m] * np.cos(2 * pi * m * xi) w += w * summation w /= w.max() w = w[n//2:] return w
def testACosh(self): vectorA = m.Vector([1, 2, 3, 4]) result = [math.acosh(x) for x in vectorA.values] self.assertEqual(vectorA.acosh(), result)
def nud(self): return math.acosh(self.expression())