def mp_binom(k, n, p): """ Binomial function, returning the probability of k successes in n trials given the trial success probability p, and supporting multiprecission output. Parameters ---------- k : int, ndarray Successes. n : int, ndarray Trials. p : float,ndarray Trial (experiment) success probability. Returns ------- val : float,ndarray Probability of k successes in n trials. Examples -------- >>> k = 10 >>> n = 10000 >>> p = 0.9 >>> mp_binom(k, n, p) 9.56548769092821e-9958 """ import mpmath as mp val = mp_comb(n, k) * mp.power(p, k) * mp.power(1 - p, n - k) return val
def mp_binom(k,n,p): """ Binomial function, returning the probability of k successes in n trials given the trial success probability p, and supporting multiprecission output. Parameters ---------- k : int, ndarray Successes. n : int, ndarray Trials. p : float,ndarray Trial (experiment) success probability. Returns ------- val : float,ndarray Probability of k successes in n trials. Examples -------- >>> k = 10 >>> n = 10000 >>> p = 0.9 >>> mp_binom(k, n, p) 9.56548769092821e-9958 """ import mpmath as mp val = mp_comb(n,k) * mp.power(p,k) * mp.power(1-p,n-k) return val
def sign_test_precision(preds_system_A, preds_system_B, ground_truth, q=0.5): ties = 0 plus = 0 minus = 0 for i, gt in enumerate(ground_truth): if preds_system_A[i] == preds_system_B[i]: ties += 1 continue else: if preds_system_A[i] == gt: plus += 1 continue else: minus += 1 continue all_samples = len(ground_truth) k = np.ceil(ties / 2) + min(plus, minus) N = 2 * np.ceil(ties / 2) + plus + minus print("The k is: ", k) print("The N is: ", N) res = 0 for idx in range(0, int(k)): res += (mpmath.binomial(N, idx) * mpmath.power(q, idx) * mpmath.power( (1 - q), (N - idx))) #res += (nCr(N, idx)*pow(q, idx)*pow((1-q), (N-idx))) return (2 * res)
def _calculate_constant(self): """ Calculates the normalization constant. :rtype: """ return power(nsum(lambda n: self._internal_function(n) * power(n, -self._alpha), [1, inf], method=self._summation_method), -1)
def sround(num, decimal_places): """ Rounds away from 0. works for ints, floats and mpmath.mpf. returns string. """ s = str(num) #get the digits after the decimal if s.find('.') == -1: after_d = '0' else: after_d = s.split('.')[1] #only worry about rounding if there's enough dps to make a difference if len(after_d) > decimal_places and after_d[decimal_places] >= '5': #we round away from 0 if num >= 0: #e.g num: 234.23356 ; dp: 3 -> 234.23456 num += mpmath.mpf(1.0) * mpmath.power(10, -decimal_places) else: num -= mpmath.mpf(1.0) * mpmath.power(10, -decimal_places) #there still might be trailing digits whcih we chop off #e.g num: 234.23456 -> 234.234 return schop(num, decimal_places)
def round5_fp_fast(n, h, q, p, t, f, mu, B, add_coeff=False, verbose=False): ## use this for full precision ### dif = mp_zeros(q) ### dif[0] = mp.mpf(1.0) ## use this for double precision dif = np.zeros(q) dif[0] = 1.0 # determine number of times to convolve the term differences in term s*e. #If prime cyclotomic, it is h, if ring swithing or scaler, just h/2. # Only h(2h) convolutions as we start with probability gen function # for difference between two random variables with q-p rounding noise # This can be done as we consider balanced secrets w = h if add_coeff: w = 2 * w # computation of convolution of w variables (we have the sum of w variables) for i in range(w): dif = spec_conv_comb_qp(dif, q, p) # convert to mpf if we were double dif = np.array([mp.mpf(dif[i]) for i in range(len(dif))]) # normalize, just in case dif /= dif.sum() # second convolution with the p to t noise. Single time to account for coefficient compression from p to t. dif = spec_conv_comb_pt(dif, q, p, t) # Decryption failure ranges for case when parameter B>1 up_fail = (q + (1 << B)) // (1 << (B + 1)) down_fail = (q * ((1 << (B + 1)) - 1) + (1 << B)) // (1 << (B + 1)) # Bit failure probability (bfp). Distribution goes from 0 to q-1, highly provable values are centered around 0, thus, we sum the central part. bfp = dif[up_fail:down_fail].sum() # Failure probability after error correction ffp = mp.mpf(0) for j in range(f + 1, mu + 1): ffp += (mp.binomial(mu, j) * mp.power(bfp, j) * mp.power(mp.mpf(1) - bfp, (mu - j))) return float(mp.log(ffp, 2))
def integrand(self, eta, l, p, n, kind="A"): if kind not in ("A", "B", "C", "D", "E"): raise NotImplementedError("Integrand types supported \ go only from A to E") if kind == "C": return (mpmath.sqrt(self.k ** 2 - eta ** 2) / eta \ * self.integrand(eta, l, p, n, kind="A")) if kind == "D": return (mpmath.sqrt(self.k ** 2 - eta ** 2) / eta \ * self.integrand(eta, l, p, n, kind="B")) pm = 1 exponent = n - 1 if kind == "B": pm = -1 elif kind == "E": pm = 0 exponent = n if p == 0: lgr_factor = 1 else: lgr_factor = (self.a(eta) ** 2 \ * mpmath.laguerre(p - 1, l, self.a(eta) ** 2)) kz = mpmath.sqrt(self.k**2 - eta**2) return ( mpmath.power(eta, np.abs(l) + 1) / mpmath.sqrt(kz) \ * mpmath.exp(-self.a(eta) ** 2 / 2) * (1 + pm * kz / self.k) \ * mpmath.power(eta / self.k, exponent) * lgr_factor)
def __init__(self, pos, f, H0, Q, R1, annot, box=False, sim=False): super(Lowpass, self).__init__(pos) self.annot = annot self.box = box self.sim = sim # Calculate component values R3 = R1 / H0 R2 = R1 / (1.0 + H0) w0 = 2.0 * f * mp.pi # The product C1*C2 C1C2 = 1 / (mp.power(w0, 2.0) * R1 * R2) # The ratio C1/C2 rC1C2 = mp.power(Q, 2.0) * mp.power( mp.sqrt(R2 / R1) * (1 + H0) + mp.sqrt(R1 / R2), 2.0) # C1, C2 C1 = mp.sqrt(C1C2 * rC1C2) C2 = C1C2 / C1 self.R1 = "%s" % sisuffix(R1) self.R2 = "%s" % sisuffix(R2) self.R3 = "%s" % sisuffix(R3) self.C1 = "%sF" % sisuffix(C1) self.C2 = "%sF" % sisuffix(C2) self.f = "%sHz" % sisuffix(f) if self.sim: self.OPAMP = "IDEAL" else: self.OPAMP = "LM358" # Just a dummy value self.Build()
def calculateWindChillOperator( measurement1, measurement2 ): ''' https://www.ibiblio.org/units/dictW.html ''' validUnitTypes = [ [ 'velocity', 'temperature' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'wind_chill\' requires velocity and temperature measurements' ) windSpeed = arguments[ 'velocity' ].convert( 'miles/hour' ).value temperature = arguments[ 'temperature' ].convert( 'degrees_F' ).value if windSpeed < 3: raise ValueError( '\'wind_chill\' is not defined for wind speeds less than 3 mph' ) if temperature > 50: raise ValueError( '\'wind_chill\' is not defined for temperatures over 50 degrees fahrenheit' ) result = fsum( [ 35.74, fmul( temperature, 0.6215 ), fneg( fmul( 35.75, power( windSpeed, 0.16 ) ) ), fprod( [ 0.4275, temperature, power( windSpeed, 0.16 ) ] ) ] ) # in case someone puts in a silly velocity if result < -459.67: result = -459.67 return RPNMeasurement( result, 'degrees_F' ).convert( arguments[ 'temperature' ].units )
def test5(): # Measure probability of at least 1 instance of T consecutive successes over P trials n = 100 c = 80 b = 20 _range = list(range(int(c/2), c, 1)) # _range = list(range(500, 1000, 1)) for T in [110]: for trials in [10**15]: results = [] # with Pool(8) as pool: # results = pool.map(prob_atleast_k_identical_cons_n_trials_p_probability, [(trials, T, i) for i in _range]) for i in _range: print(i) h = hyper(n, i+b, 40, 32) h = mp.power(h, T) results.append(mp.mp.mpf(1) - mp.power(mp.mp.mpf(1)-h, trials-T+1)) for index, r in enumerate(results): if r >= 0.9: print(_range[index], r) plt.semilogy(_range, results, label=(trials, T)) plt.plot(_range, [1/(10**math.log(2**(32), 10))]*len(_range)) plt.plot(_range, [0.5]*len(_range)) # plt.ylim((10**-100,1)) plt.legend() plt.show()
def binom(trials, successes, p): total = mp.mp.mpf(0) p_ = mp.mp.mpf(p) for i in range(successes, trials + 1): total += (binomial(trials, i) * mp.power(p_, i) * mp.power(1 - p_, trials - i)) return total
def hitungParabolaDrag(time, timeStep, gravitasi, nilaiVO, nilaiD, sudut, massa): listSumbuY = [] listSumbuX = [] nilaiVx = nilaiVO * numpy.cos(numpy.deg2rad(sudut)) nilaiVy = nilaiVO * numpy.sin(numpy.deg2rad(sudut)) posisiSumbuY = nilaiVy * timeStep posisiSumbuX = nilaiVx * timeStep listSumbuX.append(posisiSumbuX) listSumbuY.append(posisiSumbuY) nilaiV = mpmath.sqrt(mpmath.power(nilaiVx, 2) + mpmath.power(nilaiVy, 2)) nilaiAx = -(nilaiD / massa) * nilaiV * nilaiVx nilaiAy = gravitasi - (nilaiD / massa) * nilaiV * nilaiVy for i in numpy.arange(0, time, timeStep): nilaiAx = -(nilaiD / massa) * nilaiV * nilaiVx nilaiAy = gravitasi - (nilaiD / massa) * nilaiV * nilaiVy nilaiVx += nilaiAx * timeStep nilaiVy += nilaiAy * timeStep nilaiV = mpmath.sqrt( mpmath.power(nilaiVx, 2) + mpmath.power(nilaiVy, 2)) posisiSumbuY += nilaiVy * timeStep posisiSumbuX += nilaiVx * timeStep if (posisiSumbuY < 0): break listSumbuX.append(posisiSumbuX) listSumbuY.append(posisiSumbuY) tampilGraph(listSumbuX, listSumbuY)
def B_01(Non, Noff, alpha): Ntot = Non + Noff gam = (1 + 2 * Noff) * power(alpha, (0.5 + Ntot)) * gamma(0.5 + Ntot) delta = ((2 * power((1 + alpha), Ntot)) * gamma(1 + Ntot) * hyp2f1(0.5 + Noff, 1 + Ntot, 1.5 + Noff, (-1 / alpha))) c1_c2 = sqrt(pi) / (2 * atan(1 / sqrt(alpha))) return gam / (c1_c2 * delta)
def calculateWindChill( measurement1, measurement2 ): validUnitTypes = [ [ 'velocity', 'temperature' ], ] arguments = matchUnitTypes( [ measurement1, measurement2 ], validUnitTypes ) if not arguments: raise ValueError( '\'wind_chill\' requires velocity and temperature measurements' ) wind_speed = arguments[ 'velocity' ].convert( 'miles/hour' ).value temperature = arguments[ 'temperature' ].convert( 'degrees_F' ).value if wind_speed < 3: raise ValueError( '\'wind_chill\' is not defined for wind speeds less than 3 mph' ) if temperature > 50: raise ValueError( '\'wind_chill\' is not defined for temperatures over 50 degrees fahrenheit' ) result = fsum( [ 35.74, fmul( temperature, 0.6215 ), fneg( fmul( 35.75, power( wind_speed, 0.16 ) ) ), fprod( [ 0.4275, temperature, power( wind_speed, 0.16 ) ] ) ] ) # in case someone puts in a silly velocity if result < -459.67: result = -459.67 return RPNMeasurement( result, 'degrees_F' ).convert( arguments[ 'temperature' ].units )
def getEclipseTotality( body1, body2, location, date ): '''Returns the angular size of an astronomical object in radians.''' if isinstance( location, str ): location = getLocation( location ) if not isinstance( body1, RPNAstronomicalObject ) or not isinstance( body2, RPNAstronomicalObject ) and \ not isinstance( location, RPNLocation ) or not isinstance( date, RPNDateTime ): raise ValueError( 'expected two astronomical objects, a location and a date-time' ) separation = body1.getAngularSeparation( body2, location, date ).value radius1 = body1.getAngularSize( ).value radius2 = body2.getAngularSize( ).value if separation > fadd( radius1, radius2 ): return 0 distance1 = body1.getDistanceFromEarth( date ) distance2 = body2.getDistanceFromEarth( date ) area1 = fmul( pi, power( radius1, 2 ) ) area2 = fmul( pi, power( radius2, 2 ) ) area_of_intersection = fadd( getCircleIntersectionTerm( radius1, radius2, separation ), getCircleIntersectionTerm( radius2, radius1, separation ) ) if distance1 > distance2: result = fdiv( area_of_intersection, area1 ) else: result = fdiv( area_of_intersection, area2 ) if result > 1: return 1 else: return result
def getNSphereRadius( n, k ): if real_int( k ) < 3: raise ValueError( 'the number of dimensions must be at least 3' ) if not isinstance( n, RPNMeasurement ): return RPNMeasurement( n, 'meter' ) dimensions = n.getDimensions( ) if dimensions == { 'length' : 1 }: return n elif dimensions == { 'length' : int( k - 1 ) }: m2 = n.convertValue( RPNMeasurement( 1, [ { 'meter' : int( k - 1 ) } ] ) ) result = root( fdiv( fmul( m2, gamma( fdiv( k, 2 ) ) ), fmul( 2, power( pi, fdiv( k, 2 ) ) ) ), fsub( k, 1 ) ) return RPNMeasurement( result, [ { 'meter' : 1 } ] ) elif dimensions == { 'length' : int( k ) }: m3 = n.convertValue( RPNMeasurement( 1, [ { 'meter' : int( k ) } ] ) ) result = root( fmul( fdiv( gamma( fadd( fdiv( k, 2 ), 1 ) ), power( pi, fdiv( k, 2 ) ) ), m3 ), k ) return RPNMeasurement( result, [ { 'meter' : 1 } ] ) else: raise ValueError( 'incompatible measurement type for computing the radius: ' + str( dimensions ) )
def Ptrue(Qp, I, R, S, Q, b, replacement=True): """ Returns the probability of testing with replacement, in which tested individuals can be retested on the same day. Args ---- Qp (int): number of positive tests. I (int): number of infecteds. R (int): number of recovered. S (int): number of suceptibles. Q (int): number of tests. b (float): biased-testing factor. replacement (boolean): testing with/without replacement. """ if replacement: f0 = (I + R) / (S + I + R) Ptrue = binomial(Q, Qp) * power(f0 * exp(b), Qp) * power( 1 - f0, Q - Qp) Ptrue /= power(1 + (exp(b) - 1) * f0, Q) else: product = [(I + R - k) / (S - Q + Qp - k) for k in range(Qp)] Ptrue = binomial(Q, Qp) * fprod(product) * exp(Qp*b) * \ 1/hyp2f1( -I - R, -Q, S - Q + 1, exp(b) ) return Ptrue
def cdf(self, x, shape, loc, scale, dx='1e-10', precision=100): """ Calculates cdf. Parameters ---------- x : float or array_like shape : float loc : float scale : float dx : str, optional precision : int, optional """ with mpmath.workdps(precision): # Make sure passed values are valid x = self.check_support(x, shape, loc, scale, dx, precision) z = self.__z(x, shape, loc, scale, dx, precision) part_2 = -(mpmath.mpf('1') / mpmath.mpf(shape)) if np.isscalar(x): part_1 = mpmath.mpf('1') + mpmath.mpf(shape) * z return mpmath.mpf('1') - mpmath.power(part_1, part_2) else: parts_1 = [ mpmath.mpf('1') + mpmath.mpf(shape) * _z for _z in z ] return np.array([ mpmath.mpf('1') - mpmath.power(part_1, part_2) for part_1 in parts_1 ])
def getNthOctagonalTriangularNumber( n ): sign = power( -1, real( n ) ) return nint( floor( fdiv( fmul( fsub( 7, fprod( [ 2, sqrt( 6 ), sign ] ) ), power( fadd( sqrt( 3 ), sqrt( 2 ) ), fsub( fmul( 4, real_int( n ) ), 2 ) ) ), 96 ) ) )
def compute_single_item_loss_list(u, node_capacity, n_seats, p0): u_to_the_n = math.power(u, node_capacity) C_fact = math.factorial(n_seats) C_to_the_n_minus_c = math.power(n_seats, (node_capacity - n_seats)) denominator = math.fmul(C_fact, C_to_the_n_minus_c) fraction = math.fdiv(u_to_the_n, denominator) return math.fmul(fraction, p0)
def getKSphereRadius(n, k): if k < 3: raise ValueError('the number of dimensions must be at least 3') if not isinstance(n, RPNMeasurement): return RPNMeasurement(n, 'meter') dimensions = n.getDimensions() if dimensions == {'length': 1}: return n if dimensions == {'length': int(k - 1)}: area = n.convertValue(RPNMeasurement(1, [{'meter': int(k - 1)}])) result = root( fdiv(fmul(area, gamma(fdiv(k, 2))), fmul(2, power(pi, fdiv(k, 2)))), fsub(k, 1)) return RPNMeasurement(result, [{'meter': 1}]) if dimensions == {'length': int(k)}: volume = n.convertValue(RPNMeasurement(1, [{'meter': int(k)}])) result = root( fmul(fdiv(gamma(fadd(fdiv(k, 2), 1)), power(pi, fdiv(k, 2))), volume), k) return RPNMeasurement(result, [{'meter': 1}]) raise ValueError( 'incompatible measurement type for computing the radius: ' + str(dimensions))
def cheb_D(n: int) -> List[mp.mpf]: pts = cheb_pts(n) Dmat = [[0 for i in range(n)] for j in range(n)] N = n - 1 Dmat[0][0] = mp.fdiv(mp.mpf(2) * mp.power(N, 2) + mp.mpf(1), mp.mpf(6)) Dmat[N][N] = -mp.fdiv(mp.mpf(2) * mp.power(N, 2) + mp.mpf(1), mp.mpf(6)) Dmat[0][N] = mp.mpf(0.5) * mp.power(-1, N) Dmat[N][0] = -mp.mpf(0.5) * mp.power(-1, N) for i in range(1, N): Dmat[0][i] = mp.mpf(2.0) * mp.power(-1, i) * mp.fdiv( 1, mp.mpf(1) - pts[i]) Dmat[N][i] = -mp.mpf(2.0) * mp.power(-1, i + N) * mp.fdiv( 1, mp.mpf(1) + pts[i]) Dmat[i][0] = -mp.mpf(0.5) * mp.power(-1, i) * mp.fdiv( 1, mp.mpf(1) - pts[i]) Dmat[i][N] = mp.mpf(0.5) * mp.power(-1, i + N) * mp.fdiv( 1, mp.mpf(1) + pts[i]) Dmat[i][i] = -0.5 * pts[i] * mp.fdiv(1, mp.mpf(1) - mp.power(pts[i], 2)) for j in range(1, N): if i != j: Dmat[i][j] = mp.power(-1, i + j) * mp.fdiv(1, pts[i] - pts[j]) return Dmat
def getNthDecagonalCenteredSquareNumberOperator(n): sqrt10 = sqrt(10) dps = 7 * int(n) if mp.dps < dps: mp.dps = dps return nint( floor( fsum([ fdiv(1, 8), fmul(fdiv(7, 16), power(fsub(721, fmul(228, sqrt10)), fsub(n, 1))), fmul( fmul(fdiv(1, 8), power(fsub(721, fmul(228, sqrt10)), fsub(n, 1))), sqrt10), fmul( fmul(fdiv(1, 8), power(fadd(721, fmul(228, sqrt10)), fsub(n, 1))), sqrt10), fmul(fdiv(7, 16), power(fadd(721, fmul(228, sqrt10)), fsub(n, 1))) ])))
def regularHoeffding(n, D, N): alpha = mp.mp.mpf(0.8) n = mp.mp.mpf(n) D = mp.mp.mpf(D) N = mp.mp.mpf(N) p = D/N t = alpha - p return mp.power(mp.power(mp.e, -2*mp.power(t, 2)*n), 1550)
def getEulerPhi( n ): if real( n ) < 2: return n if g.ecm: return reduce( fmul, ( fmul( fsub( i[ 0 ], 1 ), power( i[ 0 ], fsub( i[ 1 ], 1 ) ) ) for i in getECMFactors( n ) ) ) else: return reduce( fmul, ( fmul( fsub( i[ 0 ], 1 ), power( i[ 0 ], fsub( i[ 1 ], 1 ) ) ) for i in getFactors( n ) ) )
def getNthDecagonalTriangularNumberOperator(n): return nint( floor( fdiv( fmul(fadd(9, fprod([4, sqrt(2), power(-1, fadd(n, 1))])), power(fadd(1, sqrt(2)), fsub(fmul(4, fadd(n, 1)), 6))), 64)))
def distance(self, another): """ This method computes the Euclidean distance with another opinion and returns it """ return mpmath.sqrt(mpmath.power(self.getBelief() - another.getBelief(), mpmath.mpf("2")) + \ mpmath.power(self.getDisbelief() - another.getDisbelief(), mpmath.mpf("2")) + \ mpmath.power(self.getUncertainty() - another.getUncertainty(), mpmath.mpf("2"))\ )
def getNthOctagonalTriangularNumberOperator(n): sign = power(-1, n) return nint( floor( fdiv( fmul(fsub(7, fprod([2, sqrt(6), sign])), power(fadd(sqrt(3), sqrt(2)), fsub(fmul(4, n), 2))), 96)))
def getNthAperyNumber( n ): result = 0 for k in arange( 0, real( n ) + 1 ): result = fadd( result, fmul( power( binomial( n, k ), 2 ), power( binomial( fadd( n, k ), k ), 2 ) ) ) return result
def __call__(self, y): """ This function should be used by the root finder. If the brentq root finder is used then the derivative does not help. """ r = self.r2 / self.r1 lhs = self.a1 - self.b1 * mp.root(y, 2) rhs = self.a2 * mp.power(y, r - 1) + self.b2 * mp.power(y, 1.5 * r - 1) return rhs - lhs
def get_prob_correct_async(k, pc, rprime): """prob = \sum_{l=0}^{k-rprime} (k_choose_l) * (pc)^l * (1 - pc)^(k-l) """ retval = 0 lmax = k - rprime for l in range(0, lmax + 1): retval += mpmath.binomial(k,l) * mpmath.power(pc, l) * \ mpmath.power(1 - pc, k - l) return retval
def get_prob_correct_sync(k, pc): """prob = \sum_{l=0}^{ceil(k/2)-1} (k_choose_l) * (pc)^l * (1 - pc)^(k-l) """ retval = 0 lmax = mpmath.ceil(float(k)/2) - 1 for l in range(0, lmax + 1): retval += mpmath.binomial(k,l) * mpmath.power(pc, l) * \ mpmath.power(1 - pc, k - l) return retval
def convertToPrimitiveUnits(self): debugPrint() debugPrint('convertToPrimitiveUnits:', self.value, self.units) if not g.unitConversionMatrix: loadUnitConversionMatrix() value = self.value units = RPNUnits() debugPrint('value', value) for unit in self.units: if self.units[unit] == 0: continue newUnits = g.basicUnitTypes[getUnitType(unit)].primitiveUnit debugPrint('unit', unit, 'newUnits', newUnits) if unit != newUnits: debugPrint('unit vs newUnits:', unit, newUnits) if (unit, newUnits) in g.unitConversionMatrix: value = fmul( value, power(mpf(g.unitConversionMatrix[(unit, newUnits)]), self.units[unit])) elif (unit, newUnits) in specialUnitConversionMatrix: value = power( specialUnitConversionMatrix[(unit, newUnits)](value), self.units[unit]) else: if unit == '1' and newUnits == '_null_unit': reduced = RPNMeasurement(value, units) debugPrint('convertToPrimitiveUnits 2:', reduced.value, reduced.units) return reduced raise ValueError('cannot find a conversion for ' + unit + ' and ' + newUnits) newUnits = RPNUnits(newUnits) for newUnit in newUnits: newUnits[newUnit] *= self.units[unit] units.update(newUnits) debugPrint('value', value) baseUnits = RPNMeasurement(value, units) debugPrint('convertToPrimitiveUnits 3:', baseUnits.value, baseUnits.units) debugPrint() return baseUnits
def getNthNonagonalPentagonalNumber( n ): sqrt21 = sqrt( 21 ) sign = power( -1, real_int( n ) ) return nint( floor( fdiv( fprod( [ fadd( 25, fmul( 4, sqrt21 ) ), fsub( 5, fmul( sqrt21, sign ) ), power( fadd( fmul( 2, sqrt( 7 ) ), fmul( 3, sqrt( 3 ) ) ), fsub( fmul( 4, n ), 4 ) ) ] ), 336 ) ) )
def hoeffding(n, D, N, lamb): n = mp.mp.mpf(n) D = mp.mp.mpf(D) N = mp.mp.mpf(N) lamb = mp.mp.mpf(lamb) p = D/N t = (lamb/(n*mp.sqrt(n))) + (p/n) - p print(lamb, t) return mp.power(mp.e, -2*mp.power(t, 2)*n)
def getNthDecagonalHeptagonalNumber( n ): sqrt10 = sqrt( 10 ) return nint( floor( fdiv( fprod( [ fsub( 11, fmul( fmul( 2, sqrt10 ), power( -1, real_int( n ) ) ) ), fadd( 1, sqrt10 ), power( fadd( 3, sqrt10 ), fsub( fmul( 4, n ), 3 ) ) ] ), 320 ) ) )
def __call__(self, y): """ This function should be used by the root finder. If the brentq root finder is used then the derivative does not help. """ r = self.r2 / self.r1 lhs = self.a1 - self.b1 * mp.root(y, 2) rhs = self.a2 * mp.power(y, r - 1) + self.b2 * mp.power(y, 1.5*r - 1) return rhs - lhs
def round5_fp_fast(d, n, h, q, p, t, f, mu, B, add_coeff=False, verbose=False): # dif = mp_zeros(q) # full precision # dif[0] = mp.mpf(1.0) dif = np.zeros(q) # double precision approximation dif[0] = 1.0 scale = 0 for w in h: # w = weight of +-scale scale += 1 if add_coeff: w = 2 * w # closer to 2 * w - 1 if h ~= w/2 w *= 2 # double it here; can use floats if verbose: print "\nw" + str(scale), "=", w for i in range(w): dif = conv_comb_qp(dif, q, p, scale) if verbose: sys.stdout.write('.') sys.stdout.flush() if verbose: print "done" # convert to mpf if we were double dif = np.array([mp.mpf(dif[i]) for i in range(len(dif))]) dif /= dif.sum() # normalize, just in case if verbose: print "eqp*R + eqp'*S".ljust(16) + str_stats(dif) dif = conv_comb_pt(dif, q, p, t) if verbose: print "rounded p->t".ljust(16) + str_stats(dif) # Decryption failure ranges for case when parameter B>1 up_fail = (q + (1 << B)) // (1 << (B + 1)) down_fail = (q * ((1 << (B + 1)) - 1) + (1 << B)) // (1 << (B + 1)) bfp = dif[up_fail:down_fail].sum() if verbose: print "per bit failure probability:", str_log2(bfp) print bfp ffp = mp.mpf(0) for j in range(f + 1, mu + 1): ffp += (mp.binomial(mu, j) * mp.power(bfp, j) * mp.power(mp.mpf(1) - bfp, (mu - j))) if verbose: print "more than", f, "errors in", mu, "bits:", str_log2(ffp) print ffp return float(mp.log(ffp, 2))
def get_rudder_force( self, rudder_angle, velocity): # hydrodynamic force in the fixed body frame self.rudder_force.x = self.RUDDER_LIFT_COEF * (mpmath.power( velocity.x, 2)) * math.sin(rudder_angle) self.rudder_force.y = self.RUDDER_LIFT_COEF * (mpmath.power( velocity.y, 2)) * math.cos(rudder_angle) return self.rudder_force
def getNthNonagonalTriangularNumber( n ): a = fmul( 3, sqrt( 7 ) ) b = fadd( 8, a ) c = fsub( 8, a ) return nint( fsum( [ fdiv( 5, 14 ), fmul( fdiv( 9, 28 ), fadd( power( b, real_int( n ) ), power( c, n ) ) ), fprod( [ fdiv( 3, 28 ), sqrt( 7 ), fsub( power( b, n ), power( c, n ) ) ] ) ] ) )
def pmf(k, n, p): """ Probability mass function of the binomial distribution. """ _validate_np(n, p) with mpmath.extradps(5): p = mpmath.mpf(p) return (mpmath.binomial(n, k) * mpmath.power(p, k) * mpmath.power(1 - p, n - k))
def fibSum(n): if n == 0 or n == 1: return 0 elif n == 2: return 1 else: n = n+1 a = math.sqrt(5) ; b =1+a ; c = 1-a e = (mp.power(b,n)-mp.power(c,n))/(mp.power(2,n)*a) return e-1
def getNthSquareTriangularNumber( n ): neededPrecision = int( real_int( n ) * 3.5 ) # determined by experimentation if mp.dps < neededPrecision: setAccuracy( neededPrecision ) sqrt2 = sqrt( 2 ) return nint( power( fdiv( fsub( power( fadd( 1, sqrt2 ), fmul( 2, n ) ), power( fsub( 1, sqrt2 ), fmul( 2, n ) ) ), fmul( 4, sqrt2 ) ), 2 ) )
def pdf_eval(self, x): if x < 0: return 0 elif x < self.location: return 0 else: x = mpf(x) a = self.shape/self.scale b = (x-self.location)/self.scale b = mpmath.power(b, self.shape-1) c = mpmath.exp(-mpmath.power(((x-self.location)/self.scale), self.shape)) return a * b *c
def getNthDecagonalCenteredSquareNumber( n ): sqrt10 = sqrt( 10 ) dps = 7 * int( real_int( n ) ) if mp.dps < dps: mp.dps = dps return nint( floor( fsum( [ fdiv( 1, 8 ), fmul( fdiv( 7, 16 ), power( fsub( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ), fmul( fmul( fdiv( 1, 8 ), power( fsub( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ), sqrt10 ), fmul( fmul( fdiv( 1, 8 ), power( fadd( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ), sqrt10 ), fmul( fdiv( 7, 16 ), power( fadd( 721, fmul( 228, sqrt10 ) ), fsub( n, 1 ) ) ) ] ) ) )
def getNthAperyNumber( n ): ''' http://oeis.org/A005259 a(n) = sum(k=0..n, C(n,k)^2 * C(n+k,k)^2 ) ''' result = 0 for k in arange( 0, real( n ) + 1 ): result = fadd( result, fmul( power( binomial( n, k ), 2 ), power( binomial( fadd( n, k ), k ), 2 ) ) ) return result
def getNthNonagonalSquareNumber( n ): if real( n ) < 0: ValueError( '' ) p = fsum( [ fmul( 8, sqrt( 7 ) ), fmul( 9, sqrt( 14 ) ), fmul( -7, sqrt( 2 ) ), -28 ] ) q = fsum( [ fmul( 7, sqrt( 2 ) ), fmul( 9, sqrt( 14 ) ), fmul( -8, sqrt( 7 ) ), -28 ] ) sign = power( -1, real_int( n ) ) index = fdiv( fsub( fmul( fadd( p, fmul( q, sign ) ), power( fadd( fmul( 2, sqrt( 2 ) ), sqrt( 7 ) ), n ) ), fmul( fsub( p, fmul( q, sign ) ), power( fsub( fmul( 2, sqrt( 2 ) ), sqrt( 7 ) ), fsub( n, 1 ) ) ) ), 112 ) return nint( power( nint( index ), 2 ) )
def interval_bisection(equation, lower, upper) -> str: """ Calculate the root of the equation using `Interval Bisection` method. Examples: >>> interval_bisection([1, 0, -3, -4], 2, 3)[0] '2.19582335' >>> interval_bisection([1, 0, 1, -6], 1, 2)[0] '1.63436529' >>> interval_bisection([1, 0, 3, -12], 1, 2)[0] '1.85888907' """ # Counts the number of iteration counter = 0 equation = mpfiy(equation) lower, upper = mpf(lower), mpf(upper) index_length = len(equation) x = mean(lower, upper) previous_alpha = alpha = None delta = fsub(upper, lower) while delta > power(10, -10) or previous_alpha is None: ans = mpf(0) # Summing the answer for i in range(index_length): index_power = index_length - i - 1 ans = fadd(ans, fmul(equation[i], power(x, index_power))) if ans > mpf(0): upper = x else: lower = x x = mean(lower, upper) previous_alpha, alpha = alpha, x if previous_alpha is None: continue elif previous_alpha == alpha: break delta = abs(fsub(alpha, previous_alpha)) counter += 1 return str(near(alpha, lower, upper)), counter
def get_prob_schedulable(msgs, mi, boot_time, sync = True): """Returns the probability that message m is successfully transmitted even in the presence of omission, commission, transmission faults. Here, although m represents a single message, we compute the probability of successful transmission collectively for all replicas of m, identified by a common 'tid' field. """ r = msgs.get_replication_factor(mi) rprime = int(mpmath.floor(r / 2.0) + 1) prob_msg_corrupted = 1 - br.get_prob_poisson(0, mi.deadline, msgs.po) prob_msg_omitted = 1 - br.get_prob_poisson(0, boot_time, msgs.po) # since pr(correct) is just a function of k <= r and pc, # we compute it beforehand for all values (pc is commission fault prob.) prob_correct = [] for k in range(0, r + 1): if sync: prob_correct.append(get_prob_correct_sync(k, prob_msg_corrupted)) else: prob_correct.append(get_prob_correct_async(k, prob_msg_corrupted, rprime)) # need to iterate over all subsets of replica set of m replica_ids = [] for mk in msgs: if mk.tid == mi.tid: replica_ids.append(mk.id) assert r == len(replica_ids) prob_success = 0 for omitted_ids in powerset(replica_ids): for mk in msgs: if mk.id in omitted_ids: mk.omitted = True else: mk.omitted = False s = r - len(omitted_ids) prob_omitted = mpmath.power(prob_msg_omitted, r - s) * \ mpmath.power(1 - prob_msg_omitted, s) prob_time_correct = 0 for k in range(1, s + 1): prob_time_correct += get_prob_time_periodic(msgs, mi, k) * \ prob_correct[k] prob_success += prob_omitted * prob_time_correct return min(prob_success, 1)
def multiplyDigits( n, exponent = 1, dropZeroes = False ): if exponent < 1: raise ValueError( 'multiplyDigits( ) expects a positive integer for \'exponent\'' ) elif exponent == 1: return fprod( getDigits( n, dropZeroes ) ) else: return fprod( [ power( i, exponent ) for i in getDigits( n, dropZeroes ) ] )
def getSigma( target ): ''' Returns the sum of the divisors of n, including 1 and n. http://math.stackexchange.com/questions/22721/is-there-a-formula-to-calculate-the-sum-of-all-proper-divisors-of-a-number ''' n = floor( target ) if real( n ) == 0: return 0 elif n == 1: return 1 factors = getECMFactors( n ) if g.ecm else getFactors( n ) result = 1 for factor in factors: numerator = fsub( power( factor[ 0 ], fadd( factor[ 1 ], 1 ) ), 1 ) denominator = fsub( factor[ 0 ], 1 ) #debugPrint( 'sigma', numerator, denominator ) result = fmul( result, fdiv( numerator, denominator ) ) if result != floor( result ): raise ValueError( 'insufficient precision for \'sigma\', increase precision (-p))' ) return result
def getNthPadovanNumber( arg ): n = fadd( real( arg ), 4 ) a = root( fsub( fdiv( 27, 2 ), fdiv( fmul( 3, sqrt( 69 ) ), 2 ) ), 3 ) b = root( fdiv( fadd( 9, sqrt( 69 ) ), 2 ), 3 ) c = fadd( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) ) d = fsub( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) ) e = power( 3, fdiv( 2, 3 ) ) r = fadd( fdiv( a, 3 ), fdiv( b, e ) ) s = fsub( fmul( fdiv( d, -6 ), a ), fdiv( fmul( c, b ), fmul( 2, e ) ) ) t = fsub( fmul( fdiv( c, -6 ), a ), fdiv( fmul( d, b ), fmul( 2, e ) ) ) return nint( re( fsum( [ fdiv( power( r, n ), fadd( fmul( 2, r ), 3 ) ), fdiv( power( s, n ), fadd( fmul( 2, s ), 3 ) ), fdiv( power( t, n ), fadd( fmul( 2, t ), 3 ) ) ] ) ) )
def getNthKFibonacciNumber( n, k ): if real( n ) < 0: raise ValueError( 'non-negative argument expected' ) if real( k ) < 2: raise ValueError( 'argument <= 2 expected' ) if n < k - 1: return 0 nth = int( n ) + 4 precision = int( fdiv( fmul( n, k ), 8 ) ) if ( mp.dps < precision ): mp.dps = precision poly = [ 1 ] poly.extend( [ -1 ] * int( k ) ) roots = polyroots( poly ) nthPoly = getNthFibonacciPolynomial( k ) result = 0 exponent = fsum( [ nth, fneg( k ), -2 ] ) for i in range( 0, int( k ) ): result += fdiv( power( roots[ i ], exponent ), polyval( nthPoly, roots[ i ] ) ) return floor( fadd( re( result ), fdiv( 1, 2 ) ) )
def getNthLucasNumber( n ): if real( n ) == 0: return 2 elif n == 1: return 1 else: return floor( fadd( power( phi, n ), 0.5 ) )
def tetrateRight( i, j ): result = i for x in arange( 1, j ): result = power( i, result ) return result
def tetrate( i, j ): result = i for x in arange( 1, j ): result = power( result, i ) return result
def stirling(x): #uses Stirling's approximation # x**y = e**(y log x) in essentially constant time n = mpmath.mpf(x) coeff = mpmath.sqrt(2 * mpmath.pi * n) expon = mpmath.power(n/mpmath.e, n) return coeff * expon
def packInteger( values, fields ): if isinstance( values, RPNGenerator ): return packInteger( list( values ), fields ) elif not isinstance( values, list ): return unpackInteger( [ values ], fields ) if isinstance( fields, RPNGenerator ): return packInteger( values, list( fields ) ) elif not isinstance( fields, list ): return unpackInteger( values, [ fields ] ) if isinstance( values[ 0 ], list ): return [ unpackInteger( value, fields ) for value in values ] result = 0 count = min( len( values ), len( fields ) ) size = 0 for i in range( count, 0, -1 ): result = fadd( result, fmul( values[ i - 1 ], power( 2, size ) ) ) size += fields[ i - 1 ] return result