我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用math.e()。
def GetFh(self,code):#?????? try: ret = urllib.urlopen("http://money.finance.sina.com.cn/corp/go.php/vISSUE_ShareBonus/stockid/" + code + ".phtml") soup = BeautifulSoup(Tools().smartCode(ret.read()), "html.parser") dict = {} for x in soup.find_all('tbody'): for e in str(x).split('_blank'): if "type=1" in e: td = re.findall(r'<td>(.+?)</td>', e) dict.update({td[0]: {u"????".encode('gbk', 'ignore').decode('gbk'): td[0], u"??".encode('gbk', 'ignore').decode('gbk'): td[1], u"??".encode('gbk', 'ignore').decode('gbk'): td[2], u"??".encode('gbk', 'ignore').decode('gbk'): td[3], u"??".encode('gbk', 'ignore').decode('gbk'): td[4], u"?????".encode('gbk', 'ignore').decode('gbk'): td[5], u"?????".encode('gbk', 'ignore').decode('gbk'): td[6], u"?????".encode('gbk', 'ignore').decode('gbk'): td[7] }}) return pandas.DataFrame.from_dict(dict, orient="index") except: return None
def GetPg(self,code):#?????? try: ret = urllib.urlopen("http://money.finance.sina.com.cn/corp/go.php/vISSUE_ShareBonus/stockid/" + code + ".phtml") soup = BeautifulSoup(Tools().smartCode(ret.read()), "html.parser") dict = {} for x in soup.find_all('tbody'): for e in str(x).split('_blank'): if "type=2" in e: td = re.findall(r'<td>(.+?)</td>', e) dict.update({td[0]: {u"????".encode('gbk', 'ignore').decode('gbk'): td[0], u"????".encode('gbk', 'ignore').decode('gbk'): td[1], u"????".encode('gbk', 'ignore').decode('gbk'): td[2], u"????".encode('gbk', 'ignore').decode('gbk'): td[3], u"???".encode('gbk', 'ignore').decode('gbk'): td[4], u"?????".encode('gbk', 'ignore').decode('gbk'): td[5], u"?????".encode('gbk', 'ignore').decode('gbk'): td[6], u"?????".encode('gbk', 'ignore').decode('gbk'): td[7], u"?????".encode('gbk', 'ignore').decode('gbk'): td[8], }}) return pandas.DataFrame.from_dict(dict, orient="index") except: return None
def test_callback_register_double(self): # Issue #8275: buggy handling of callback args under Win64 # NOTE: should be run on release builds as well dll = CDLL(_ctypes_test.__file__) CALLBACK = CFUNCTYPE(c_double, c_double, c_double, c_double, c_double, c_double) # All this function does is call the callback with its args squared func = dll._testfunc_cbk_reg_double func.argtypes = (c_double, c_double, c_double, c_double, c_double, CALLBACK) func.restype = c_double def callback(a, b, c, d, e): return a + b + c + d + e result = func(1.1, 2.2, 3.3, 4.4, 5.5, CALLBACK(callback)) self.assertEqual(result, callback(1.1*1.1, 2.2*2.2, 3.3*3.3, 4.4*4.4, 5.5*5.5)) ################################################################
def evaluateStack( s ): op = s.pop() if op == 'unary -': return -evaluateStack( s ) if op in "+-*/^": op2 = evaluateStack( s ) op1 = evaluateStack( s ) return opn[op]( op1, op2 ) elif op == "PI": return math.pi # 3.1415926535 elif op == "E": return math.e # 2.718281828 elif op in fn: return fn[op]( evaluateStack( s ) ) elif op[0].isalpha(): raise Exception("invalid identifier '%s'" % op) else: return float( op )
def evaluateStack( s ): op = s.pop() if op == 'unary -': return -evaluateStack( s ) if op in "+-*/^": op2 = evaluateStack( s ) op1 = evaluateStack( s ) return opn[op]( op1, op2 ) elif op == "PI": return math.pi # 3.1415926535 elif op == "E": return math.e # 2.718281828 elif op in fn: return fn[op]( evaluateStack( s ) ) elif op[0].isalpha(): if op in variables: return variables[op] raise Exception("invalid identifier '%s'" % op) else: return float( op )
def test_Timing(self): e = vu.ElapsedTime() with vu.Timing(elapsed=e): time.sleep(0.2) self.assertAlmostEqual(e.value, 0.2, places=1) # test some other modes of invocation with vu.Timing() as t: x = 1 loglvl = 10 class FakeLog: def __init__(self, testclass): self.tc = testclass def log(self, lvl, msg): self.tc.assertEqual(lvl, loglvl) with vu.Timing(log=FakeLog(self), level=loglvl): x = 1
def test_get_mongo(self): "Test get_mongo() function" import math with self.assertRaises(ValueError): for rec in [1, 2, 3], 'foo': vv.mongo_get(rec, 'a') for rec in {}, None, '': self.assertEqual(vv.mongo_get(rec, 'a', 'dee-fault'), 'dee-fault') rec = {'a': { 'apple': { 'red': 'delicious', 'green': 'grannysmith', 'blue': 'venutian'}, 'anumber': 2, }, 'e': math.e, } default = 'mittens' # these should be found for key, expected in (('a.apple.green', 'grannysmith'), ('a.anumber', 2), ('e', math.e)): self.assertEqual(vv.mongo_get(rec, key, default), expected) # these should not for key in 'a.apple.orange', 'x', '', 'z.zebra.', '.': self.assertEqual(vv.mongo_get(rec, key, default), default)
def get_price_for_trade(prediction, trade): """Returns the price of a trade for a prediction.""" if trade.contract == 'CONTRACT_ONE': old_quantity = prediction.contract_one old_quantity_other = prediction.contract_two else: old_quantity = prediction.contract_two old_quantity_other = prediction.contract_one if trade.direction == 'BUY': new_quantity = old_quantity + trade.quantity else: new_quantity = old_quantity - trade.quantity price = (prediction.liquidity * math.log( math.pow(math.e, (new_quantity / prediction.liquidity)) + math.pow(math.e, (old_quantity_other / prediction.liquidity)))) - ( prediction.liquidity * math.log( math.pow(math.e, (old_quantity / prediction.liquidity)) + math.pow(math.e, (old_quantity_other / prediction.liquidity)))) return price
def getForegroundMask(self): ''' @return: A mask image indicating which pixels are considered foreground. Depending on whether soft-thresholding is used, this may be a binary image with values of [0 or 255], or image of weights [0.0-255.0], which will have to be divided by 255 to get weights [0.0-1.0]. @note: One may wish to perform additional morphological operations on the foreground mask prior to use. ''' diff = self._computeBGDiff() if self._softThreshold: mask = 1 - (math.e)**(-(1.0*diff)/self._threshold) #element-wise exp weighting #mask = (diff > self._threshold) else: mask = (sp.absolute(diff) > self._threshold) #mu = sp.mean(diff) #sigma = sp.std(diff) #mask = sp.absolute((diff-mu)/sigma) > self._threshold return pv.Image(mask*255.0)
def _PrintResiduals(self, slope, intercept): independent_dict = None dependent_dict = None if len(self._county_idata) > 0 and len(self._county_ddata) > 0: independent_dict = self._county_idata dependent_dict = self._county_ddata else: independent_dict = self._independent_data dependent_dict = self._dependent_data for precinct,logvotes in sorted(independent_dict.iteritems()): if precinct not in dependent_dict: continue actual = int(math.e**dependent_dict[precinct]) predict_exponent = intercept + slope*logvotes predict = int(math.e**predict_exponent) diff = actual - predict pct_error = (1.0 * diff) / predict print('%-38s\t%7d\t%7d\t%7d\t%7.4f' % (precinct, actual, predict, diff, pct_error))
def get_theta(): import math theta = [0.0, 0.0, 0.0] step = 0.01 comments = Comment.query.all()[:100] print "Comments gotten! Training..." for m in range(1000): for comment in comments: if comment.emotion != -1: x = [1, float(comment.pos_count), float(comment.neg_count)] feature_sum = 0 for i in range(3): feature_sum += theta[i]*x[i] h = 1 / (1+math.e**-(feature_sum)) for i in range(3): theta[i] = theta[i] + step*(comment.emotion-h)*x[i] print "Theta Gotten: ", theta
def get_emotion(): print "Calculating thetas..." get_theta() print "Done!" comments = Comment.query.filter_by(emotion=-1).all() for comment in comments: x = [1, float(comment.pos_count), float(comment.neg_count)] hypothesis = 0 feature_sum = 0 for i in range(3): feature_sum += theta[i]*x[i] hypothesis = 1 / (1+math.e**-(feature_sum)) if 0 < hypothesis < 0.4: comment.analysis_score = 0 elif 0.4 <= hypothesis < 0.6: comment.analysis_score = 0.5 elif 0.6 <= hypothesis < 1: comment.analysis_score = 1
def get_stats_and_update_occupancy(CG, sorted_nodes, tfile) : """ Update the occupancy in the Graph and the total simulation time """ # http://www.regular-expressions.info/floatingpoint.html reg_flt = re.compile('[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?.') lastlines = s.check_output(['tail', '-2', tfile]).strip().split("\n") if not reg_flt.match(lastlines[0]): raise ValueError('Cannot parse simulation output', tfile) else : time = float(lastlines[0].split()[0]) iterations = int(lastlines[-1].split()[-1]) tot_occ =sum(map(float, lastlines[0].split()[1:])) for e, occu in enumerate(lastlines[0].split()[1:]) : ss = sorted_nodes[e][0] CG.node[ss]['occupancy'] = float(occu)/tot_occ return time, iterations
def evaluateStack( s ): try: op = s.pop() if op == 'unary -': return -evaluateStack( s ) if op in "+-*/^": op2 = evaluateStack( s ) op1 = evaluateStack( s ) return opn[op]( op1, op2 ) elif op == "PI": return math.pi # 3.1415926535 elif op == "E": return math.e # 2.718281828 elif op in fn: return fn[op]( evaluateStack( s ) ) elif op[0].isalpha(): return 0 else: return float( op ) except: return None
def test_use_decimal(): import math from decimal import Decimal dstr = "2.7182818284590452353602874713527" d = Decimal(dstr) with pytest.raises(TypeError): rapidjson.dumps(d) assert rapidjson.dumps(float(dstr)) == str(math.e) assert rapidjson.dumps(d, use_decimal=True) == dstr assert rapidjson.dumps({"foo": d}, use_decimal=True) == '{"foo":%s}' % dstr assert rapidjson.loads( rapidjson.dumps(d, use_decimal=True), use_decimal=True) == d assert rapidjson.loads(rapidjson.dumps(d, use_decimal=True)) == float(dstr)
def poisson_distribution(gamma): """Computes the probability of events for a Poisson distribution. Args: gamma: The average number of events to occur in an interval. Returns: The probability distribution of k events occuring. This is a function taking one parameter (k) and returning the probability of k events occuring. """ constant_factor = math.e ** (-gamma) def probability(k): """The probability of k events occuring for a Poisson distribution. Args: k: The number of the events occuring in an interval. Returns: The probability of k events occuring in the given distribution. """ return (constant_factor * gamma ** k) / (math.factorial(k)) return probability
def _createGameFromData(self, gameData): temp = int(gameData['Template']) tempID, tempSettings, overrides = self._getTempSettings(temp) teams = self._assembleTeams(gameData) try: wlID = self.handler.createGame(tempID, self._getGameName(gameData), teams, settingsDict=tempSettings, overridenBonuses=overrides, teamless=self.teamless, message=self._getGameMessage(gameData)) self._adjustTemplateGameCount(temp, 1) createdStr = datetime.strftime(datetime.now(), self.TIMEFORMAT) self._updateEntityValue(self.games, gameData['ID'], WarlightID=wlID, Created=createdStr) return gameData except Exception as e: sides = gameData['Sides'] self.parent.log("Failed to make game with %s on %d because of %s" % (sides, temp, repr(e)), self.name, error=True) self._deleteGame(gameData, False, False)
def _createBatch(self, batch): currentID = self._getBatchStartingID() for game in batch: try: self._addEntity(self.games, {'ID': currentID, 'WarlightID': '', 'Created': '', 'Winners': '', 'Sides': game['Sides'], 'Vetos': 0, 'Vetoed': '', 'Finished': '', 'Template': game['Template']}) self._makeGame(currentID) currentID += 1 except (SheetErrors.DataError, SheetErrors.SheetError) as e: self.parent.log(("Failed to add game to sheet due to %s" % str(e)), self.name, error=True) except APIError as e: self.parent.log(("Failed to create game with ID %d" % (currentID)), self.name, error=True)
def test_nfloat_ops_binary(): # Signedness (nfloat + nfloat) assert (nfloat( exponent=4 ) + nfloat( exponent=4 )).e == 4 assert (nfloat( exponent=4 ) + nfloat( exponent=8 )).e == 8 assert (nfloat( exponent=8 ) + nfloat( exponent=4 )).e == 8 assert (nfloat( exponent=8 ) + nfloat( exponent=8 )).e == 8 # Size (nfloat + nfloat) assert (nfloat( mantissa=4 ) + nfloat( mantissa=4 )).m == 4 assert (nfloat( mantissa=4 ) + nfloat( mantissa=8 )).m == 8 assert (nfloat( mantissa=8 ) + nfloat( mantissa=4 )).m == 8 assert (nfloat( mantissa=8 ) + nfloat( mantissa=8 )).m == 8 # Signedness (nfloat + float) assert (nfloat( exponent=4 ) + 0.0).e == 4 assert (nfloat( exponent=8 ) + 0.0).e == 8 # Size (nfloat + float) assert (nfloat( mantissa=4 ) + 0.0).m == 4 assert (nfloat( mantissa=8 ) + 0.0).m == 8 # Arithmetic assert float32(3.0) + float32(2.0) == float32(5.0) assert float32(3.0) - float32(2.0) == float32(1.0) assert float32(3.0) * float32(2.0) == float32(6.0) assert float32(3.0) / float32(2.0) == float32(1.5) assert float32(3.0) // float32(2.0) == float32(1.0) assert float32(7.0) % float32(5.0) == float32(2.0) assert float32(3.0) ** float32(4.0) == float32(81.0)
def test_nfloat_ops_reflected(): # Exponent size (float <op> nfloat) assert (0.0 + nfloat( exponent=4 )).e == 4 assert (0.0 + nfloat( exponent=8 )).e == 8 assert (0.0 + nfloat( exponent=4 )).e == 4 assert (0.0 + nfloat( exponent=8 )).e == 8 # Mantissa size (float <op> nfloat) assert (0.0 + nfloat( mantissa=4 )).m == 4 assert (0.0 + nfloat( mantissa=8 )).m == 8 assert (0.0 + nfloat( mantissa=4 )).m == 4 assert (0.0 + nfloat( mantissa=8 )).m == 8 # Arithmetic assert 3.0 + float32(2.0) == float32(5.0) assert 3.0 - float32(2.0) == float32(1.0) assert 3.0 * float32(2.0) == float32(6.0) assert 3.0 / float32(2.0) == float32(1.5) assert 3.0 // float32(2.0) == float32(1.0) assert 7.0 % float32(5.0) == float32(2.0) assert 3.0 ** float32(4.0) == float32(81.0)
def test_constants(): for prec in [3, 7, 10, 15, 20, 37, 80, 100, 29]: mp.dps = prec assert pi == mpf(tpi) assert e == mpf(te) assert degree == mpf(tdegree) assert euler == mpf(teuler) assert ln2 == mpf(tln2) assert ln10 == mpf(tln10) assert catalan == mpf(tcatalan) assert khinchin == mpf(tkhinchin) assert glaisher == mpf(tglaisher) assert phi == mpf(tphi) if prec < 50: assert mertens == mpf(tmertens) assert twinprime == mpf(ttwinprime) mp.dps = 15 assert pi >= -1 assert pi > 2 assert pi > 3 assert pi < 4
def kullback_leibler_divergence(prob_dist1, prob_dist2, base=math.e): # Calculate the Kullback-Leibler divergence kl_divergence = 0 # To avoid zero in the numerator or denominator pseudo_count = 0.000001 for index in range(len(prob_dist1)): #print 'KL Divergence PD1[{0}]: {1} PD2[{0}]: {2}'.format(index, prob_dist1[index], prob_dist2[index]) #print "newdiv == {0}".format(newdiv(float(prob_dist1[index]) + pseudo_count, float(prob_dist2[index]) + pseudo_count)) #kl_divergence += prob_dist1[index] * math.log(newdiv(float(prob_dist1[index]) + pseudo_count, float(prob_dist2[index]) + pseudo_count), base) kl_divergence += prob_dist1[index] * math.log((float(prob_dist1[index]) + pseudo_count) / (float(prob_dist2[index]) + pseudo_count), base) return kl_divergence
def jensen_shannon_divergence(prob_dist1, prob_dist2, base=math.e): # Calculate "M" == (prob_dist1 + prob_dist2) / 2 # m = [] len_pd1 = len(prob_dist1) m = [0.5 * (prob_dist1[index] + prob_dist2[index]) for index in range(len_pd1)] # for index in range(0, len(prob_dist1)): # m.append(0.5 * (prob_dist1[index] + prob_dist2[index])) #print 'M: {0}'.format(m) # Return Jensen-Shannon Divergence jsd = 0.5 * (kullback_leibler_divergence(prob_dist1, m, base) + kullback_leibler_divergence(prob_dist2, m, base)) #print 'Jensen-Shannon Divergence: {0}'.format(jsd) return jsd
def annealing_optimize(domain, cost_fuc, t=10000.0, cool=0.95, step=1): vec = [float(random.randint(domain[i][0], domain[i][1])) for i in range(len(domain))] while t > 0.1: i = random.randint(0, len(domain)-1) direction = random.randint(-step, step) new_vec = vec[:] new_vec[i] += direction if new_vec[i] < domain[i][0]: new_vec[i] = domain[i][0] elif new_vec[i] > domain[i][1]: new_vec[i] = domain[i][1] cost = cost_fuc(vec) new_cost = cost_fuc(new_vec) # ?? pow(math.e, -(new_cost-cost)/t) ??????? # ?new_cost > cost ?????t????????new_cost # ??t????????????new_cost # ??t???????????new_cost if new_cost < cost or random.random() < pow(math.e, -(new_cost+cost)/t): vec = new_vec t *= cool return vec, cost_fuc(vec)
def run_cc(self, cmd, msg): gid = str(msg.guild.id) if self.ccs[gid][cmd]["locked"] and not msg.author.guild_permissions.manage_messages: await respond(msg, f"**WARNING: Custom command {cmd} is locked.**") else: ccdat = self.ccs[gid][cmd]["content"] try: res = self._find_tags(ccdat, msg) except CustomCommandSyntaxError as e: err = e if e else "Syntax error." await respond(msg, f"**WARNING: Author made syntax error: {err}**") except CommandSyntaxError as e: err = e if e else "Syntax error." await respond(msg, f"**WARNING: {err}**") except Exception: self.logger.exception("Exception occurred in custom command: ", exc_info=True) await respond(msg, "**WARNING: An error occurred while running the custom command.**") else: if res: await respond(msg, res) else: self.logger.warning(f"CC {cmd} of {str(msg.guild)} returns nothing!") self.ccvars = {} self.ccs[gid][cmd]["times_run"] += 1 self._save_ccs()
def upper_incomplete_gamma(a,x,d=0,iterations=100): if d == iterations: if ((d % 2) == 1): return 1.0 # end iterations else: m = d/2 return x + (m-a) if d == 0: result = ((x**a) * (e**(-x)))/upper_incomplete_gamma(a,x,d=d+1) return result elif ((d % 2) == 1): m = 1.0+((d-1.0)/2.0) return x+ ((m-a)/(upper_incomplete_gamma(a,x,d=d+1))) else: m = d/2 return 1+(m/(upper_incomplete_gamma(a,x,d=d+1))) # 6.5.31 Handbook of Mathematical Functions, page 263 # Recursive implementation
def lower_incomplete_gamma(a,x,d=0,iterations=100): if d == iterations: if ((d % 2) == 1): return 1.0 # end iterations else: m = d/2 return x + (m-a) if d == 0: result = ((x**a) * (e**(-x)))/lower_incomplete_gamma(a,x,d=d+1) return result elif ((d % 2) == 1): m = d - 1 n = (d-1.0)/2.0 return a + m - (((a+n)*x)/lower_incomplete_gamma(a,x,d=d+1)) else: m = d-1 n = d/2.0 return a+m+((n*x)/(lower_incomplete_gamma(a,x,d=d+1)))
def _normal_function(x, mean, variance): """ Find a value in the cumulative distribution function of a normal curve. See https://en.wikipedia.org/wiki/Normal_distribution Args: x (float): Value to feed into the normal function mean (float): Mean of the normal function variance (float): Variance of the normal function Returns: float Example: >>> round(_normal_function(0, 0, 5), 4) 0.1784 """ e_power = -1 * (((x - mean) ** 2) / (2 * variance)) return (1 / math.sqrt(2 * variance * math.pi)) * (math.e ** e_power)
def test_callback_register_double(self): # Issue #8275: buggy handling of callback args under Win64 # NOTE: should be run on release builds as well dll = CDLL(_ctypes_test.__file__) CALLBACK = CFUNCTYPE(c_double, c_double, c_double, c_double, c_double, c_double) # All this function does is call the callback with its args squared func = dll._testfunc_cbk_reg_double func.argtypes = (c_double, c_double, c_double, c_double, c_double, CALLBACK) func.restype = c_double def callback(a, b, c, d, e): return a + b + c + d + e result = func(1.1, 2.2, 3.3, 4.4, 5.5, CALLBACK(callback)) self.assertEqual(result, callback(1.1*1.1, 2.2*2.2, 3.3*3.3, 4.4*4.4, 5.5*5.5))
def evaluate(self): self._set_ready() condition = self.get_parameter_value(self.condition) if not condition: return input_value = self.get_parameter_value(self.input_value) if isinstance(input_value, numbers.Number): for e in range(0, input_value): self._set_value(e) for cell in self.output_cells: cell.evaluate() else: for e in input_value: self._set_value(e) for cell in self.output_cells: cell.evaluate() pass pass for cell in self.output_cells: cell.reset() pass pass
def train(self): m = self.m for k in range(self.itern): cls = self.estimator(max_depth = 3, presort = True) cls.fit(self.X, self.y, sample_weight = self.w) self.estimators.append(cls) y_predict = cls.predict(self.X) error = 0 # number of wrong prediction for i in range(m): if y_predict[i] != self.y[i]: error += self.w[i] if error == 0: error += 0.01 # smoothness alpha = 0.5*log((1-error)/error) # estimator weight self.alphas = np.append(self.alphas, alpha) for i in range(m): # update sample weights if y_predict[i] != self.y[i]: self.w[i] *= e**alpha else: self.w[i] /= e**alpha self.w /= sum(self.w)
def ok(f): global PASS, FAIL if THE.tests: try: print("\n-----| %s |-----------------------" % f.__name__) if f.__doc__: print("# "+ re.sub(r'\n[ \t]*',"\n# ",f.__doc__)) f() print("# pass") PASS += 1 except Exception,e: FAIL += 1 print(traceback.format_exc()) return f ### LIB.tiles ##################################################
def mutate(old, abouts, pop=[], better= lambda x,y,z: cdom(x,y,z), fiddles= None, # e.g. de. maxWalkSat fiddle = any1thing, # e.g. around1 or any1thing after = wrap, # e.g. wrap or cap retries= THE.retries): assert retries > 0, 'too hard to satisfy model' new = abouts.copyDecs(old) if fiddle: for col in abouts._decs: if r() < THE.cf: new[col.pos] = fiddle(old[col.pos], col) # eg around1, any1thing if fiddles: new = fiddles(old,new,abouts,pop, better) # eg deFiddles maxWalkSatFiddles if after: # e.g. wrap cap for col in abouts._decs: new[col.pos] = after(new[col.pos], col) return new if abouts.ok(new) else mutate(old, abouts, pop,better, fiddles,fiddle, after, retries=retries-1) ### Tables #####################################################################
def cdom(x, y, abouts): "many objective" x= abouts.objs(x) y= abouts.objs(y) def w(better): return -1 if better == less else 1 def expLoss(w,x1,y1,n): return -1*math.e**( w*(x1 - y1) / n ) def loss(x, y): losses= [] n = min(len(x),len(y)) for obj in abouts._objs: x1, y1 = x[obj.pos] , y[obj.pos] x1, y1 = obj.norm(x1), obj.norm(y1) losses += [expLoss( w(obj.want),x1,y1,n)] return sum(losses) / n l1= loss(x,y) l2= loss(y,x) return l1 < l2
def gaussian_blur(cls, self, radius, n=3): if self.mode == 'RGBA': return cls.gaussian_blur(self.convert('RGBa'), radius, n).convert('RGBA') if self.mode == 'LA': return cls.gaussian_blur(self.convert('La'), radius, n).convert('LA') # http://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf # [7] Box length. L = math.sqrt(12.0 * float(radius) * radius / n + 1.0) # [11] Box radius. l = (L - 1.0) / 2.0 # Integer part. li = math.floor(l) # Reduce the fractional part in accordance with tests. a = math.e ** (2.5 * (l - li) / (li + 1)) - 1 a /= math.e ** (2.5 / (li + 1)) - 1 box_radius = li + a self.load() return self._new(self.im.box_blur(box_radius, n))
def evaluateStack(self, s): op = s.pop() if op == 'unary -': return -self.evaluateStack(s) if op in "+-*/^": op2 = self.evaluateStack(s) op1 = self.evaluateStack(s) return self.opn[op](op1, op2) elif op == "PI": return math.pi # 3.1415926535 elif op == "E": return math.e # 2.718281828 elif op in self.fn: return self.fn[op](self.evaluateStack(s)) elif op[0].isalpha(): return 0 else: return float(op)
def emp_cdf(samples,x): ''' Indicator Function for Empirical Distribution: 1: if X_i <= x 0: otherwise sample = X_i ''' def indicator(sample): # Note: This function will grab the value of "x" from the scope of the parent function. if sample <= x: return 1 else: return 0 sigma = 0 n = len(samples) for X_i in samples: sigma += indicator(X_i) return (1/n) * sigma # Function is a string with a matematical expression, e.g. function='x+5' # Input: function is a f: R --> R
def __init__(self): """ 'code_word' ????key???list?value?dict?????????? 'word_code' ????key????value?dict???????????? 'vocab' ????? 'N' N???????????? """ self.a = 0.65 self.b = 0.8 self.c = 0.9 self.d = 0.96 self.e = 0.5 self.f = 0.1 self.degree = 180 self.PI = math.pi self.code_word = {} self.word_code = {} self.vocab = set() self.N = 0 self.read_cilin()
def ntk(self, ra, da, rb, db, hra, hrb): if hra < hrb: tmpkey = str(hra) + "#" + str(hrb) else: tmpkey = str(hrb) + "#" + str(hra) if self.cache.exists(tmpkey): return float(self.cache.read(tmpkey)) lena,lenb = len(ra), len(rb) c, p, minlen = 0, 0, min(lena,lenb) while c < minlen and ra[c] == rb[c]: if ra[c] == "#": p += 1 c += 1 #print "p = ", p, "da, db", da, db, ra, rb if self.gamma == 1: r = (p+1)*(math.e**(-self.beta*(da + db - 2*p))) else: r = (1-self.gamma**(p+1))/(1-self.gamma)*(math.e**(-self.beta*(da + db - 2*p))) if len(self.cache) > self.cachesize: self.cache.removeAll() self.cache.insert(tmpkey,r) return r # if self.gamma == 1: # return (p+1)*(math.e**(-self.beta*(da + db - 2*p))) # else: # return (1-self.gamma**(p+1))/(1-self.gamma)*(math.e**(-self.beta*(da + db - 2*p)))
def test_import(self): self.assert_ok("""\ import math print(math.pi, math.e) from math import sqrt print(sqrt(2)) """)
def evaluateStack(self, s ): op = s.pop() if op == 'unary -': return -self.evaluateStack( s ) if op in "+-x/^": op2 = self.evaluateStack( s ) op1 = self.evaluateStack( s ) return self.opn[op]( op1, op2 ) elif op == "PI": return math.pi # 3.1415926535 elif op == "E": return math.e # 2.718281828 elif op in self.fn: return self.fn[op]( self.evaluateStack( s ) ) elif op[0].isalpha(): return 0 else: return float( op )
def Incap(self): df1 = self.sharedf incap=[] for x in df1['market_value']: incap.append(math.log(x,math.e)) df1['incap'] = incap return df1[['date','incap']]
def expmin(values, num): """ Return a list of `num` exponentially distributed numbers from the list `values`, starting at the lowest one. The base is the constant `e`. """ l = len(values) v = [] for i in range(num): index = int((exp(i / num) - 1.0) / (e - 1.0) * l) index = clipint(index, l) v.append(values[index]) return v
def expmax(values, num): """ Return a list of `num` exponentially distributed numbers from the list `values`, starting at the highest one. The base is the constant `e`. """ l = len(values) last = l - 1 v = [] for i in range(num): index = last - int((exp(i / num) - 1.0) / (e - 1.0) * l) index = clipint(index, l) v.append(values[index]) return v
