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