def test_add(f1, f2): s1, s2 = str(f1), str(f2) cd1, cd2 = cdecimal.Decimal(s1), cdecimal.Decimal(s2) d1, d2 = decimal.Decimal(s1), decimal.Decimal(s2) assert str(cd1) == s1 assert str(cd2) == s2 assert str(cd1 + cd2) == str(d1 + d2)
def getdecimal(self,*mpaths): ''' like get, but return a decimal value. If value to return is None or not numeric, zero is returned. warning: this function might 'mask' errors, because when input is not-valid, it aalwyas return a decimal 0. useful eg for when math calculations are needed in mapping. ''' terug = self.get(*mpaths) if terug and terug[-1] == u'-': #if minus-sign at the end, put it in front. This is useful for idocs, where fields are never defined as numeric. terug = terug[-1] + terug[:-1] try: return decimal.Decimal(terug) except (TypeError,ValueError): return decimal.Decimal('0')
def main(): D_to_x = {} x_squared_minus_one_is_square = {} for D in xrange(2, 1000 + 1): D_decimal = cdecimal.Decimal(D) if D_decimal.sqrt().is_integer(): continue x_squared_minus_one = D_decimal while True: #print x_squared_minus_one if x_squared_minus_one not in x_squared_minus_one_is_square: x_squared_minus_one_is_square[x_squared_minus_one] = ( x_squared_minus_one + 1).sqrt().is_integer() if x_squared_minus_one_is_square[x_squared_minus_one] and \ ((x_squared_minus_one / D_decimal).sqrt().is_integer()): break x_squared_minus_one += D_decimal x = (x_squared_minus_one + 1).sqrt() print "D: %s, x: %s" % (D, x) D_to_x[D] = x import ipdb ipdb.set_trace() pass
def convert(t, convstr=True): """ t is the testset. At this stage the testset contains a tuple of operands t.op of various types. For decimal methods the first operand (self) is always converted to Decimal. If 'convstr' is true, string operands are converted as well. Context operands are of type deccheck.Context, rounding mode operands are given as a tuple (C.rounding, P.rounding). Other types (float, int, etc.) are left unchanged. """ for i, op in enumerate(t.op): context.clear_status() if not t.contextfunc and i == 0 or \ convstr and isinstance(op, str): try: c = C.Decimal(op) cex = None except (TypeError, ValueError, OverflowError) as e: c = None cex = e.__class__ try: p = RestrictedDecimal(op) pex = None except (TypeError, ValueError, OverflowError) as e: p = None pex = e.__class__ t.cop.append(c) t.cex.append(cex) t.pop.append(p) t.pex.append(pex) if cex is pex: if str(c) != str(p) or not context.assert_eq_status(): raise_error(t) if cex and pex: # nothing to test return 0 else: raise_error(t) elif isinstance(op, Context): t.context = op t.cop.append(op.c) t.pop.append(op.p) elif op in RoundModes: t.cop.append(op[0]) t.pop.append(op[1]) else: t.cop.append(op) t.pop.append(op) return 1
def test_after(): """Test that we can fetch the first rate after a missing rate.""" d, e = store.get_rate('EUR', 'GBP', as_of_date=datetime.date(2015, 10, 10), closest_rate=ecbxrate.AFTER) assert d == datetime.date(2015, 10, 12) assert e == decimal.Decimal('0.740100')
def test_before(): """Test that we can fetch the first rate before a missing rate.""" d, e = store.get_rate('EUR', 'GBP', as_of_date=datetime.date(2015, 10, 10), closest_rate=ecbxrate.BEFORE) assert d == datetime.date(2015, 10, 9) assert e == decimal.Decimal('0.740700')
def getcountsum(self, *mpaths): ''' return the sum for all values found in mpath. Eg total number of ordered quantities.''' mpath_for_found_node = mpaths[-1].copy() for key, value in list(mpaths[-1].items()): if value is None: del mpaths[-1][key] count = decimal.Decimal(0) for i in self.getloop(*mpaths): count += i.getdecimal(mpath_for_found_node) return str(count)
def test_historic_rate(): """Test that we can fetch a particular historic rate.""" d, e = store.get_rate('EUR', 'GBP', as_of_date=datetime.date(2015, 1, 8)) assert d == datetime.date(2015, 1, 8) assert e == decimal.Decimal('0.781100') # The closest rate option should have no effect d, e = store.get_rate('EUR', 'GBP', as_of_date=datetime.date(2015, 1, 8), closest_rate=ecbxrate.BEFORE) assert d == datetime.date(2015, 1, 8) assert e == decimal.Decimal('0.781100') d, e = store.get_rate('EUR', 'GBP', as_of_date=datetime.date(2015, 1, 8), closest_rate=ecbxrate.AFTER) assert d == datetime.date(2015, 1, 8) assert e == decimal.Decimal('0.781100')
def _parse_xml(self, xmlfile, days=None): rates = [] date_count = 0 current_date = None max_date = None for event, element in etree.iterparse(xmlfile, events=('start', 'end')): if element.tag != CUBE_TAG: continue if event == 'start' and element.tag == CUBE_TAG: time = element.get('time', None) if time: m = _date_re.match(time) current_date = datetime.date(int(m.group(1)), int(m.group(2)), int(m.group(3))) if max_date is None or max_date < current_date: max_date = current_date if days and date_count + 1 > days: break date_count += 1 if event == 'end' and element.tag == CUBE_TAG: currency = element.get('currency', None) rate = element.get('rate', None) if currency and rate: rate = decimal.Decimal(rate) rates.append({ 'date': current_date, 'currency': currency, 'rate': rate }) return (rates, date_count, max_date)
print( "\n# ======================================================================" ) print("# Factorial") print( "# ======================================================================\n" ) C.getcontext().prec = C.MAX_PREC for n in [100000, 1000000, 10000000, 100000000]: print("n = %d\n" % n) start_calc = time.time() x = factorial(C.Decimal(n), 0) end_calc = time.time() start_conv = time.time() sx = str(x) end_conv = time.time() print("cdecimal:") print("calculation time: %fs" % (end_calc - start_calc)) print("conversion time: %fs\n" % (end_conv - start_conv)) start_calc = time.time() y = factorial(mpz(n), 0) end_calc = time.time() start_conv = time.time() sy = str(y) end_conv = time.time()
propose_decision_fee = 10**5 create_jury_fee = 10**4 jury_vote_fee = 500 reveal_jury_vote_fee = 500 SVD_consensus_fee = 0 buy_shares_fee = 10**5 collect_winnings_reward = 5 * 10**4 # Lower limits on what the "time" tag in a block can say. mmm = 100 # Take the median of this many of the blocks. # How far back in history do we look when we use statistics to guess at # the current blocktime and difficulty. history_length = 400 # This constant is selected such that the 50 most recent blocks count for 1/2 the # total weight. inflection = cdecimal.Decimal('0.985') download_many = 50 # Max number of blocks to request from a peer at the same time. max_download = 58000 #buy_shares_target='0'*4+'1'+'9'*59 buy_shares_target = '0' * 3 + '1' + '9' * 60 blocktime = 60 DB = { 'reward_peers_queue': multiprocessing.Queue(), 'suggested_blocks': multiprocessing.Queue(), 'suggested_txs': multiprocessing.Queue(), 'heart_queue': multiprocessing.Queue(), } #seconds_per_week=604800 #cycle_length=seconds_per_week/blocktime#cycle_length cycle_length = 40 vote_reveal_length = cycle_length / 10
def python_test(num1, num2): x = cdecimal.Decimal(num1) y = cdecimal.Decimal(num2) return x * y
def get_rate(self, from_currency, to_currency, as_of_date=None, closest_rate=False): """Returns the exchange rate pair (date, E), such that to_amount = from_amount * E where to_amount is expressed in to_currency and from_amount in from_currency. If ``as_of_date`` is specified, returns the rate published for the date specified. You can also specify 'today' or 'yesterday' or 'latest' for this parameter. If you specify a date and are happy with the latest rate known prior to that date, you can set ``closest_rate`` to BEFORE. If you need instead the earliest rate known after that date, you can set ``closest_rate`` to AFTER. For backwards compatibility, setting closest_rate to True will have the same effect as BEFORE. If no exchange rate is known for the combination you have specified, this method returns (date, None).""" if as_of_date is None or as_of_date == 'today': as_of_date = datetime.date.today() if as_of_date == 'yesterday': as_of_date = datetime.date.today() - datetime.timedelta(days=1) er1 = exchange_rates.alias() er2 = exchange_rates.alias() if from_currency == 'EUR': from_rate = decimal.Decimal(1) if to_currency == 'EUR': to_rate = decimal.Decimal(1) stmt = None else: stmt = select([er2.c.date.label('date'), er2.c.rate.label('to_rate')]) \ .where(er2.c.currency==to_currency) er = er2 else: if to_currency == 'EUR': to_rate = decimal.Decimal(1) stmt = select([er1.c.date.label('date'), er1.c.rate.label('from_rate')]) \ .where(er1.c.currency==from_currency) er = er1 else: stmt = select([er1.c.date.label('date'), er1.c.rate.label('from_rate'), er2.c.rate.label('to_rate')]) \ .where(and_(er1.c.date==er2.c.date, er1.c.currency==from_currency, er2.c.currency==to_currency)) er = er1 if stmt is not None: if closest_rate == AFTER: stmt = stmt.order_by(er.c.date.asc()) else: stmt = stmt.order_by(er.c.date.desc()) stmt = stmt.limit(1) if as_of_date != 'latest': if closest_rate == True or closest_rate == BEFORE: stmt = stmt.where(er.c.date <= as_of_date) elif closest_rate == AFTER: stmt = stmt.where(er.c.date >= as_of_date) else: stmt = stmt.where(er.c.date == as_of_date) conn = self._connect() try: with conn.begin() as trans: result = conn.execute(stmt).fetchone() if result is None or result == (None, None, None): return (as_of_date, None) if from_currency != 'EUR': from_rate = result['from_rate'] if to_currency != 'EUR': to_rate = result['to_rate'] rate_date = result['date'] finally: self._disconnect() else: rate_date = datetime.date.today() with decimal.localcontext() as ctx: rate = to_rate / from_rate # If we have fewer than 6dp, round to 6dp; if we have more than 6dp # and the number has significant figures to the left of the decimal # point, round to 6dp. Otherwise, round to 6sf. exp = rate.as_tuple().exponent if exp > -6: q = decimal.Decimal('0.000001') rate = rate.quantize(q) elif exp < -6: adj = rate.adjusted() if adj < 0: q = decimal.Decimal((0, [1], adj - 5)) else: q = decimal.Decimal((0, [1], -6)) rate = rate.quantize(q) return (rate_date, rate)
def process_result_value(self, value, dialect): if value is None: return None return decimal.Decimal(value) / 10**6
def test_encodeCDecimal(self): sut = cdecimal.Decimal("1337.1337") encoded = ujson.encode(sut, double_precision=100) decoded = ujson.decode(encoded) self.assertEquals(decoded, 1337.1337)