def calculatebmi(listpr): c = Context() for p in listpr: for timeattr in p.getalltimeattribute(): if timeattr.getattribute("HEIGHT") is not None and timeattr.getattribute("WEIGHT") is not None: bmi = c.divide(timeattr.getattribute("HEIGHT"), c.power(timeattr.getattribute("WEIGHT"), Decimal("2"))) timeattr.setattribute("BMI", bmi)
def test_timepoint(self): """Assert timepoints are saved from the schedule correctly as Decimals and ordered by appt_datetime. """ context = Context(prec=2) self.helper.consent_and_put_on_schedule() self.assertEqual( [obj.timepoint for obj in Appointment.objects.all().order_by('appt_datetime')], [context.create_decimal(n) for n in range(0, 4)])
def float_to_decimal(self, f): "Convert a floating point number to a Decimal with no loss of information" n, d = f.as_integer_ratio() numerator, denominator = Decimal(n), Decimal(d) ctx = Context(prec=60) result = ctx.divide(numerator, denominator) while ctx.flags[Inexact]: ctx.flags[Inexact] = False ctx.prec *= 2 result = ctx.divide(numerator, denominator) return result
def bench_telco(loops, filename): getcontext().rounding = ROUND_DOWN rates = list(map(Decimal, ('0.0013', '0.00894'))) twodig = Decimal('0.01') Banker = Context(rounding=ROUND_HALF_EVEN) basictax = Decimal("0.0675") disttax = Decimal("0.0341") with open(filename, "rb") as infil: data = infil.read() infil = io.BytesIO(data) outfil = six.StringIO() start = perf.perf_counter() for _ in range(loops): infil.seek(0) sumT = Decimal("0") # sum of total prices sumB = Decimal("0") # sum of basic tax sumD = Decimal("0") # sum of 'distance' tax for i in xrange(5000): datum = infil.read(8) if datum == '': break n, = unpack('>Q', datum) calltype = n & 1 r = rates[calltype] p = Banker.quantize(r * n, twodig) b = p * basictax b = b.quantize(twodig) sumB += b t = p + b if calltype: d = p * disttax d = d.quantize(twodig) sumD += d t += d sumT += t print(t, file=outfil) outfil.seek(0) outfil.truncate() return perf.perf_counter() - start
def float_to_decimal(f): """Convert a floating point number to a Decimal with no loss of information. See: http://docs.python.org/release/2.6.7/library/decimal.html#decimal-faq """ n, d = f.as_integer_ratio() numerator, denominator = Decimal(n), Decimal(d) ctx = Context(prec=60) result = ctx.divide(numerator, denominator) while ctx.flags[Inexact]: ctx.flags[Inexact] = False ctx.prec *= 2 result = ctx.divide(numerator, denominator) return result
def float_to_decimal(f): "Convert a floating point number to a Decimal with no loss of information" if f in _special_floats: return _special_floats[f] elif math.isnan(f): return Decimal('NaN') n, d = f.as_integer_ratio() numerator, denominator = Decimal(n), Decimal(d) ctx = Context(prec=60) result = ctx.divide(numerator, denominator) while ctx.flags[Inexact]: ctx.flags[Inexact] = False ctx.prec *= 2 result = ctx.divide(numerator, denominator) return result
def float_to_decimal(f): """ Convert a floating point number to a Decimal with no loss of information. Intended for Python 2.6 where casting float to Decimal does not work. """ n, d = f.as_integer_ratio() numerator, denominator = Decimal(n), Decimal(d) ctx = Context(prec=60) result = ctx.divide(numerator, denominator) while ctx.flags[Inexact]: ctx.flags[Inexact] = False ctx.prec *= 2 result = ctx.divide(numerator, denominator) return result
def solve(): mod, cnt, num1, num2 = 10 ** 9, 2, 1, 1 x, y = ( Decimal(1) / Decimal(5).sqrt(), (Decimal(1) + Decimal(5).sqrt()) / Decimal(2) ) _context = Context() while True: num1, num2 = num2, (num1 + num2) % mod _set = set(str(num1)) if '0' not in _set and len(_set) == 9: _tmp = x.log10() + cnt * y.log10() _num = int(_context.power(10, _tmp - int(_tmp) + 8)) _set = set(str(_num)) if '0' not in _set and len(_set) == 9: return cnt cnt += 1
def round_to_nearest(num, roundto): """ rounds num to the closest multiple of roundto. e.g., round_to_nearest(8,5) => 10 round_to_nearest(6,5) => 5 int -> int -> int """ assert num > 0 and roundto > 0 # for now ceil_ctx = Context() ceil_ctx.rounding = ROUND_CEILING num = Decimal(num) roundto = Decimal(roundto) modval = num % roundto if modval > roundto / 2: return (num/roundto).quantize(1, rounding=ROUND_CEILING) * roundto else: return (num/roundto).quantize(1, rounding=ROUND_FLOOR) * roundto
def query_naivebayes(model={}, text='', min_word_size=4, k=1): from decimal import Decimal, Context from math import log from re import sub as replace # cria contexto para o built-in Decimal context = Context() # processa texto para de ter apenas palavras significativas if type(text).__name__ == 'str': print('Processando texto, stemming, removendo stopwords ....\n\n') words = text_processing( replace(r'([^a-zA-Z ]+)', r'', text), min_word_size=min_word_size) else: words = text #return model # cria vetor de probabilidades prob_topic = list() for topic in model.keys(): #print("Calculando topico: %s" % topic) prob = context.ln(model[topic]['P_topic']) words_of_topic = model[topic]['P_wk'].keys() #print("ANTES %s" % words) for wk in words: #print("PROBLEMA %s %f %f" % (wk, model[topic]['P_wk'][wk], log(model[topic]['P_wk'][wk]))) if not wk in words_of_topic: prob += context.ln( model[topic]['P_wk']['espuria'] ) else: prob += context.ln( model[topic]['P_wk'][wk] ) prob_topic.append( {topic: prob} ) sorted_probs = sorted(prob_topic, key=lambda k: tuple(k.values())[0], reverse=True) return sorted_probs[0:k]
def get_completed_prices(kth_percentile=None): categories = { 'sportcoat': 3002, 'dress_shirt': 57991, 'casual_shirt': 57990, 'tie': 15662, 'sweater': 11484, 'coats_and_jacket': 57988, 'pant': 57989, 'jeans': 11483, 'suit': 3001, 'vest': 15691, 'sleepwear_and_robe': 11510, 'swimwear': 15690, 'dress_shoes': 53120 } prices = {} for key, category_id in categories.items(): request_completed(category_id=category_id) num_sold = f_api.response.dict()['paginationOutput']['totalEntries'] values_list = return_list_of_prices(f_api) list_len = len(values_list) list_mean = sum(values_list) / list_len prices[key] = { 'average_price': list_mean, 'values_list': values_list, 'num_sold': num_sold } if kth_percentile is not None: from decimal import Decimal, Context kth_decimal = Decimal(kth_percentile) / 100 index = Decimal(Decimal(list_len) * kth_decimal, Context(rounding='ROUND_UP')) sorted_values = sorted(values_list) kth_dist_value = sorted_values[int(index)] prices[key]['percentile'] = { 'percentile_value': kth_percentile, 'kth_distribution': kth_dist_value} return prices
def to_xdr_amount(value: Union[str, Decimal]) -> int: """Converts an amount to the appropriate value to send over the network as a part of an XDR object. Each asset amount is encoded as a signed 64-bit integer in the XDR structures. An asset amount unit (that which is seen by end users) is scaled down by a factor of ten million (10,000,000) to arrive at the native 64-bit integer representation. For example, the integer amount value 25,123,456 equals 2.5123456 units of the asset. This scaling allows for seven decimal places of precision in human-friendly amount units. This static method correctly multiplies the value by the scaling factor in order to come to the integer value used in XDR structures. See `Stellar's documentation on Asset Precision <https://www.stellar.org/developers/guides/concepts/assets.html#amount-precision-and-representation>`_ for more information. :param value: The amount to convert to an integer for XDR serialization. """ if not (isinstance(value, str) or isinstance(value, Decimal)): raise TypeError( f"Value of type '{value}' must be of type {str} or {Decimal}, but got {type(value)}." ) # throw exception if value * ONE has decimal places (it can't be represented as int64) try: amount = int((Decimal(value) * Operation._ONE).to_integral_exact( context=Context(traps=[Inexact]))) except decimal.Inexact: raise ValueError( f"Value of '{value}' must have at most 7 digits after the decimal." ) if amount < 0 or amount > 9223372036854775807: raise ValueError( f"Value of '{value}' must represent a positive number " "and the max valid value is 922337203685.4775807.") return amount
def testQueryGets(self): context = Context(prec=10, rounding=ROUND_HALF_EVEN) self.query_request.set_consistency(Consistency.EVENTUAL).set_statement( query_statement).set_prepared_statement( self.prepare_result_select).set_limit(3).set_max_read_kb( 2).set_max_write_kb(3).set_max_memory_consumption( 5).set_math_context(context) self.assertIsNone(self.query_request.get_compartment()) self.assertTrue(self.query_request.is_done()) self.assertEqual(self.query_request.get_limit(), 3) self.assertEqual(self.query_request.get_max_read_kb(), 2) self.assertEqual(self.query_request.get_max_write_kb(), 3) self.assertEqual(self.query_request.get_max_memory_consumption(), 5) self.assertEqual(self.query_request.get_math_context(), context) self.assertEqual(self.query_request.get_consistency(), Consistency.EVENTUAL) self.assertEqual(self.query_request.get_statement(), query_statement) self.assertEqual(self.query_request.get_prepared_statement(), self.prepare_result_select.get_prepared_statement()) self.assertEqual(self.query_request.get_timeout(), timeout)
def is_perfect_square(square, *, complex=False): """ Things I like about this: * cmath.sqrt is really neat! * float.is_integer() is descriptive * complex.real and complex.imag are well named * Decimal(<number>).sqrt(<context>) is handy Things that I don't like: * logic is branchy: we handle complex numbers iff complex=True * special case stuff for high precision floats of non-complex input only means that complex/real behaviour is different again... * """ if complex: root = cmath.sqrt(square) return root.real.is_integer() and root.imag.is_integer() if square < 0: return False high_precision_context = Context(prec=len(str(square)) * 2) return 0 == Decimal(square).sqrt(high_precision_context) % 1
def countPercentValueForGroup(self, row, rounding=0): column = CLaboratoryCalculatorTableModel.ciPercentCount rows = self.getGroupRows(row) for row in rows: rowGroupData = forceInt( self.data( self.index(row, CLaboratoryCalculatorTableModel.ciGroupSumm))) if rowGroupData: rowData = forceInt( self.data( self.index( row, CLaboratoryCalculatorTableModel.ciGlobalCount))) value = (100.0 * rowData) / rowGroupData decimalValue = Decimal(unicode(value)) context = Context(prec=rounding + len(str(int(value)))) value = float(decimalValue.normalize(context) / 1) self.setData(self.index(row, column), QtCore.QVariant(value))
def cova(patch_size, grp, align): ############################## T = grp[-1].t[1] - grp[0].t[0] ################### time span _p = patch_size ################################### shortcut Np = ceil(T / _p) ############################# nof patches p0 = grp[0].t[0] ######################## cova left endpoint if align: p0 -= Np * _p - T ###################### right align def GPI(t): return floor((t - p0) / _p) #### get patch index nof_guards = [1] * Np ############# number of guards per patch for g in grp: ############################################## if g.n == 1: continue ################################## ### Here we use the next_minus method to handle the case # vhen t's right endpoint is on a patch boundary. ###### j = [ GPI(g.t[0]), ###################################### GPI(g.t[1].next_minus(Context(prec=4))) ] #########< for i in range(j[0], j[1] + 1): ######################## nof_guards[i] = 2 ################################## return nof_guards, p0 ######################################
def sqrt_continued_fraction_period( number: int, *, members_count_start: int = 250, members_count_step: int = 50, precision_start: int = 500, precision_step: int = 250, precision_stop: int = 2_501) -> Sequence[int]: try: return memoized_sqrt_continued_fractions_periods[number] except KeyError: for members_count in count(members_count_start, members_count_step): for precision in range(precision_start, precision_stop, precision_step): context = Context(prec=precision) setcontext(context) sequence = list( islice(sqrt_continued_fraction(number), 1, members_count)) cycle = find_cycle(sequence) if cycle is not None: memoized_sqrt_continued_fractions_periods[number] = cycle return cycle
def test_sign_built_vote_tx(tx_builder, feeder_wallet, account_addrs, wei_value, sign_data): feeder, validator = account_addrs pub_key, signature = sign_data txb = tx_builder("soju-0012", 45, 0) txb.append_votemsg( exchange_rate=Decimal("8000.0").quantize( wei_value, context=Context(prec=30), ), denom="ukrw", feeder=f"{feeder}", validator=f"{validator}", salt="1234", ) result = txb.sign(feeder_wallet) expected = signed_message(feeder, validator, pub_key, signature) assert result == expected
def time_for_cookies(C, F, X): from decimal import Decimal from decimal import setcontext from decimal import Context setcontext(Context(prec=10)) time_taken = Decimal(0.0) current_cookies = Decimal(0.0) CPS = Decimal(2.0) wait_time = Decimal(0.0) buy_time = Decimal(0.0) if C > X > current_cookies: time_taken = X / CPS current_cookies = X return time_taken while current_cookies < X: if current_cookies >= C: wait_time = (X - current_cookies) / CPS buy_time = X / (CPS + F) if wait_time > buy_time: current_cookies = current_cookies - C CPS = CPS + F elif wait_time <= buy_time: time_taken = time_taken + (X - current_cookies) / CPS current_cookies = X elif current_cookies < C: wait_time = (C - current_cookies) / CPS current_cookies = C time_taken = time_taken + wait_time return time_taken
def _update_price(self, stock, price): symbol = stock.symbol.replace(".", "-") if stock.exchange == Stock.Exchange.TSX: symbol = symbol + ".TO" else: self.stderr.write( "Symbol: {}. We don't handle this exchange yet: {}".format( stock.symbol, stock.exchange)) return self.stdout.write("Looking up symbol {}".format(symbol)) new_price = round( Decimal( yfinance.Ticker(symbol).info["regularMarketPrice"], context=Context(prec=120), ), 4, ) if new_price != price.price: self.stdout.write("Updating price from {} to {}".format( price.price, new_price)) price.price = new_price price.save() else: self.stdout.write("No update required")
def __init__(self, precision=2): self.empty() self._context = Context(prec=precision)
def __new__(cls, *args, **kwargs): def replace_microsecond(new_value): if has_microsecond_argument: lst = list(args) lst[DATETIME_CONSTRUCTOR_MICROSECOND_ARGUMENT_INDEX] = new_value return tuple(lst) else: kwargs[TIMESTAMP_MICROSECOND_FIELD] = new_value return args precision = None fractional_precision = None fractional_seconds = None datetime_microseconds = None has_microsecond_argument = len( args) > DATETIME_CONSTRUCTOR_MICROSECOND_ARGUMENT_INDEX if has_microsecond_argument: datetime_microseconds = args[ DATETIME_CONSTRUCTOR_MICROSECOND_ARGUMENT_INDEX] elif TIMESTAMP_MICROSECOND_FIELD in kwargs: datetime_microseconds = kwargs.get(TIMESTAMP_MICROSECOND_FIELD) if TIMESTAMP_PRECISION_FIELD in kwargs: precision = kwargs.get(TIMESTAMP_PRECISION_FIELD) # Make sure we mask this before we construct the datetime. del kwargs[TIMESTAMP_PRECISION_FIELD] if TIMESTAMP_FRACTION_PRECISION_FIELD in kwargs: fractional_precision = kwargs.get( TIMESTAMP_FRACTION_PRECISION_FIELD) if fractional_precision is not None and not ( 0 <= fractional_precision <= MICROSECOND_PRECISION): raise ValueError( 'Cannot construct a Timestamp with fractional precision of %d digits, ' 'which is out of the supported range of [0, %d].' % (fractional_precision, MICROSECOND_PRECISION)) # Make sure we mask this before we construct the datetime. del kwargs[TIMESTAMP_FRACTION_PRECISION_FIELD] if TIMESTAMP_FRACTIONAL_SECONDS_FIELD in kwargs: fractional_seconds = kwargs.get(TIMESTAMP_FRACTIONAL_SECONDS_FIELD) if fractional_seconds is not None: if not (0 <= fractional_seconds < 1): raise ValueError( 'Cannot construct a Timestamp with fractional seconds of %s, ' 'which is out of the supported range of [0, 1).' % str(fractional_seconds)) # Make sure we mask this before we construct the datetime. del kwargs[TIMESTAMP_FRACTIONAL_SECONDS_FIELD] if fractional_seconds is not None and (fractional_precision is not None or datetime_microseconds is not None): raise ValueError( 'fractional_seconds cannot be specified ' 'when fractional_precision or microseconds are not None.') if fractional_precision is not None and datetime_microseconds is None: raise ValueError( 'datetime_microseconds cannot be None while fractional_precision is not None.' ) if fractional_precision == 0 and datetime_microseconds != 0: raise ValueError( 'datetime_microseconds cannot be non-zero while fractional_precision is 0.' ) if fractional_seconds is not None: fractional_seconds_exponent = fractional_seconds.as_tuple( ).exponent if fractional_seconds == DECIMAL_ZERO and fractional_seconds_exponent > 0: # Zero with a positive exponent is just zero. Set the exponent to zero so fractional_precision is # calculated correctly. fractional_seconds_exponent = 0 fractional_seconds = DECIMAL_ZERO fractional_precision = min(-fractional_seconds_exponent, MICROSECOND_PRECISION) # Scale to microseconds and truncate to an integer. args = replace_microsecond( int(fractional_seconds * BASE_TEN_MICROSECOND_PRECISION_EXPONENTIATION)) elif datetime_microseconds is not None: if fractional_precision is None: fractional_precision = MICROSECOND_PRECISION if fractional_precision == 0: # As previously verified, datetime_microseconds must be zero in this case. fractional_seconds = DECIMAL_ZERO else: try: fractional_seconds = Decimal(datetime_microseconds).scaleb(-MICROSECOND_PRECISION)\ .quantize(PRECISION_LIMIT_LOOKUP[fractional_precision], context=Context(traps=[Inexact])) except Inexact: raise ValueError( 'microsecond value %d cannot be expressed exactly in %d digits.' % (datetime_microseconds, fractional_precision)) else: assert datetime_microseconds is None # The datetime constructor requires a non-None microsecond argument. args = replace_microsecond(0) fractional_precision = 0 fractional_seconds = DECIMAL_ZERO instance = super(Timestamp, cls).__new__(cls, *args, **kwargs) setattr(instance, TIMESTAMP_PRECISION_FIELD, precision) setattr(instance, TIMESTAMP_FRACTION_PRECISION_FIELD, fractional_precision) setattr(instance, TIMESTAMP_FRACTIONAL_SECONDS_FIELD, fractional_seconds) return instance
# IN THE SOFTWARE. # """ Some utility functions to deal with mapping Amazon DynamoDB types to Python types and vice-versa. """ import base64 from decimal import (Decimal, DecimalException, Context, Clamped, Overflow, Inexact, Underflow, Rounded) from collections import Mapping from boto.dynamodb.exceptions import DynamoDBNumberError from boto.compat import filter, map, six, long_type DYNAMODB_CONTEXT = Context( Emin=-128, Emax=126, rounding=None, prec=38, traps=[Clamped, Overflow, Inexact, Rounded, Underflow]) # python2.6 cannot convert floats directly to # Decimals. This is taken from: # http://docs.python.org/release/2.6.7/library/decimal.html#decimal-faq def float_to_decimal(f): n, d = f.as_integer_ratio() numerator, denominator = Decimal(n), Decimal(d) ctx = DYNAMODB_CONTEXT result = ctx.divide(numerator, denominator) while ctx.flags[Inexact]: ctx.flags[Inexact] = False ctx.prec *= 2 result = ctx.divide(numerator, denominator)
def tahara_features(classify="dropout", is_classify="dropout", is_80=False): u"""田原アルゴリズムに基づいて特徴語を抽出し、ユーザーベクトルを作成する Args: calassify:適用するユーザーのクラス is_classify:どのユーザークラスらしさでベクトルを作成するか is_80:上位80語制限 """ import pymongo from decimal import Decimal,Context import math from function_common import get_word_point context=Context() count=0 if classify == "dropout": profiles=load_from_mongo(config.m_dropout.db,config.m_dropout.profile_coll) elif classify=="normal": profiles=load_from_mongo(config.m_normal.db,config.m_normal.profile_coll) elif classify=="dropout_test": profiles=load_from_mongo(config.m_dropout_test.db,config.m_dropout_test.profile_coll) print len(profiles) elif classify=="normal_test": profiles=load_from_mongo(config.m_normal_test.db,config.m_normal_test.profile_coll) print len(profiles) else: print "unknown classify ",classify return if is_classify =="dropout": dropouts=load_from_mongo(config.m_dropout.db,config.m_dropout.tahara_coll,True) names=[] for d in dropouts.sort("rate",pymongo.DESCENDING): count+=1 names.append(d["_id"]) if count >=1000: break if(is_80==True): print "name,dropout,{0}".format( ",".join([str(n) for n in names if get_word_point(n) > 0])) else: print "name,dropout,{0}".format(",".join([str(n) for n in names])) for profile in profiles: if classify == "dropout" or classify == "normal": wui=load_from_mongo("db","users_of_tehara",return_cursor=False,criteria={'_id':profile['_id']}) elif classify == "dropout_test" or classify == "normal_test": wui=load_from_mongo("db","users_of_tehara_test",return_cursor=False,criteria={'_id':profile['_id']}) else: print "unknown classify ",classify return if (wui is None) or (len(wui)==0): continue words= wui[0][u'words'] wui_wci=0 w2ui=0 w2ci=0 if is_classify =="dropout": dropouts=load_from_mongo(config.m_dropout.db,config.m_dropout.tahara_coll,True) else: dropouts=load_from_mongo(config.m_normal.db,config.m_normal.tahara_coll,True) if classify=="dropout": tweets=load_from_mongo(config.m_dropout.db,config.m_dropout.tweets_coll,criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) if len(tweets)==0: tweets=load_from_mongo(config.m_dropout.db,"tweets_of_dropout?",criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) tmp_sim_dropouts=[] tmp_sim_dropouts.append(profile["_id"]) tmp_sim_dropouts.append(-1) elif classify == "normal": tweets=load_from_mongo(config.m_normal.db,config.m_normal.tweets_coll,criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) tmp_sim_dropouts=[] tmp_sim_dropouts.append(profile["_id"]) tmp_sim_dropouts.append(1) elif classify == "dropout_test": tweets=load_from_mongo(config.m_dropout_test.db,config.m_dropout_test.tweets_coll,criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) if len(tweets)==0: tweets=load_from_mongo(config.m_dropout_test.db,"tweets_of_dropout?",criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) tmp_sim_dropouts=[] tmp_sim_dropouts.append(profile["_id"]) tmp_sim_dropouts.append(-1) elif classify == "normal_test": tweets=load_from_mongo(config.m_normal_test.db,config.m_normal_test.tweets_coll,criteria={'$and':[{"user.screen_name":profile["_id"]},{'text':{'$regex':'^[^RT]'}},{'created_at':{'$gte':profile["date_of_start"],'$lte':profile["date_of_dropout"]}}]}) tmp_sim_dropouts=[] tmp_sim_dropouts.append(profile["_id"]) tmp_sim_dropouts.append(-1) # 実際につぶやきがあった日数をカウント day_counter=set() for tweet in tweets: y=extract_time(tweet["created_at"],"Y") m=extract_time(tweet["created_at"],"M") d=extract_time(tweet["created_at"],"D") days=y,":",m,":",d day_counter.add(days) total_days=len(day_counter) if total_days == 0: print "Error! ",profile["_id"],"has 0 tweets." continue tmp_sim_dropouts=[] count=0 for d in dropouts.sort("rate",pymongo.DESCENDING): count+=1 word=[w for w in words if w["name"] == d["_id"]] if len(word)==0: word=[{"count":0,"name":d["_id"],"days":0}] else: pass cnt=Decimal(word[0]["count"]) rate=Decimal(d["rate"]) days=Decimal(word[0]["days"]) d_point=Decimal(get_word_point(d["_id"])) if d_point == 0: if is_classify=="dropout": if count > 1000: if is_80==True: break else: pass else: if is_80==True: continue else: pass td=Decimal(total_days) if is_classify=="dropout": tmp_wui_wci=Decimal(days/td) wui_wci+=tmp_wui_wci tmp_w2ui=context.power(cnt,2) w2ui+=tmp_w2ui tmp_w2ci=context.power(rate,2) w2ci+=tmp_w2ci else: tmp_wui_wci=Decimal(cnt*rate) wui_wci+=(cnt*rate) tmp_w2ui=Decimal(math.pow((Decimal(cnt)),2)) w2ui+=math.pow((cnt),2) tmp_w2ci=Decimal(math.pow(Decimal(rate),2)) w2ci+=math.pow(rate,2) if count >= 1000: break if tmp_wui_wci == 0 or tmp_w2ci == 0 or tmp_w2ui == 0 or cnt ==0: tmp_sim_dropouts.append(0) else: tmp_sim_dropout=tmp_wui_wci tmp_sim_dropouts.append(float(tmp_sim_dropout)) print profile["_id"],",True,{0}".format( ",".join([str(t) for t in tmp_sim_dropouts]) )
def round_places(input_value, prec=4): from decimal import Decimal, ROUND_HALF_EVEN, Context ctx = Context(prec=prec, rounding=ROUND_HALF_EVEN) return float(ctx.create_decimal(input_value))
def floatformat(text, arg=-1): """ Displays a float to a specified number of decimal places. If called without an argument, it displays the floating point number with one decimal place -- but only if there's a decimal place to be displayed: * num1 = 34.23234 * num2 = 34.00000 * num3 = 34.26000 * {{ num1|floatformat }} displays "34.2" * {{ num2|floatformat }} displays "34" * {{ num3|floatformat }} displays "34.3" If arg is positive, it will always display exactly arg number of decimal places: * {{ num1|floatformat:3 }} displays "34.232" * {{ num2|floatformat:3 }} displays "34.000" * {{ num3|floatformat:3 }} displays "34.260" If arg is negative, it will display arg number of decimal places -- but only if there are places to be displayed: * {{ num1|floatformat:"-3" }} displays "34.232" * {{ num2|floatformat:"-3" }} displays "34" * {{ num3|floatformat:"-3" }} displays "34.260" If the input float is infinity or NaN, the (platform-dependent) string representation of that value will be displayed. """ try: input_val = repr(text) d = Decimal(input_val) except InvalidOperation: try: d = Decimal(str(float(text))) except (ValueError, InvalidOperation, TypeError): return '' try: p = int(arg) except ValueError: return input_val try: m = int(d) - d except (ValueError, OverflowError, InvalidOperation): return input_val if not m and p < 0: return mark_safe(formats.number_format('%d' % (int(d)), 0)) if p == 0: exp = Decimal(1) else: exp = Decimal('1.0') / (Decimal(10)**abs(p)) # Set the precision high enough to avoid an exception (#15789). tupl = d.as_tuple() units = len(tupl[1]) units += -tupl[2] if m else tupl[2] prec = abs(p) + units + 1 # Avoid conversion to scientific notation by accessing `sign`, `digits`, # and `exponent` from Decimal.as_tuple() directly. sign, digits, exponent = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec)).as_tuple() digits = [str(digit) for digit in reversed(digits)] while len(digits) <= abs(exponent): digits.append('0') digits.insert(-exponent, '.') if sign: digits.append('-') number = ''.join(reversed(digits)) return mark_safe(formats.number_format(number, abs(p)))
from .schema import extract_record_type, extract_logical_type, parse_schema from ._schema_common import SCHEMA_DEFS from ._read_common import (SchemaResolutionError, MAGIC, SYNC_SIZE, HEADER_SCHEMA, missing_codec_lib) from ._timezone import epoch from .const import (MCS_PER_HOUR, MCS_PER_MINUTE, MCS_PER_SECOND, MLS_PER_HOUR, MLS_PER_MINUTE, MLS_PER_SECOND, DAYS_SHIFT) MASK = 0xFF AVRO_TYPES = { 'boolean', 'bytes', 'double', 'float', 'int', 'long', 'null', 'string', 'fixed', 'enum', 'record', 'error', 'array', 'map', 'union', 'request', 'error_union' } decimal_context = Context() def match_types(writer_type, reader_type): if isinstance(writer_type, list) or isinstance(reader_type, list): return True if isinstance(writer_type, dict) or isinstance(reader_type, dict): return match_schemas(writer_type, reader_type) if writer_type == reader_type: return True # promotion cases elif writer_type == 'int' and reader_type in ['long', 'float', 'double']: return True elif writer_type == 'long' and reader_type in ['float', 'double']: return True elif writer_type == 'float' and reader_type == 'double':
import math # Decimal precision getcontext().prec = 64 getcontext().Emax = 33 getcontext().Emin = -33 dec_con = getcontext() # Decimal constants dec_zero = dec_con.create_decimal('0E-16') dec_one = dec_con.create_decimal('1.0000000000000000') dec_eps = dec_con.create_decimal('1E-16') dec_qua = dec_con.create_decimal('1E-8') # Reward decimal context rew_con = Context(prec=64, Emax=33, Emin=-33) rew_quant = rew_con.create_decimal('0E-32') # Debug flag debug = True # logger class Logger(object): logger = logging.getLogger('Cryptotrader') @staticmethod def __init__(name, output_dir=None): """ Initialise the logger """ # Logger.logger = logging.getLogger(name)
import ast from decimal import Decimal, Context import decimal def binomial(n, k): if not(type(n) is int and type(k) is int): raise ValueError('expected int') res = 1 for i in range(n-k+1,n+1): res *= i for i in range(1,k+1): res /= i return res context = Context() stack = []; display_format = 'd' while 1: input_str = input("") try: if input_str == "quit": break if input_str == "": pass elif input_str == "%" or input_str == "mod": stack.append(stack.pop() % stack.pop()) elif input_str == "+": stack.append(stack.pop() + stack.pop())
def validDecimal_12_4(d): """validate that d is dec(12,4)""" FOURPLACES = Decimal(10)**-4 d.quantize(FOURPLACES, context=Context(traps=[Inexact])) if d < Decimal("1000000000000"): return True
u'hello', u'x' * 5000, 'x' * 9000, 123, -123, 123.12, -123.12, 10**20, 10**38 - 1, -10**38 + 1, datetime.datetime(2011, 2, 3, 10, 11, 12, 3000), Decimal('1234.567'), Decimal('1234000'), Decimal('9' * 38), Decimal('0.' + '9' * 38), Decimal('-' + ('9' * 38), Context(prec=38)), Decimal('1E10'), Decimal('1E-10'), Decimal('0.{0}1'.format('0' * 37)), None, 'hello', '', pytds.Binary(b''), pytds.Binary(b'\x00\x01\x02'), pytds.Binary(b'x' * 9000), 2**63 - 1, False, True, uuid.uuid4(), u'Iñtërnâtiônàlizætiøn1', u'\U0001d6fc',
def gauss_seidel(A, b, eps): global n setcontext(Context(traps=[DivisionByZero, Underflow, Overflow])) # Verifica se a matriz converge A_modified = sassenfeld(A) if A_modified is None: print('Convergence test failed') exit(0) n = len(A_modified) # Número de iterações máximas iter_max = 10000 # Vetor inicial de x x = [] # Vetor para os novos valores de x v = [] # Inicializa com zero os vetores de x inicial e x atualizado do mesmo tamanho do vetor b for i in range(n): x.append(Decimal(0.0)) v.append(Decimal(0.0)) # Percorre todas as linhas da matriz for i in range(n): r = Decimal(1.0) / A_modified[i][i] # percorre todas colunas da matriz for j in range(n): if i != j: # Divide o valor dos elementos que não fazem parte da diagonal da # matriz pelo o valor da diagonal correspondente aquela linha A_modified[i][j] = A_modified[i][j] * r # Divide o elemento do vetor resposta pelo valor da diagonal da matriz # correspondente aquela linha b[i] *= r # Quantidade de iterações k = 0 while True: # Inicializa a váriavel que recebe o calculo do critério de parada d = 0 # Incrementa o número de iterações k += 1 # Percorre todas as linhas da matriz for i in range(n): # Inicializa a soma como 0 soma = 0 # Percorre todas as colunas da matriz for j in range(n): # Se não for um elemento da diagonal principal soma o valor # do elemento multiplicado ao valor de x daquela linha a variavel soma if i != j: # Se for a primeira linha da matriz, x0 if i == 0: soma += A_modified[i][j] * x[j] # Caso contrário, utiliza os valores de x já calculado else: soma += A_modified[i][j] * v[j] # Calcula o valor de x mais atualizado com relação aquela linha # e o valor de y da linha v[i] = b[i] - soma # Recebe o valor do critério de parada d = teste_parada(x, v) # A_modifiedtualiza o vetor x para os valores de x calculados na iteração for i in range(0, n): x[i] = v[i] # Verifica se d é menor ou igual que o eps if d <= eps: return x # Verifica se k é maior que o número máximo de iterações elif k >= iter_max: break
def floatformat(text, arg=-1): """ Display a float to a specified number of decimal places. If called without an argument, display the floating point number with one decimal place -- but only if there's a decimal place to be displayed: * num1 = 34.23234 * num2 = 34.00000 * num3 = 34.26000 * {{ num1|floatformat }} displays "34.2" * {{ num2|floatformat }} displays "34" * {{ num3|floatformat }} displays "34.3" If arg is positive, always display exactly arg number of decimal places: * {{ num1|floatformat:3 }} displays "34.232" * {{ num2|floatformat:3 }} displays "34.000" * {{ num3|floatformat:3 }} displays "34.260" If arg is negative, display arg number of decimal places -- but only if there are places to be displayed: * {{ num1|floatformat:"-3" }} displays "34.232" * {{ num2|floatformat:"-3" }} displays "34" * {{ num3|floatformat:"-3" }} displays "34.260" If arg has the 'g' suffix, force the result to be grouped by the THOUSAND_SEPARATOR for the active locale. When the active locale is en (English): * {{ 6666.6666|floatformat:"2g" }} displays "6,666.67" * {{ 10000|floatformat:"g" }} displays "10,000" If the input float is infinity or NaN, display the string representation of that value. """ force_grouping = False if isinstance(arg, str) and arg.endswith('g'): force_grouping = True arg = arg[:-1] or -1 try: input_val = repr(text) d = Decimal(input_val) except InvalidOperation: try: d = Decimal(str(float(text))) except (ValueError, InvalidOperation, TypeError): return '' try: p = int(arg) except ValueError: return input_val try: m = int(d) - d except (ValueError, OverflowError, InvalidOperation): return input_val if not m and p < 0: return mark_safe( formats.number_format('%d' % (int(d)), 0, force_grouping=force_grouping), ) exp = Decimal(1).scaleb(-abs(p)) # Set the precision high enough to avoid an exception (#15789). tupl = d.as_tuple() units = len(tupl[1]) units += -tupl[2] if m else tupl[2] prec = abs(p) + units + 1 # Avoid conversion to scientific notation by accessing `sign`, `digits`, # and `exponent` from Decimal.as_tuple() directly. rounded_d = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec)) sign, digits, exponent = rounded_d.as_tuple() digits = [str(digit) for digit in reversed(digits)] while len(digits) <= abs(exponent): digits.append('0') digits.insert(-exponent, '.') if sign and rounded_d: digits.append('-') number = ''.join(reversed(digits)) return mark_safe( formats.number_format(number, abs(p), force_grouping=force_grouping), )
#attempt to Approximate ln(x) for a given value try: value_x = (value - D("1.0"))/(value + D("1.0")) for item in xrange(1,k,2): next_value = value_x**item/item first_value += next_value return 2*(first_value) #Raise TypeError if input is not a number except TypeError: print 'Please enter an integer or a float value' if __name__ == "__main__": with localcontext(Context(prec=67)): for arg in xrange(7,28,10): print "ln(%s) = %s " %\ (arg, maclaurin_ln(arg,D("10000"))) ####################################################################### #FT "C:\Maclaurin_lndecimal1.py" #ln(7) = 1.945910149055313305105352743443179729637084729581861188459390149937 #ln(17) = 2.833213344056216080249534617873126535588203012585744787297237737878 #ln(27) = 3.295836866004329074185735710767577113942471673468248355204083000896 ########################################################################################## Version : Python 3.2 #from decimal import Decimal as D
class Utils: TYPE_STRING = 'S' TYPE_NUMBER = 'N' TYPE_BINARY = 'B' TYPE_STRING_SET = 'SS' TYPE_NUMBER_SET = 'NS' TYPE_BINARY_SET = 'BS' TYPE_NULL = 'NULL' TYPE_BOOLEAN = 'BOOL' TYPE_MAP = 'M' TYPE_LIST = 'L' ALL_TYPES_WHERE_VALUE_DO_NOT_NEED_MODIFICATIONS = [TYPE_STRING, TYPE_BOOLEAN] DECIMAL_DYNAMODB_CONTEXT = Context(prec=38, rounding=decimal.ROUND_HALF_EVEN, Emin=-128, Emax=126, capitals=1, clamp=0, flags=[], traps=[]) # 38 is the maximum numbers of Decimals numbers that DynamoDB can support. from boto3.dynamodb.types import TypeSerializer, TypeDeserializer # The serializer and deserializer can be static, even in a lambda, # since their classes will never change according to the user. _serializer = None _deserializer = None @classmethod def serializer(cls) -> TypeSerializer: if cls._serializer is None: cls._serializer = cls.TypeSerializer() return cls._serializer @classmethod def deserializer(cls) -> TypeDeserializer: if cls._deserializer is None: cls._deserializer = cls.TypeDeserializer() return cls._deserializer # todo: deprecate this function that was a complication because i was using the decimal module @staticmethod def float_serializer(python_object): if isinstance(python_object, float): # Okay, this is a weird one. The decimal module will crash if it is passed a float # with less than two decimal numbers, like float(0.5) which has only one. The decimal # module is used when using the Utils.TypeSerializer accessible via the serializer property. # Yet, the module has no issues with number with more than 20 decimals, and we want to keep # this infos, so we will not round the object. Instead, with the "%.f" % python_object we will # get the number of decimal numbers on the float (returned in the form of a string, for real, # and if this number is under two, we will turn the float into a float with two decimal numbers by # using "%.2f" % python_object, which will then be able to be passed to the Decimal modules without errors. # PS : Obviously, instead of doing this, a number like 0.5 cannot be converted to an int ;) if ("%.f" % python_object) < "2": python_object = "%.2f" % python_object return Decimal(python_object) elif isinstance(python_object, list): for i, item in enumerate(python_object): python_object[i] = Utils.float_serializer(python_object=item) return python_object elif isinstance(python_object, dict): for key, value in python_object.items(): python_object[key] = Utils.float_serializer(python_object=value) return python_object else: return python_object def decimal_deserializer(self, python_object): from decimal import Decimal if isinstance(python_object, Decimal): if ("%.f" % python_object) > "0": python_object = float(python_object) else: python_object = int(python_object) return python_object elif isinstance(python_object, list): for i, item in enumerate(python_object): python_object[i] = Utils.decimal_deserializer(python_object=item) return python_object elif isinstance(python_object, dict): for key, value in python_object.items(): python_object[key] = Utils.decimal_deserializer(python_object=value) return python_object else: return python_object @staticmethod def python_to_dynamodb(python_object: Any): """ None {'NULL': True} True/False {'BOOL': True/False} int/Decimal {'N': str(value)} string {'S': string} Binary/bytearray/bytes (py3 only) {'B': bytes} set([int/Decimal]) {'NS': [str(value)]} set([string]) {'SS': [string]) set([Binary/bytearray/bytes]) {'BS': [bytes]} list {'L': list} dict {'M': dict} :param python_object: :return: """ object_type = type(python_object) if object_type in [int, float]: return {Utils.TYPE_NUMBER: Utils._python_to_decimal(python_number=python_object)} elif object_type == list: for i, item in enumerate(python_object): python_object[i] = Utils.python_to_dynamodb(python_object=item) return {Utils.TYPE_LIST: python_object} elif object_type == dict: for key, item in python_object.items(): python_object[key] = Utils.python_to_dynamodb(python_object=item) return {Utils.TYPE_MAP: python_object} elif object_type == bool: return {Utils.TYPE_BOOLEAN: python_object} elif object_type == str: return {Utils.TYPE_STRING: python_object} elif object_type == type(None): return {Utils.TYPE_NULL: True} elif object_type == bytes: return {Utils.TYPE_BINARY: python_object} else: return python_object @staticmethod def dynamodb_to_python(dynamodb_object: Any): if isinstance(dynamodb_object, Decimal): return Utils._decimal_to_python(decimal_number=dynamodb_object) elif isinstance(dynamodb_object, list): for i, item in enumerate(dynamodb_object): dynamodb_object[i] = Utils.dynamodb_to_python(dynamodb_object=item) return dynamodb_object elif isinstance(dynamodb_object, dict): if len(dynamodb_object) == 1: # If the length of the Dict is only one, it might be a DynamoDB object, with its key # as its variable type. For example : {'N': '1'} And yes, this also apply to lists and maps. first_key = list(dynamodb_object.keys())[0] first_item = dynamodb_object[first_key] # First do we thing, is check if the value is a Decimal value (which happens often). if isinstance(first_item, Decimal): return Utils._decimal_to_python(decimal_number=first_item) # Then the order of the elif statement is based on what we personally use the most at Inoft. # For example, we always use the numbers, string, list and dictionaries (maps) but always # never binary data or sets. In the default library, the list and dict were at the end of the loop. elif first_key == Utils.TYPE_NUMBER: return Utils._dynamodb_number_to_python(number_string=first_item) elif first_key == Utils.TYPE_STRING: return first_item elif first_key in Utils.ALL_TYPES_WHERE_VALUE_DO_NOT_NEED_MODIFICATIONS: return first_item elif first_key == Utils.TYPE_MAP: return dict([(key, Utils.dynamodb_to_python(element)) for key, element in first_item.items()]) elif first_key == Utils.TYPE_LIST: return [Utils.dynamodb_to_python(element) for element in first_item] elif first_key == Utils.TYPE_NULL: return None elif first_key == Utils.TYPE_BINARY: return Utils._dynamodb_binary_to_python(binary_data=first_item) elif first_key == Utils.TYPE_NUMBER_SET: return set(map(Utils.DECIMAL_DYNAMODB_CONTEXT.create_decimal, first_item)) elif first_key == Utils.TYPE_STRING_SET: return set(first_item) elif first_key == Utils.TYPE_BINARY_SET: from boto3.dynamodb.types import Binary return set(map(Utils._dynamodb_binary_to_python, first_item)) # If the dict was a classic dict, with its first key not in the keys used by DynamoDB keys_to_pop: List[str] = list() for key, item in dynamodb_object.items(): item_value = Utils.dynamodb_to_python(dynamodb_object=item) if item_value is not None: dynamodb_object[key] = item_value else: keys_to_pop.append(key) for key in keys_to_pop: dynamodb_object.pop(key) return dynamodb_object else: return dynamodb_object @staticmethod def dynamodb_to_python_higher_level(dynamodb_object: Any): if isinstance(dynamodb_object, Decimal): return Utils._decimal_to_python(decimal_number=dynamodb_object) elif isinstance(dynamodb_object, list): for i, item in enumerate(dynamodb_object): dynamodb_object[i] = Utils.dynamodb_to_python_higher_level(dynamodb_object=item) return dynamodb_object elif isinstance(dynamodb_object, dict): # If the dict was a classic dict, with its first key not in the keys used by DynamoDB for key, item in dynamodb_object.items(): dynamodb_object[key] = Utils.dynamodb_to_python_higher_level(dynamodb_object=item) return dynamodb_object return dynamodb_object @staticmethod def _decimal_to_python(decimal_number: Decimal) -> float or int: decimal_float = decimal_number.__float__() return decimal_float if decimal_float.is_integer() is not True else int(decimal_float) @staticmethod def _python_to_decimal(python_number: int or float) -> Decimal: return Utils.DECIMAL_DYNAMODB_CONTEXT.create_decimal(python_number) @staticmethod def _dynamodb_number_to_python(number_string: str): float_number = float(number_string) if float_number.is_integer(): return int(float_number) else: return float_number @staticmethod def _dynamodb_binary_to_python(binary_data): from boto3.dynamodb.types import Binary return Binary(value=binary_data) @staticmethod def python_type_to_dynamodb_type(python_type): """ {'NULL': True} None {'BOOL': True/False} True/False {'N': str(value)} Decimal(str(value)) {'S': string} string {'B': bytes} Binary(bytes) {'NS': [str(value)]} set([Decimal(str(value))]) {'SS': [string]} set([string]) {'BS': [bytes]} set([bytes]) {'L': list} list {'M': dict} dict """ if python_type == type(None): return "NULL" elif python_type == bool: return "BOOL" elif python_type in [Decimal, int, float]: return "N" elif python_type == str: return "S" elif python_type == bytes: return "B" elif python_type == list: return "L" elif python_type == dict: return "M"
from taurus.engine.runtime.dynamodb.definitions import ( InstanceDataHourlyDynamoDBDefinition, MetricDynamoDBDefinition, MetricDataDynamoDBDefinition, MetricTweetsDynamoDBDefinition) from htmengine import htmengineerrno, utils from htmengine.runtime.anomaly_service import AnomalyService from taurus.engine import logging_support g_log = taurus_logging.getExtendedLogger(__name__) # FIXME Hack around boto bug #2413 # See https://github.com/boto/boto/issues/2413 FIXED_DYNAMODB_CONTEXT = Context( Emin=-128, Emax=126, rounding=None, prec=5, # Reduce precision for overall reduction in payload size traps=[Clamped, Overflow, Underflow]) def convertDefineModelResultToMetricItem(modelCommandResult): """ Convert "defineModel" Model Command Result to MetricItem suitable for publishing to dynamodb. :param dict modelCommandResult: See model_command_result_amqp_message.json for schema. :returns: MetricItem instance suitable for publishing to the `taurus.metric` dynamodb table. :rtype: Instance of namedtuple implemented in `MetricDynamoDBDefinition().Item()` constructor """
import csv import gc import json from datetime import datetime, date from decimal import Decimal, Context, setcontext from os import path, environ from multiprocessing import Pool, cpu_count import click from spectrify.utils.timestamps import iso8601_to_nanos, iso8601_to_days_since_epoch from spectrify.utils.parquet import Writer from spectrify.utils.s3 import S3GZipCSVReader # Redshift allows up to 38 bits of decimal/numeric precision. Set the Python # decimal context accordingly redshift_context = Context(prec=38) setcontext(redshift_context) # This determines the number of rows in each row group of the Parquet file. # Larger row group means better compression. # Larger row group also means more memory required for write. # Assuming a row size of 2KB, this will process approx. 500MB of data per group. # Actual memory usage will be some multiple of that, since multiple copies # are required in memory for processing. SPECTRIFY_ROWS_PER_GROUP = environ.get('SPECTRIFY_ROWS_PER_GROUP') or 250000 # These are the values Redshift uses for true/false in its CSVs POSTGRES_TRUE_VAL = 't' POSTGRES_FALSE_VAL = 'f'
@cache def web_lookup(url): return urllib.urlopen(url).read() ''' print("-----分离临时上下文-----") print("保存旧的,创建新的") old_context = getcontext().copy() print(old_context) getcontext().prec = 50 print(Decimal(355) / Decimal(113)) setcontext(old_context) print("-----分离临时上下文,更好的方法-----") print("译注:示例代码在使用标准库decimal,这个库已经实现好了localcontext") with localcontext(Context(prec=50)): print(Decimal(355) / Decimal(113)) print("-----如何打开关闭文件-----") file = 'test.txt' file_name = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + \ '\\' + 'docs' + '\\' + 'txt' + '\\' + file f = open(file_name) try: data = f.read() print(data) finally: f.close() print("-----如何打开关闭文件,更好的方法-----") with open(file_name) as f:
from xrpl.constants import XRPLException ONE_DROP: Final[Decimal] = Decimal("0.000001") """Indivisible unit of XRP""" MAX_XRP: Final[Decimal] = Decimal(10 ** 11) """100 billion decimal XRP""" MAX_DROPS: Final[Decimal] = Decimal(10 ** 17) """Maximum possible drops of XRP""" # Drops should be an integer string. MAY have (positive) exponent. # See also: https://xrpl.org/currency-formats.html#string-numbers _DROPS_REGEX: Final[str] = r"[1-9][0-9Ee-]{0,17}|0" _DROPS_CONTEXT: Final[Context] = Context(prec=18, Emin=0, Emax=18) def xrp_to_drops(xrp: Union[int, float, Decimal]) -> str: """ Convert a numeric XRP amount to drops of XRP. Args: xrp: Numeric representation of whole XRP Returns: Equivalent amount in drops of XRP Raises: TypeError: if ``xrp`` is given as a string XRPRangeException: if the given amount of XRP is invalid
# # copyright: 2020-2021, Frederico Martins # author: Frederico Martins <http://github.com/fscm> # license: SPDX-License-Identifier: MIT """Tests for the Lek representation.""" from decimal import Context from pytest import raises from multicurrency import Currency, Lek from multicurrency import ( CurrencyMismatchException, CurrencyTypeException) CONTEXT = Context(prec=28, rounding='ROUND_HALF_EVEN').copy() def test_lek(): """test_lek.""" amount = CONTEXT.create_decimal(1) / CONTEXT.create_decimal(7) lek = Lek(amount=amount) decimal = CONTEXT.create_decimal(amount) assert lek.amount == decimal assert lek.numeric_code == '008' assert lek.alpha_code == 'ALL' assert lek.decimal_places == 2 assert lek.decimal_sign == ',' assert lek.grouping_sign == '\u202F' assert not lek.international assert lek.symbol == 'Lek'
def learn_naivebayes_text(texts=[], min_word_size=4): from datetime import datetime as date from decimal import Decimal, Context # cria contexto para o built-in Decimal context = Context() if type(texts).__name__ == 'list': print('Preparando dados') proc_texts = prepare_reuters_data(texts, min_word_size=min_word_size) else: proc_texts = texts print('\n\nCalculo das probabilidades\n') # cria vocabulario e ja conta ocorrencias de palavas # por texto vocabulary = set() freq_words = [] index = 0 for text in proc_texts['texts']: # contagem das palavras freq_words.append({}) for word in text: if not word in freq_words[index]: freq_words[index][word] = 0 freq_words[index][word] += 1 # criacao do vocabulario vocabulary.update(text) index += 1 # ja adiciona um para evitar a prob ser zero vocabulary_size = len(vocabulary) vocab_freq = {} for word in vocabulary: vocab_freq[word] = 1 # calculando P_topicj e P_wk__topicj topics = {} total_texts = len(proc_texts['texts']) for topic, text_indices in proc_texts['topics'].items(): print("\t" + date.now().strftime('[%Y-%m-%d %H:%M:%S]') + " topico: %s" % topic) topics[topic] = { 'P_topic': Decimal( len(text_indices) / total_texts), 'P_wk': vocab_freq } # itera os textos do topico em questao total_words = 0 for text in text_indices: for word, freq in freq_words[text].items(): topics[topic]['P_wk'][word] += freq total_words += len(freq_words[text]) # frequencia das palavras para o topico em questao # ja contadas, e acrescidas de 1, para evitar o zero # agora calcula a prob real da palavra dado o topico for word, freq in topics[topic]['P_wk'].items(): topics[topic]['P_wk'][word] = context.divide( Decimal(freq), Decimal(total_words + vocabulary_size)) # crio uma palavra nao existente como um marcador para # palavras nao vistas topics[topic]['P_wk']['espuria'] = context.divide( Decimal(1), Decimal(total_words + vocabulary_size)) print('\n\nTopicos processados: %d' % len(topics.keys())) print('Tamanho do vocabulario: %d' % vocabulary_size) return topics
return True if (n < 2 or n % 2 == 0): return False if (n < 9): return True if (n % 3 == 0): return False r = int(n**0.5) f = 5 while (f <= r): if (n % f == 0): return False if (n % (f + 2) == 0): return False f += 6 return True setcontext(Context(prec=300)) xe = Decimal(1).exp() xe_s = str(xe) print(xe_s) pos = 0 while (pos < 290): nr = int(xe_s[pos + 2:pos + 10]) pos += 1 if (is_prime(nr)): print(str(nr) + ":" + str(pos))
def arredondar_precisao_4(numero): return numero.quantize( Context(prec=4, rounding=ROUND_FLOOR).create_decimal(numero))