def encode_to_stream(self, value, out_stream: OutputStream): user_context = decimal.getcontext() decimal.setcontext(self.context) value = value.quantize(self.scale_format) bytes_value = str(value).encode("utf-8") out_stream.write_bytes(bytes_value, len(bytes_value)) decimal.setcontext(user_context)
def start_up() -> None: """Initialize the program. As far as possible: Set up program variables in config.py. Load config files from disk - savelocation.ini, config.ini, config_dynamic.ini. Load datafile from disk - <program name>.dat. """ decimal.setcontext(decimal.BasicContext) config.root_dir, _ = os.path.split(__file__) load_values_from_setup_py() # Get <program name> and version start_logger() # config.root\<program name>.log set_savelocation() # config.root\savelocation.ini points to user data directory load_config_ini() # config.root\config.ini load_config_dynamic_ini() # savelocation_path\config_dynamic_fn # Try to load the data file. If not found it is expected the user will navigate to the # correct location and open the file from the menu. try: control.load_program_data() # savelocation_path\<program name>.dat except FileNotFoundError: config.data = control.Database() # Update version of database data_version = getattr(config.data, 'data_version', None) if data_version != config.data.data_code_version: config.data.version_update(data_version)
def decode_from_stream(self, in_stream: InputStream, length=0): user_context = decimal.getcontext() decimal.setcontext(self.context) value = decimal.Decimal( in_stream.read_bytes().decode("utf-8")).quantize(self.scale_format) decimal.setcontext(user_context) return value
def solve_rpn(equation: str, context=decimal.DefaultContext) -> Decimal: '''Solve an arithmetic problem in Reverse Polish Notation.''' decimal.setcontext(context) stack = [] for unit in re.split(r'\s+', equation.strip()): if number.match(str(unit)): stack.append(Decimal(unit)) elif unit in binary_ops: if (len(stack) < 2): raise RPNError("Too few arguments for operator " "'{}'".format(unit)) num = binary_ops[unit](stack.pop(), stack.pop()) stack.append(num) elif unit in unary_ops: if (len(stack) < 1): raise RPNError("Too few arguments for operator " "'{}'".format(unit)) num = unary_ops[unit](stack.pop()) stack.append(num) else: raise RPNError("Unknown identifier '{}'".format(unit)) else: if (len(stack) > 1): raise RPNError("No remaining operator(s) for numbers " "{}".format(', '.join(map(str, stack)))) return stack[0]
def drops_to_xrp(drops: str) -> Decimal: """ Convert from drops to decimal XRP. Args: drops: String representing indivisible drops of XRP Returns: Decimal representation of the same amount of XRP Raises: TypeError: if ``drops`` not given as a string XRPRangeException: if the given number of drops is invalid """ if type(drops) != str: raise TypeError(f"Drops must be provided as string (got {type(drops)})") drops = drops.strip() setcontext(_DROPS_CONTEXT) if not fullmatch(_DROPS_REGEX, drops): raise XRPRangeException(f"Not a valid amount of drops: '{drops}'") try: drops_d = Decimal(drops) except InvalidOperation: raise XRPRangeException(f"Not a valid amount of drops: '{drops}'") xrp_d = drops_d * ONE_DROP if xrp_d > MAX_XRP: raise XRPRangeException(f"Drops amount {drops} is too large.") return xrp_d
def test_lot_sold(self): """ """ context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) category = MarketCategory.objects.all()[0] now = datetime.datetime.now() now_plus_10 = now + datetime.timedelta(seconds=5) auction = AuctionSession(shop=self.shop, title="Auction Session Nr 1", description="-- no desc --", start=now, end=now_plus_10) auction.save() lot = Lot(shop = self.shop, title = "Coin From Rusia 1901 (PCGS 60)", description = "rare coin", category = category, date_time = now, weight = "5", session=auction, starting_bid=decimal.Decimal("10.00"), reserve=decimal.Decimal("0.00")) lot.save() success = self.client.login(username='******', password='******') self.assertEqual(success, True, "login failed") bidder = User.objects.filter(username="******").get() cart = Cart(shop=self.shop, bidder=bidder) cart.save() #Check that lot is still active... self.assertEqual(lot.is_active(), True , "Failed: The lot should be active!") self.assertEqual(lot.bidhistory_set.all().count(), 0 , "Failed: The lot should not have any bid yet!") my_bid = decimal.Decimal("19.00") response = self.client.get(reverse("bidding_view_lot", args=[lot.id]), {'amount': my_bid}, HTTP_HOST=self.HTTP_HOST) self.assertEqual(response.status_code, 302, "Failed when trying to bid a valid amount $19.00. This value should be allowed...") lot = Lot.objects.get(id=lot.id) self.assertNotEqual(lot.bidhistory_set.all().count(), 0 , "Failed: The lot should have at least one bid!") logging.info("waiting to auction session finish...") while not lot.session.finished(): time.sleep(1) logging.info("Running cron...") cron.minute_update() lot = Lot.objects.get(id=lot.id) self.assertEqual(lot.reserve_has_been_met(), True , "Failed, reserved has not been met!") self.assertEqual(lot.bid_actual.bid_amount, my_bid , "Failed: The bid actual is wrong, is %s but should be %s" % (lot.bid_actual.bid_amount, my_bid)) self.assertEqual(lot.bid_actual.bidder.username, "test" , "Failed, wrong bidder won!") self.assertEqual(lot.is_active(), False, "Failed: The lot state is wrong, should be SOLD but it is %s" % lot.state) self.assertEqual(lot.is_didnt_sell(), False, "Failed: The lot state is wrong, should be SOLD but it is %s" % lot.state) self.assertEqual(lot.is_sold(), True, "Failed: The lot state is wrong, should be SOLD but it is %s" % lot.state)
def best_weight_N_Dwar(opts): sN = opts['sN'] sK = opts['sK'] trade_least = [] from decimal import Decimal from decimal import setcontext from decimal import Context setcontext(Context(prec=10)) items_left = len(sN) if items_left == 1: bN = sN[0] sN.remove(bN) return bN if sN[0] < sK[0] or sN[-1] < sK[-1]: tN = (sK[items_left-1] + sK[items_left-2]) / Decimal(2.0) bN = sN[0] sN.remove(bN) return tN else: bN = sN[items_left - 1] sN.remove(bN) return bN
def render_button(self, cart, request): import decimal context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) url = braintree.TransparentRedirect.url() #TODO: Replace this in production entry_point = request.build_absolute_uri(reverse("braintree_confirm")) amount = cart.total_with_taxes() logging.warn(amount) amount = amount.quantize(decimal.Decimal('.01')) tr_data = braintree.Transaction.tr_data_for_sale({ "transaction": { "type": "sale", "amount": str(amount), # "options": { # "submit_for_settlement": True # } } }, entry_point) html = """ <form action="%s" method="POST"> <input type="hidden" name="tr_data" value="%s" /> <label>Credit Card Number</label><input type="text" name="transaction[credit_card][number]" /><br/> <label>Expiration Date</label><input type="text" name="transaction[credit_card][expiration_date]" /><br/> <label>CVV</label><input type="text" name="transaction[credit_card][cvv]" /><br/> <button class="primaryAction small awesome" type="submit">Pay</button> </form> """ % (url, tr_data) logging.debug("---- BRAINTREE FORM ----- \n%s" % html) return html
def to_bip(value): """ Convert PIPs to BIPs. Use dynamic Decimal precision, depending on value length. Args: value (int|str|Decimal): value in PIP Returns: Decimal """ # Check if value is correct PIP value value = str(value) if not value.isdigit(): raise ValueError(f'{value} is not correct PIP value') # Get default decimal context context = decimal.getcontext() # Set temporary decimal context for calculation decimal.setcontext( decimal.Context(prec=len(value), rounding=decimal.ROUND_DOWN)) # Convert value value = decimal.Decimal(value) / decimal.Decimal(PIP) # Reset decimal context to default decimal.setcontext(context) return value
def float_to_decimal(f): "Convert a floating point number to a Decimal with no loss of information" # Transform (exactly) a float to a mantissa (0.5 <= abs(m) < 1.0) and an # exponent. Double the mantissa until it is an integer. Use the integer # mantissa and exponent to compute an equivalent Decimal. If this cannot # be done exactly, then retry with more precision. try: mantissa, exponent = math.frexp(f) except OverflowError: return decimal.Inf while mantissa != int(mantissa): mantissa *= 2.0 exponent -= 1 mantissa = int(mantissa) oldcontext = decimal.getcontext() decimal.setcontext(decimal.Context(traps=[decimal.Inexact])) try: while True: try: return mantissa * decimal.Decimal(2) ** exponent except decimal.Inexact: decimal.getcontext().prec += 1 finally: decimal.setcontext(oldcontext)
def float2decimal(fval): """ Convert a floating point number to a Decimal with no loss of information """ # Transform (exactly) a float to a mantissa (0.5 <= abs(m) < 1.0) and an # exponent. Double the mantissa until it is an integer. Use the integer # mantissa and exponent to compute an equivalent Decimal. If this cannot # be done exactly, then retry with more precision. # # This routine is from # http://docs.python.org/release/2.5.2/lib/decimal-faq.html mantissa, exponent = math.frexp(fval) try: while mantissa != int(mantissa): mantissa *= 2.0 exponent -= 1 mantissa = int(mantissa) except (OverflowError, ValueError): return "---" oldcontext = decimal.getcontext() decimal.setcontext(decimal.Context(traps=[decimal.Inexact])) try: while True: try: return mantissa * decimal.Decimal(2) ** exponent except decimal.Inexact: decimal.getcontext().prec += 1 finally: decimal.setcontext(oldcontext)
def decode_from_stream(self, in_stream, nested): user_context = decimal.getcontext() decimal.setcontext(self.context) size = in_stream.read_bigendian_int32() value = decimal.Decimal(in_stream.read(size).decode("utf-8")).quantize(self.scale_format) decimal.setcontext(user_context) return value
def float2decimal(fval): """ Convert a floating point number to a Decimal with no loss of information """ # Transform (exactly) a float to a mantissa (0.5 <= abs(m) < 1.0) and an # exponent. Double the mantissa until it is an integer. Use the integer # mantissa and exponent to compute an equivalent Decimal. If this cannot # be done exactly, then retry with more precision. # # This routine is from # http://docs.python.org/release/2.5.2/lib/decimal-faq.html mantissa, exponent = math.frexp(fval) try: while mantissa != int(mantissa): mantissa *= 2.0 exponent -= 1 mantissa = int(mantissa) except (OverflowError, ValueError): return "---" oldcontext = decimal.getcontext() decimal.setcontext(decimal.Context(traps=[decimal.Inexact])) try: while True: try: return mantissa * decimal.Decimal(2)**exponent except decimal.Inexact: decimal.getcontext().prec += 1 finally: decimal.setcontext(oldcontext)
def render_button(self, cart): import decimal context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) url = braintree.TransparentRedirect.url() #TODO: Replace this in production entry_point = "http://%s:8080%s" % (cart.shop.default_dns, reverse("braintree_confirm")) amount = cart.total_with_taxes() logging.warn(amount) amount = amount.quantize(decimal.Decimal('.01')) tr_data = braintree.Transaction.tr_data_for_sale({ "transaction": { "type": "sale", "amount": str(amount), # "options": { # "submit_for_settlement": True # } } }, entry_point) html = """ <form action="%s" method="POST"> <input type="hidden" name="tr_data" value="%s" /> <label>Credit Card Number</label><input type="text" name="transaction[credit_card][number]" /><br/> <label>Expiration Date</label><input type="text" name="transaction[credit_card][expiration_date]" /><br/> <button class="primaryAction small awesome" type="submit">Pay</button> </form> """ % (url, tr_data) logging.debug("---- BRAINTREE FORM ----- \n%s" % html) return html
def convert_value(cls, value, to, prec=33): """ Convert values from/to pip/bip. Args: value (string|int|Decimal|float): value to convert to (string): coin to convert value to prec (int): decimal context precision (decimal number length) Returns: int|Decimal """ # Get default decimal context context = decimal.getcontext() # Set temporary decimal context for calculation decimal.setcontext( decimal.Context(prec=prec, rounding=decimal.ROUND_DOWN)) # PIP in BIP in Decimal default = decimal.Decimal(str(cls.DEFAULT)) # Value in Decimal value = decimal.Decimal(str(value)) # Make conversion if to == 'pip': value = int(value * default) elif to == 'bip': value /= default # Reset decimal context to default decimal.setcontext(context) return value
def _label_scalar(cls, bucket): context = decimal.getcontext() try: decimal.setcontext(ROUND_UP_CONTEXT) return cls._label_scalar_nocontext(bucket=bucket) finally: decimal.setcontext(context)
def invoicer(subtotal=None,context=None): if context is None: decimal.getcontext().rounding='ROUND_HALF_UP' else: decimal.setcontext(context) subtot=getsubtotal(subtotal) contrib=cnpcalc(subtot) dototal(subtot,contrib,vatcalc(subtot,contrib),ritacalc(subtot))
def invoicer(subtotal=None, context=None): if context is None: decimal.getcontext().rounding = 'ROUND_HALF_UP' else: decimal.setcontext(context) subtot = getsubtotal(subtotal) contrib = cnpcalc(subtot) dototal(subtot, contrib, vatcalc(subtot, contrib), ritacalc(subtot))
def unit_fraction_cycle(n): decimal.setcontext( decimal.Context(prec=max_precision, rounding=decimal.ROUND_HALF_DOWN)) val = str(decimal.Decimal(1) / decimal.Decimal(n)) if val and '.' in val: s = val.split('.')[1][:-1] return repeats(s) return ''
def invoicer(subtotal=None, context=None): if context is None: decimal.getcontext().rounding = "ROUND_HALF_UP" # Euro rounding rules else: decimal.setcontext(context) # set to context arg subtot = getsubtotal(subtotal) contrib = cnpcalc(subtot) dototal(subtot, contrib, vatcalc(subtot, contrib), ritacalc(subtot))
def invoicer(subtotal=None, context=None): if context is None: decimal.getcontext().rounding="ROUND_HALF_UP" # Euro rounding rules else: decimal.setcontext(context) # set to context arg subtot = getsubtotal(subtotal) contrib = cnpcalc(subtot) dototal(subtot, contrib, vatcalc(subtot, contrib), ritacalc(subtot))
def encode_to_stream(self, value, out_stream, nested): user_context = decimal.getcontext() decimal.setcontext(self.context) value = value.quantize(self.scale_format) bytes_value = str(value).encode("utf-8") out_stream.write_bigendian_int32(len(bytes_value)) out_stream.write(bytes_value, False) decimal.setcontext(user_context)
def init(): global SCREEN, threshold con = getcontext() con.prec = 800 setcontext(con) threshold = D(0.5) SCREEN = pygame.display.set_mode((WIDTH, HEIGTH))
def phi_approx(self, term): thousand_places = decimal.Decimal(10) ** -999 my_context = decimal.Context(prec = 1000) decimal.setcontext(my_context) phi_approx = str(decimal.Decimal(Fib_Math().nth_term(term) / Fib_Math().nth_term(term - 1)).quantize(thousand_places)) return phi_approx
def calculate_barrett_constant(quotient, modulus=(2**32), wordcount=8): from decimal import getcontext, setcontext, Decimal ctx = getcontext() ctx.prec = 128 setcontext(ctx) return ctx.divide_int(Decimal((modulus**(2 * wordcount))), Decimal(quotient))
def __init__(self, excel_filename, sheet_name="Sheet1", strptime_formats=None): self.filename = excel_filename self.sheet_name = sheet_name self.strptime_formats = strptime_formats or [] decimal.setcontext(decimal.ExtendedContext)
def setDecimalPrecision(self, precision): if self.buffers["rounding"] == 0: rounding = decimal.ROUND_HALF_EVEN if self.buffers["rounding"] == 1: rounding = decimal.ROUND_HALF_UP else: raise ValueError("Rounding must be either 0 or 1.") context = decimal.Context(prec=precision, rounding=rounding) decimal.setcontext(context)
def init_context(): """ Context setup for modules. :return: None """ # ensures all threads use same context decimal.DefaultContext.prec = 9 decimal.DefaultContext.rounding = decimal.ROUND_HALF_UP # >=0.5 rounds away from zero decimal.setcontext(decimal.DefaultContext)
def round_up_or_down(transactions, up=True): """Round the list of transactions passed in. If up=True (default) ronud up, else round down. Return a new list of rounded values """ WHOLE_NUM = Decimal(1) context = Context(rounding=ROUND_UP) if up else Context( rounding=ROUND_DOWN) setcontext(context) return [Decimal(num).quantize(WHOLE_NUM) for num in transactions]
def test_lot_didnt_sell(self): """ Check that a lot get state DIDN'T SELL when there no bidding... """ context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) category = MarketCategory.objects.all()[0] now = datetime.datetime.now() now_plus_10 = now + datetime.timedelta(seconds=5) auction = AuctionSession(shop=self.shop, title="Auction Session Nr 2", description="-- no desc --", start=now, end=now_plus_10) auction.save() lot = Lot(shop = self.shop, title = "Coin From Argentina 1890 (PCGS 60)", description = "rare coin", category = category, date_time = now, weight = "5", session=auction, starting_bid=decimal.Decimal("100.00"), reserve=decimal.Decimal("0.00")) lot.save() success = self.client.login(username='******', password='******') self.assertEqual(success, True, "login failed") #Check that lot is still active... self.assertEqual(lot.is_active(), True , "Failed: The lot should be active!") self.assertEqual(lot.bidhistory_set.all().count(), 0 , "Failed: The lot should not have any bid yet!") my_bid = decimal.Decimal("90.00") response = self.client.get(reverse("bidding_view_lot", args=[lot.id]), {'amount': my_bid}, HTTP_HOST=self.HTTP_HOST) self.assertEqual(response.status_code, 200, "Failed: this bid is not valid...") self.assertEqual(lot.bidhistory_set.all().count(), 0 , "Failed: The lot should not have any bid yet!") logging.info("waiting to auction session finish...") while not lot.session.finished(): time.sleep(1) logging.info("Running cron...") cron.minute_update() lot = Lot.objects.get(id=lot.id) self.assertEqual(lot.reserve_has_been_met(), False , "Failed, the reserved price should not be reached!") self.assertEqual(lot.bid_actual, None , "Failed: There were no bids! ") self.assertEqual(lot.is_active(), False, "Failed: The lot could not be active, the lot finished and there were no bids!") self.assertEqual(lot.is_sold(), False, "Failed: The lot could not be sold, there were no bids!") self.assertEqual(lot.is_didnt_sell(), True, "Failed: The lot wasn't sell!")
def lu_decomposition(A, b): """TODO Arguments: A {[type]} -- [description] b {[type]} -- [description] Returns: [type] -- [description] """ setcontext(Context(traps=[DivisionByZero, Underflow, Overflow])) # Número de linhas e colunas da matriz A n = len(A) # Cria uma matriz L de tamanho nxn e uma matriz U que recebe o conteúdo da matriz A L = [[Decimal(0.0) for _ in range(n)] for _ in range(n)] U = list(map(list, A)) # Faz a fatoração, alterando os valores de L e U for pivot in range(n): L[pivot][pivot] = Decimal(1.0) for row in range(pivot + 1, n): L[row][pivot] = U[row][pivot] / U[pivot][pivot] for column in range(pivot, n): U[row][column] -= L[row][pivot] * U[pivot][column] x = [Decimal(0.0) for i in range(n)] y = [Decimal(0.0) for i in range(n)] # Resolve L . y = b for row in range(n): for column in range(n): if row == column: y[row] += b[row] break y[row] -= L[row][column] * y[column] # Resolve U . x = y for row in range(n - 1, -1, -1): for column in range(n - 1, -1, -1): if row == column: x[row] += y[row] x[row] /= U[row][column] break x[row] -= U[row][column] * x[column] # print() # print([[float(A[i][j]) for j in range(n)] for i in range(n)]) # print([[float(L[i][j]) for j in range(n)] for i in range(n)]) # print([[float(U[i][j]) for j in range(n)] for i in range(n)]) # print([float(a) for a in y]) # print([float(a) for a in x]) return x
def _label_pd(cls, bucket): context = decimal.getcontext() try: decimal.setcontext(ROUND_UP_CONTEXT) buckets = cls._to_series(bucket) labels = buckets.apply(cls._label_scalar) if len(labels) == 0: # Empty Series retains its original dtype after apply. labels = labels.astype(str) return labels finally: decimal.setcontext(context)
def test_quantized(self): self.assertEqual( "12.00", self.us_locale.toString(D("12").quantize(D('0.01'))), msg="12 dollars" ) self.assertEqual( "3,379.70", self.us_locale.toString(D("3379.7").quantize(D('0.01'))) , msg="rubbles" ) self.assertEqual( "636.40", self.us_locale.toString(D("636.4").quantize(D('0.01'))), msg= "cny" ) self.assertEqual( "67.56", self.us_locale.toString(D("67.56")), msg= "GBP" ) self.assertEqual( "103.00", self.us_locale.toString(D("103").quantize(D('0.01'))), msg= "USD" ) self.assertEqual( "1,000,000", self.us_locale.toString(D(10)**6), msg= "1 million" ) context = decimal.getcontext() context.prec = 30 decimal.setcontext(context) self.assertEqual( "0.333,33", self.us_locale.toString((D("1")/3).quantize(D('0.00001'))) , msg= "1/3" ) self.assertEqual( "0.50", self.us_locale.toString(D("1").quantize(D('0.01'))/2), msg= "1/2" )
def test_lot_still_active(self): """ Check that nothing happend to those lots that aren't finished yet when cron is executed """ context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) category = MarketCategory.objects.all()[0] now = datetime.datetime.now() now_plus_10 = now + datetime.timedelta(seconds=5) auction = AuctionSession(shop=self.shop, title="Auction Session Nr 4", description="-- no desc --", start=now, end=now_plus_10) auction.save() lot = Lot(shop=self.shop, title="Coin From USA 1905 (PCGS 50)", description="rare coin", category=category, date_time=now, weight="5", session=auction, starting_bid=decimal.Decimal("100.00"), reserve=decimal.Decimal("300.00")) lot.save() success = self.client.login(username='******', password='******') self.assertEqual(success, True, "login failed") my_bid = decimal.Decimal("120.00") response = self.client.get(reverse("bidding_view_lot", args=[lot.id]), {'amount': my_bid}, HTTP_HOST=self.HTTP_HOST) self.assertEqual(response.status_code, 302, "Failed when trying to bid a valid amount %s. This value should be allowed..." % my_bid) lot = Lot.objects.get(id=lot.id) self.assertEqual(lot.bidhistory_set.all().count(), 1 , "Failed: The lot should not have any bid yet!") logging.info("don't wait for auction session to finish...") #Check that lot is still active... lot = Lot.objects.get(id=lot.id) self.assertEqual(lot.is_active(), True , "Failed: The lot should be active!") logging.info("Running cron...") cron.minute_update() lot = Lot.objects.get(id=lot.id) self.assertEqual(lot.is_active(), True , "Failed: The lot should be active!") self.assertEqual(lot.bid_actual.bid_amount, my_bid, "Failed: The bid actual is wrong, is %s but should be %s" % (lot.bid_actual.bid_amount, my_bid)) self.assertEqual(lot.bid_actual.bidder.username, "test" , "Failed, wrong bidder won!") self.assertEqual(lot.is_sold(), False, "Failed: The lot state is wrong, should be ACTIVE but it is %s" % lot.state)
def to_significant(self, sig_digits: int, format, rounding=ROUND_HALF_UP) -> Decimal: assert isinstance(sig_digits, int) assert sig_digits > 0, "significant digits must be positive" context = Context(prec=sig_digits + 1, rounding=rounding) setcontext(context) quotient = Decimal(self.numerator) / Decimal(self.denominator) sig_digits = quotient.quantize() return sig_digits
def test_init_invalid_rate(self, *args, **kwargs): """ Test Account.__init__ with invalid rate input. """ decimal.setcontext(decimal.BasicContext) with self.assertRaises(decimal.InvalidOperation): account = self.AccountType(self.owner, *args, balance=0, rate="invalid input", **kwargs) # `rate` is not callable if we use non-callable input # pylint: disable=comparison-with-callable if account.rate == Decimal("NaN"): raise decimal.InvalidOperation()
def calculate_price(base_quantity, quote_quantity, base_divisibility, quote_divisibility, order_type=None): if not base_divisibility: base_quantity *= config.UNIT if not quote_divisibility: quote_quantity *= config.UNIT try: if order_type == 'BUY': decimal.setcontext( decimal.Context(prec=8, rounding=decimal.ROUND_DOWN)) elif order_type == 'SELL': decimal.setcontext( decimal.Context(prec=8, rounding=decimal.ROUND_UP)) price = format(D(quote_quantity) / D(base_quantity), '.8f') decimal.setcontext( decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) return price except Exception as e: logging.exception(e) decimal.setcontext( decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) raise (e)
def run_tests(filename): nextline = give_nextline(filename) TESTS = int(next(nextline)) from decimal import Decimal from decimal import setcontext from decimal import Context setcontext(Context(prec=10)) for it in range(1, TESTS + 1): C, F, X = map(Decimal, next(nextline).split(' ')) print('Case #' + str(it) + ': ' + str(time_for_cookies(C, F, X))) return
def test_decimal_american_english(self): TESTINPUT=0 EXPECTED=1 context = decimal.getcontext() context.prec = 8+7 decimal.setcontext(context) tests = ( (D("43112279.75467"), "43,112,279.754,67"), (D("0.0101020204"), "0.010,102,020,4"), (D("0.00000001"), "0.000,000,01") ) verbose = False for c in tests: self.assertEqual( str(c[1]), self.us_locale.toString(c[0]), msg="Test case %s" % c[1] ) self.assertEqual( (c[0], True), self.us_locale.toDecimal(c[1], 10), msg="Test case US locale parsing %s" % c[1] )
def format_price(value, currency_symbol): context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) if currency_symbol is None: currency_symbol = '$$' if currency_symbol == 'USD': currency_symbol = '$' try: value = decimal.Decimal(str(value)) except Exception, e: logging.critical("could not convert value %s to decimal" % value) return value
def problem26(): decimalLength = 10000 decimal.setcontext(decimal.Context(prec=decimalLength)) limit = 1001 longestRecurring = 0 longestIndex = 0 for i in range(1, limit + 1): fraction = int( decimal.Decimal(1.0) / decimal.Decimal(i) * 10**decimalLength) if (IsReciprocal(fraction) > longestRecurring): longestRecurring = IsReciprocal(fraction) print(longestRecurring) longestIndex = i print(longestIndex)
def sum(values): ''' Sum up list of numeric strings. Return Decimal value. Args: values -- list of strings ''' # context set globally for all Decimal arithmetic, not just for this instance of method setcontext( Context( prec=None, rounding=None ) ) # used in calculation of average and when rounding_method is round.max sum = Decimal('0') for value in values: sum += Decimal(value) return(sum)
def format_price(value, currency_symbol): context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) if currency_symbol is None: currency_symbol = '$$' if currency_symbol == 'USD': currency_symbol = '$' try: value = decimal.Decimal(str(value)) except Exception,e: logging.critical("could not convert value %s to decimal" % value) return value
def step_gradient(k1_current, k2_current, points, learningRate): # gmpy2.set_context(gmpy2.context(precision=10)) decimal.setcontext(decimal.Context(prec=10)) k1_gradient = decimal.Decimal(0.0) k2_gradient = decimal.Decimal(0.0) N = decimal.Decimal( float(len(points)) ) for i in range(0, len(points)): x = decimal.Decimal( points[i, 0] ) y = decimal.Decimal( points[i, 1] ) y_hat = decimal.Decimal( k1_current * x + k2_current * (x**2) ) k1_gradient += decimal.Decimal( -(2/N) * (y - y_hat) * (x) ) k2_gradient += decimal.Decimal( -(2/N) * (y - y_hat) * (x ** 2) ) new_k1 = k1_current - (learningRate * k1_gradient) new_k2 = k2_current - (learningRate * k2_gradient) return [new_k1, new_k2, k1_gradient, k2_gradient]
def money_format2(value, shop): context = decimal.Context(prec=20, rounding=decimal.ROUND_HALF_DOWN) decimal.setcontext(context) currency_symbol = shop.preference().checkout_currency if currency_symbol is None: currency_symbol = '$$' if currency_symbol == 'USD': currency_symbol = '$' try: value = decimal.Decimal(value) except Exception,e: logging.critical("could not convert value %s to decimal" % value) return "%s %s" % (currency_symbol, value)
def clean(self): cleaned_data = super(AdminBlockAttributeForm, self).clean() if cleaned_data['key'] == 'points': try: cont = decimal.Context(prec=28, rounding=decimal.ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[decimal.Overflow, decimal.InvalidOperation, decimal.Inexact]) decimal.setcontext(cont) decimal.getcontext().clear_flags() points = decimal.Decimal(cleaned_data['value']).quantize(decimal.Decimal('0.01')) #constraints given from marking model Decimal field if points>= decimal.Decimal('1000000'): raise ValueError('points too large') except (decimal.Inexact, decimal.Overflow, decimal.InvalidOperation, ValueError) as e: msg = "'points' can only have 2 decimal places and need to be smaller than 1000000 . (e.g. 1.25)" self.add_error('value', msg) return cleaned_data
def enough_decimal_precision(digits=len(str(2 ** 256))): """ By default, Python stores ``Decimal()`` objects to 28 places. This isn't enough for the 256-bit numbers we deal with when calculating difficulty, so we provide a context manager to wrap code that needs more precision. """ orig_context = decimal.getcontext() if orig_context.prec < digits: new_context = orig_context.copy() new_context.prec = digits decimal.setcontext(new_context) yield decimal.setcontext(orig_context)
def round(sum, average, rounding_method): ''' Return average that has been rounded Use sum and rounding_method to determine appropriate level of precision. If the number of sigfigs of of sum is GREATER THAN the sigfigs that average has, do nothing. R/QTL will pad average value with zeroes so that all values in a column have same precision. Using Rounding_method.MAX results in using the rounding rules of python's decimal.ROUND_HALF_EVEN: Given value xy..., suppose x is a significant digit and y and z are not significant. ROUND_HALF_EVEN rounds x down if y ∈ {0,1,2,3,4} else if y == 5 and x is an even digit (i.e. x ∈ {0,2,4,6,8}) and all digits after y are 0 or not present at all ROUND_HALF_EVEN rounds x up if y ∈ {6,7,8,9} else if y == 5 and ( x is an odd digit (i.e. x ∈ {1,3,5,7,9}) or there exists at least one non-zero digit after y ) Therefore, for Rounding_method.MAX, the values will be biased towards being too high. However, since this MAX keeps more digits than significant anyway, it is unlikely for the true value to be affected significantly. Args: sum -- Decimal value average -- Decimal value rounding_method -- one of Rounding_method values ''' # access global var. rounding_method set by user average_rounded = average # default is to do no rounding if Rounding_method.MAX is rounding_method: num_sigfigs = Significant_value.num_significant_digits(str(sum)) setcontext(Context(prec=num_sigfigs, rounding=ROUND_HALF_EVEN)) average_rounded = +average return(average_rounded)
def assertDecimalEqual(self, exp, result, msg=None): """ @param exp: @type exp: D @param result: @type result: @return: @rtype: """ old_ctx = getcontext() setcontext(self.ctx) # unary plus forces re-calculation of # digits exp = +exp result = +result not_equal = exp.compare(result) setcontext(old_ctx) if not_equal: raise self.failureException((msg or '') + str(exp) + ' ' + str(result))
def _to_type(self,value): if self.__decimal_use_local_context__: with localcontext(self.__decimal_local_context_class__) as ctx: self._set_ctx_vars(ctx) value = self.to_type( value, ctx ) else: ctx = getcontext() self._set_ctx_vars(ctx) value = self.to_type( value, ctx ) setcontext(ctx) return value
def calculate_price(base_quantity, quote_quantity, base_divisibility, quote_divisibility, order_type = None): if not base_divisibility: base_quantity *= config.UNIT if not quote_divisibility: quote_quantity *= config.UNIT try: if order_type == 'BUY': decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_DOWN)) elif order_type == 'SELL': decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_UP)) price = format(D(quote_quantity) / D(base_quantity), '.8f') decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) return price except Exception, e: decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) return '0'
from decimal import Decimal, setcontext, ExtendedContext setcontext(ExtendedContext) precision = Decimal('0.000001') class LocationStore(object): def __init__(self): self.locations = {} def add(self, latitude, longitude, name, url=None, primary=False): latitude = makedecimal(latitude).quantize(precision).normalize() longitude = makedecimal(longitude).quantize(precision).normalize() for location, data in self.locations.iteritems(): (other_lat, other_lon) = location if latitude == other_lat and longitude == other_lon: if url is not None: data['url'] = url if primary is True: data['primary'] = True break else: #new location self.locations[(latitude, longitude)] = {'name': name, 'primary': primary} if url is not None: self.locations[(latitude, longitude)]['url'] = url def to_list(self): out = []
from __future__ import division import os, sys, math import matplotlib.pyplot as plt import numpy as np import decimal decimal.setcontext(decimal.Context(prec=34)) class data_item(): def __init__(self, id, decisions, objective): self.id = id self.decisions = decisions self.objective = objective def __repr__(self): return str(self.id)+ "|" +",".join(map(str, self.decisions)) + "|" + str(self.objective) def euclidean_distance(list1, list2): assert(len(list1) == len(list2)), "The points don't have the same dimension" distance = sum([(i - j) ** 2 for i, j in zip(list1, list2)]) ** 0.5 assert(distance >= 0), "Distance can't be less than 0" return distance def similarity(list1, list2): """higher score indicates they are very different""" same = 0 diff = 0 for a, b in zip(list1, list2): if a != b: diff += 1
from datetime import datetime import logging import decimal import base64 import json import time from lib import config, util decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) D = decimal.Decimal def calculate_price(base_quantity, quote_quantity, base_divisibility, quote_divisibility, order_type = None): if not base_divisibility: base_quantity *= config.UNIT if not quote_divisibility: quote_quantity *= config.UNIT try: if order_type == 'BUY': decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_DOWN)) elif order_type == 'SELL': decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_UP)) price = format(D(quote_quantity) / D(base_quantity), '.8f') decimal.setcontext(decimal.Context(prec=8, rounding=decimal.ROUND_HALF_EVEN)) return price except Exception, e:
#!python3 """ Output a massive list of mathematical expressions that produce the desired output. """ import decimal import sys # Automatically take care of divisions by zero etc decimal.setcontext(decimal.ExtendedContext) class Expression(object): __slots__= ['left', 'right'] def __init__(self, left, right): self.left = left self.right = right class Number(Expression): __slots__= ['value'] def __init__(self, value): self.value = decimal.Decimal(value) def evaluate(self): return self.value def __str__(self): return str(self.value) class Addition(Expression):
import decimal decimal.DefaultContext.rounding = decimal.ROUND_DOWN decimal.DefaultContext.traps = decimal.ExtendedContext.traps.copy() decimal.DefaultContext.traps[decimal.InvalidOperation] = 1 decimal.setcontext(decimal.DefaultContext) DECIMAL_PRECISION = decimal.Decimal(10) ** -8 def quantize(decimal_value): return decimal_value.quantize(DECIMAL_PRECISION)
def step_gradient(k1_current, k2_current, k3_current, points, learningRate): decimal.setcontext(decimal.Context(prec=10)) k1_gradient = decimal.Decimal(0.0) k2_gradient = decimal.Decimal(0.0) k3_gradient = decimal.Decimal(0.0) N = decimal.Decimal( float(len(points)) ) for i in range(0, len(points)): x = decimal.Decimal( points[i, 0] ) y = decimal.Decimal( points[i, 1] ) try: common_part_1 = -(2/N) * (y - (k1_current + k2_current * x) ** k3_current) except Exception as e: print('Exception #1') print('(y - (k1_current + k2_current * x)) : ', (y - (k1_current + k2_current * x))) print('k3_current : ', k3_current) try: common_part_2 = (k3_current * (k1_current + k2_current * x) ** (k3_current - 1)) except Exception as e: print('Exception #2') print('x : ', x) print('k3_current - 1 : ', (k3_current - 1)) print('k3_current * (k1_current + k2_current * x) : ', (k3_current * (k1_current + k2_current * x))) try: common_part_3 = decimal.Decimal.ln( k1_current + k2_current * x) except Exception as e: print('Exception #3') print('x : ', x) print('k1_current + k2_current * x : ', (k1_current + k2_current * x)) try: common_part_4 = (k1_current + k2_current * x) ** k3_current except Exception as e: print('Exception #4') print('x : ', x) print('k3_current : ', k3_current) print('k1_current + k2_current * x : ', (k1_current + k2_current * x)) # common_part_1 = -(2/N) * (y - (k1_current + k2_current * x) ** k3_current) # common_part_2 = (k3_current * (k1_current + k2_current * x) ** (k3_current - 1)) # common_part_3 = decimal.Decimal.ln( k1_current + k2_current * x) # common_part_4 = (k1_current + k2_current * x) ** k3_current k1_gradient += common_part_1 * common_part_2 k2_gradient += common_part_1 * common_part_2 * x k3_gradient += common_part_1 * common_part_3 * common_part_4 # k1_gradient += -(2/N) * (y - (k1_current + k2_current * x) ** k3_current) * (k3_current * (k1_current + k2_current * x) ** (k3_current - 1)) # k2_gradient += -(2/N) * (y - (k1_current + k2_current * x) ** k3_current) * (k3_current * (k1_current + k2_current * x) ** (k3_current - 1)) * x # k3_gradient += -(2/N) * (y - (k1_current + k2_current * x) ** k3_current) * np.log(k1_current + k2_current * x) * (k1_current + k2_current * x) ** k3_current if(dc.is_nan(k1_gradient) or dc.is_nan(k2_gradient) or dc.is_nan(k1_gradient) or dc.is_infinite(k1_gradient) or dc.is_infinite(k2_gradient) or dc.is_infinite(k1_gradient)): print(' i=', i) print(' x = ', x, ', y = ', y) print(' comPart_2_1 = ', (k3_current * (k1_current + k2_current * x))) print(' comPart_2_2 = ', (k3_current - 1)) print(' comPart_2_3 = ', k3_current * (k1_current + k2_current * x) ** (k3_current - 1)) print(' k1_cur=', k1_current, ' k2_cur=', k2_current, ' k3_cur=', k3_current) print(' common_part_1 = ', common_part_1) print(' common_part_2 = ', common_part_2) print(' common_part_3 = ', common_part_3) print(' k1_gradient = ', k1_gradient) print(' k2_gradient = ', k2_gradient) print(' k3_gradient = ', k3_gradient, '\n') k1_gradient = 1001.0 break new_k1 = k1_current - (learningRate * k1_gradient) new_k2 = k2_current - (learningRate * k2_gradient) new_k3 = k3_current - (learningRate * k3_gradient) return [new_k1, new_k2, new_k3, k1_gradient, k2_gradient, k3_gradient]
:synopsis: Main GUI program .. requires decimal .. Created on Fri Mar 29 14:58:02 2013 .. codeauthor:: Rod Persky <rodney.persky {removethis} AT gmail _DOT_ com> .. Licensed under the Academic Free License ("AFL") v. 3.0 .. Source at https://github.com/Rod-Persky/pyIGES """ import decimal this_context = decimal.BasicContext this_context.prec = 8 decimal.setcontext(this_context) def format_line(data, section): """concatinate data chuncks and add section marker and line counter :param data: list of values :type data: list :param section: letter for the corresponding IGES section :type section: string """ out = "" for i in range(0, len(data)):
def run(self): c = decimal.getcontext().copy() c.prec = self.prec decimal.setcontext(c) self.q.put((self.prec, a * b)) return