def evaluate(self, context=None): item = self.get_argument(context) if item is None: return elif isinstance(item, float) and (math.isnan(item) or math.isinf(item)): return item elif not isinstance(item, (float, int, Decimal)): code = 'XPTY0004' if isinstance(item, str) else 'FORG0006' raise self.error(code, "invalid argument type {!r}".format(type(item))) precision = 0 if len(self) < 2 else self[1].evaluate(context) try: if isinstance(item, int): return round(item, precision) elif isinstance(item, Decimal): return round(item, precision) elif isinstance(item, Float10): return Float10(round(item, precision)) return float(round(Decimal.from_float(item), precision)) except TypeError as err: raise self.error('XPTY0004', err) except (DecimalException, OverflowError): if isinstance(item, Decimal): return Decimal.from_float(round(float(item), precision)) return round(item, precision)
def test_floats_in_tiny_interval_within_bounds(xlo, xhi, data, center): assume(not (math.isinf(next_down(center)) or math.isinf(next_up(center)))) lo = Decimal.from_float(next_down(center)).next_plus() hi = Decimal.from_float(next_up(center)).next_minus() assert float(lo) < lo < center < hi < float(hi) val = data.draw(st.floats(lo, hi, exclude_min=xlo, exclude_max=xhi)) assert lo < val < hi
def market_and_business_value_updater(): # Update every market row in DB for market in Market.objects.all(): # Freeze market if no one owns any of its businesses if market.num_businesses == 0: market.started = False market.save() # If someone has bought one of the businesses if market.started == True: # Set range of change depending on volatility and growth rate low = float(Decimal.from_float(-.1)*market.volatility) high = float(market.growth_rate*market.volatility) # Randomly generate the market change change = Decimal.from_float(random.uniform(low, high)) market.current_multiplier += change # print(f"Market = {market.name}, Change = {change}, Market_multiplier = {market.current_multiplier} Num businesses = {market.num_businesses}") # Save new current_multiplier to market in DB market.save() # Update all business values in DB for business in market.businesses.all(): business.value = business.base_value*market.current_multiplier business.save()
def test_floats_in_tiny_interval_within_bounds(data, center): assume(not (math.isinf(next_down(center)) or math.isinf(next_up(center)))) lo = Decimal.from_float(next_down(center)).next_plus() hi = Decimal.from_float(next_up(center)).next_minus() assert float(lo) < lo < center < hi < float(hi) val = data.draw(st.floats(lo, hi)) assert lo < val < hi
def test_lossy_serialization_warning(caplog): caplog.set_level(logging.WARNING, logger="great_expectations.core") d = ( Decimal(7091.17117297555159893818) ** Decimal(2) + Decimal(7118.70008070942458289210) ** Decimal(2) + (Decimal(-1513.67274389594149397453)) ** Decimal(2) ) ** Decimal(1.5) f_1 = ( 7091.17117297555159893818 ** 2 + 7118.70008070942458289210 ** 2 + (-1513.67274389594149397453) ** 2 ) ** 1.5 f_2 = float(d) assert not (-1e-55 < Decimal.from_float(f_1) - d < 1e-55) assert not (-1e-55 < Decimal.from_float(f_2) - d < 1e-55) convert_to_json_serializable(d) assert len(caplog.messages) == 1 assert caplog.messages[0].startswith("Using lossy conversion for decimal") caplog.clear() d = Decimal(0.1) f_1 = 0.1 f_2 = float(d) assert -1e-55 < Decimal.from_float(f_1) - d < 1e-55 assert -1e-55 < Decimal.from_float(f_2) - d < 1e-55 convert_to_json_serializable(d) assert len(caplog.messages) == 0
def excel_scan_teams(teams: list, season: str): # 201 start = time.time() number = 0 sheet_line = 0 while True: while number < len(teams): teamloop = teams[number] # ['sheet_%d' % sheetnb].write = book.add_sheet(teamloop, cell_overwrite_ok= True) print('') print(teamloop) print('') number += 1 sheet_line += 1 json_dict = vexdb_json("rankings", { "team": teamloop, "season": season }) output = [] for r in json_dict["result"]: line = 'Team = {} Wins = {} Losses = {} AP = {} Ranking in Current Match = {} Highest Score = {}' \ .format(r["team"], r["wins"], r["losses"], r["ap"], r["rank"], r["max_score"]) datateam = '{}'.format(r["team"]) datawins = '{}'.format(r["wins"]) datalosses = '{}'.format(r["losses"]) dataap = '{}'.format(r["ap"]) datarank = '{}'.format(r["rank"]) datamaxscore = '{}'.format(r["max_score"]) if int(datawins) > int(datalosses): sheet2.write(sheet_line, 6, "Positive", STYLE_RED) elif int(datawins) < int(datalosses): sheet2.write(sheet_line, 6, "Negative", STYLE_BLUE) output.append(line) sheet2.write(sheet_line, 0, datateam) sheet2.write(sheet_line, 1, datawins) sheet2.write(sheet_line, 2, datalosses) sheet2.write(sheet_line, 3, dataap) sheet2.write(sheet_line, 4, datarank) sheet2.write(sheet_line, 5, datamaxscore) sheet_line += 1 book.save("Data.xls") print('') decimal = (time.time() - start) decimal = Decimal.from_float(decimal).quantize(Decimal('0.0')) ave = (float(decimal) / (int(number))) ave = Decimal.from_float(ave).quantize(Decimal('0.0')) eta = (float(ave) * (int(len(teams) - (int(number))))) etatomin = (float(eta) / 60) etatomin = Decimal.from_float(etatomin).quantize(Decimal('0.0')) print( str(number) + "/" + str(len(teams)) + " Finished, Used " + str(decimal) + " seconds. Average " + str(ave) + " seconds each. ETA: " + str(etatomin) + " mins.") if number >= 5: number = 0 sheet_line = 1 print('\n reset and xls saved!') main()
def TranslateToDecimal(amount): '''金额的float类型转换为保留两位小数的Decimal类型,用于准确计算''' try: return Decimal.from_float(amount).quantize(Decimal('0.00')) except TypeError: if isinstance(amount, Decimal): return Decimal.from_float(float(amount)).quantize( Decimal('0.00'))
def get(self, request): p2pproducts = P2PProduct.objects.filter(hide=False).filter(status=u'正在招标') p2p_list = [] repaymentType = '' for p2p in p2pproducts: # 计算进度 amount = Decimal.from_float(p2p.total_amount).quantize(Decimal('0.00')) percent = p2p.ordered_amount / amount * 100 schedule = '{}%'.format(percent.quantize(Decimal('0.0'), 'ROUND_DOWN')) for pay_method, value in WANGDAI: if p2p.pay_method == u'日计息一次性还本付息': repaymentType = 1 break if p2p.pay_method == u'日计息月付息到期还本': repaymentType = 5 break if p2p.pay_method == u'先息后本': repaymentType = 9 break if pay_method == p2p.pay_method: repaymentType = value break p2pequities = p2p.equities.all() subscribes = [{ "subscribeUserName": eq.user.username, "amount": Decimal.from_float(eq.equity).quantize(Decimal('0.00')), "validAmount": Decimal.from_float(eq.equity).quantize(Decimal('0.00')), "addDate": timezone.localtime(eq.created_at).strftime("%Y-%m-%d %H:%M:%S"), "status": "1", "type": "0" } for eq in p2pequities] reward = (p2p.activity.rule.rule_amount * 100).quantize(Decimal('0.0')) if p2p.activity else 0 temp_p2p = { "projectId": str(p2p.pk), "title": p2p.name, "amount": amount, "schedule": schedule, "interestRate": '{}%'.format(Decimal.from_float(p2p.expected_earning_rate).quantize(Decimal('0.0'))+reward), "deadline": str(p2p.period), "deadlineUnit": u"月", "reward": '{}%'.format(0),#'{}%'.format(reward), "type": u"信用标" if p2p.category == u'证大速贷'else u"抵押标", "repaymentType": str(repaymentType), "subscribes": subscribes, "userName": md5(p2p.borrower_bankcard_bank_name.encode('utf-8')).hexdigest(), "amountUsedDesc": strip_tags(p2p.short_usage), "loanUrl": "https://{}/p2p/detail/{}".format(request.get_host(), p2p.id), "publishTime": timezone.localtime(p2p.publish_time).strftime("%Y-%m-%d %H:%M:%S") } p2p_list.append(temp_p2p) return HttpResponse(renderers.JSONRenderer().render(p2p_list, 'application/json'))
def get_ws_wq(df_document_cut): stay_time_cut = df_document_cut['finish'] - df_document_cut[ 'come'] #得到逗留时间队列 wait_time_cut = df_document_cut['wait'] #得到等待时间队列 ws_cut = np.mean(stay_time_cut) #平均逗留时间 wq_cut = np.mean(wait_time_cut) #平均排队等待时间 ws_cut = Decimal.from_float(ws_cut).quantize(Decimal('0.0000')) wq_cut = Decimal.from_float(wq_cut).quantize(Decimal('0.0000')) return ws_cut, wq_cut
def _format_ohlc(result): return OHLC( result[0], Decimal.from_float(result[1]), Decimal.from_float(result[3]), Decimal.from_float(result[4]), Decimal.from_float(result[2]), Decimal.from_float(result[5]), )
def func_sin(x, n): sin_aprox = 0 coefs=[] for i in range(n): coef = (-1)**i num = x**(2*i+1) denom = math.factorial(2*i+1) sin_aprox += (Decimal.from_float(coef)) * ( Decimal.from_float((num))/Decimal.from_float((denom))) coefs.append(sin_aprox) return (sin_aprox,coefs)
def getItemdetails(buyer_state, seller_state, item, item_tax_amount): if (buyer_state != seller_state): item_details = Item_details.objects.create( igst_tax_percentage=item.tax_percentage, igst_amt=item_tax_amount) else: item_details = Item_details.objects.create( sgst_tax_percentage=Decimal.from_float(item.tax_percentage / 2), cgst_tax_percentage=Decimal.from_float(item.tax_percentage / 2), sgst_amt=Decimal(item_tax_amount / 2), cgst_amt=Decimal(item_tax_amount / 2)) return item_details
def test_saving_and_retrieving_items(self): create_two_agereements_with_periods() periods = Period.objects.all() self.assertEqual(periods.count(), 2) self.assertEqual(periods[0].start_date, date.today()) self.assertEqual(periods[0].end_date, date(date.today().year+1, date.today().month, date.today().day)) self.assertAlmostEqual(periods[0].agreement.credit_turnover, Decimal.from_float(1111.11), places=5) self.assertEqual(periods[1].start_date, date(date.today().year+1, date.today().month, date.today().day)) self.assertEqual(periods[1].end_date, date(date.today().year+4, date.today().month, date.today().day)) self.assertAlmostEqual(periods[1].agreement.credit_turnover, Decimal.from_float(5678.11), places=5)
def clean_uah_rate(self): """ Validation function to allow users enter rate with ',' instead of '.' """ data = self.cleaned_data['uah_rate'] if ',' in data: data = data.replace(',', '.') try: data = float(data) if data <= 0: raise ValidationError("Should be a number greater than 0") Decimal.from_float(data) except ValueError: raise ValidationError("Should be a number") return data
def string_to_decimal(cls, value): if value is None: return None value = value.replace(',', '') if not len(value): return Decimal.from_float(0.0) try: return parse_decimal(value) except Exception: return Decimal.from_float(0.0)
def buy_coins(): symbol = "DOGE" + BUY_WITH avg_market_price = binance_client.get_avg_price(symbol=symbol) quan = max_spending / float(avg_market_price["price"]) sym_info = binance_client.get_symbol_info(symbol) lotSizeFilter = next(item for item in sym_info["filters"] if item["filterType"] == "LOT_SIZE") #corrected_Quantity = math.floor(quan / float(lotSizeFilter["stepSize"])) * float(lotSizeFilter["stepSize"]) corrected_Quantity = float( D.from_float(quan).quantize( D(str(lotSizeFilter["stepSize"]).rstrip("0")))) try: order = binance_client.create_order(symbol=symbol, side=Client.SIDE_BUY, type=Client.ORDER_TYPE_MARKET, quantity=corrected_Quantity) avg_price = avg_market_price["price"] print( f"Bought {corrected_Quantity} {symbol} (avg market pric was {avg_price}), fills:" ) for fill in order["fills"]: qty = fill["qty"] price_fill = fill["price"] print(f"Qty: {qty}, Price: {price_fill}") # placing sell order sell_price = float(order["fills"][0]["price"]) * sell_price_mutiplier priceFilter = next(item for item in sym_info["filters"] if item["filterType"] == "PRICE_FILTER") sell_price_filtered = float( D.from_float(sell_price).quantize( D(priceFilter["tickSize"].rstrip("0")))) print(f"Placing sell order at avg price: : {sell_price_filtered}") sell_order = binance_client.order_limit_sell( symbol=symbol, quantity=corrected_Quantity, price=sell_price_filtered) print(f"Placed sell order at avg price: {sell_price_filtered}") except BinanceAPIException as e: print(e) except BinanceOrderException as e: print(e)
def update_revenue_estimate(self): if self.ce_model_id: qty = self.quantity if not isinstance(qty, Decimal): qty = Decimal.from_float(qty) if not self.ce_unit_revenue_estimate: raise ValidationError( 'Must provide unit sales price estimate.') uc = self.ce_unit_revenue_estimate if not isinstance(uc, Decimal): uc = Decimal.from_float(uc) self.ce_revenue_estimate = uc * qty
def __init__(self, api, steps, stop, *args, **kwargs): super().__init__(api, *args, **kwargs) logger = getLogger(__name__) self.orders = [] self.pending_order = None self.pivot = -1 self.steps = steps self.stop = Decimal.from_float(stop) self.correction = Decimal.from_float(0.5) logger.info('ladder strategy started with steps={}, stop={}'.format( self.steps, self.stop))
def get(self, request): now = time.mktime(datetime.datetime.now().timetuple()) project_list = [] result = { 'timestamp': now, 'project_list': project_list } p2pproducts = P2PProduct.objects.select_related('warrant_company', 'activity').filter(hide=False).filter( status=u'正在招标').order_by('-priority')[0:5] for p2pproduct in p2pproducts: rate_vip = p2pproduct.activity.rule.rule_amount * 100 if p2pproduct.activity else 0 rate_total = Decimal.from_float(p2pproduct.expected_earning_rate) + rate_vip income = 10000 * rate_total * Decimal(p2pproduct.period) / (12 * 100) income = float(income.quantize(Decimal('0.00'))) # 进度 amount = Decimal.from_float(p2pproduct.total_amount).quantize(Decimal('0.00')) percent = (p2pproduct.ordered_amount / amount) * 100 percent = percent.quantize(Decimal('0.00')) obj = { 'id': p2pproduct.id, 'title': p2pproduct.name, #'title_url': 'https://{}/p2p/detail/{}'.format(request.get_host(), p2pproduct.id), 'title_url': 'https://www.wanglibao.com/activity/xunlei_setp/?promo_token=xunlei9', 'rate_year': p2pproduct.expected_earning_rate, 'rate_vip': float(rate_vip), 'income': income, 'finance': float(p2pproduct.total_amount), 'min_invest': float(100.00), 'guarantor': p2pproduct.warrant_company.name, 'finance_progress': float(percent), 'finance_left': float(p2pproduct.remain), 'repayment_period': p2pproduct.period * 30, 'repayment_type': XUNLEI_PAY_WAY.get(p2pproduct.pay_method, 0), #'buy_url': 'https://{}/p2p/detail/{}?promo_token=xunlei'.format(request.get_host(), p2pproduct.id), #'buy_url': 'https://www.wanglibao.com/activity/xunleidenglu/?promo_token=xunlei9', 'buy_url': 'https://www.wanglibao.com/activity/xunlei_setp/?promo_token=xunlei9', 'finance_start_time': time.mktime(timezone.localtime(p2pproduct.publish_time).timetuple()), 'finance_end_time': time.mktime(timezone.localtime(p2pproduct.end_time).timetuple()), 'status': p2pproduct.status } project_list.append(obj) result.update(project_list=project_list) return HttpResponse(renderers.JSONRenderer().render(result, 'application/json'))
def _to_decimal(amount): if isinstance(amount, Decimal): return amount elif isinstance(amount, float): return Decimal.from_float(amount) else: return Decimal(amount)
class Product(models.Model): DISCOUNT_RATE = Decimal.from_float(0.10) id = models.AutoField(primary_key=True) name = models.CharField(max_length=200) description = models.TextField() price = models.DecimalField(max_digits=5, decimal_places=2) sale_start = models.DateTimeField(blank=True, null=True, default=None) sale_end = models.DateTimeField(blank=True, null=True, default=None) photo = models.ImageField(blank=True, null=True, default=None, upload_to='products') def is_on_sale(self): now = timezone.now() if self.sale_start: if self.sale_end: return self.sale_start <= now <= self.sale_end return self.sale_start <= now return False def get_rounded_price(self): return round(self.price, 2) def current_price(self): if self.is_on_sale(): discounted_price = self.price * (1 - self.DISCOUNT_RATE) return round(discounted_price, 2) return self.get_rounded_price() def __repr__(self): return '<Product object ({}) "{}">'.format(self.id, self.name)
def done(request, bill_id): bill = Bill.objects.get(pk=bill_id) if bill.voucher: v = bill.voucher v.used = True v.save() if hasattr(bill, 'servescharge'): print('sc') charge = bill.servescharge charge.paid = True charge.save() else: print('dc') charge = bill.depositcharge charge.paid = True charge.save() if hasattr(bill.customer, 'card'): card = bill.customer.card card.deposit += charge.deposit_amount else: card = Card(deposit=charge.deposit_amount, customer=bill.customer) card.save() if bill.customer: i = bill.valid_income() c = bill.customer c.credit += i c.save() if bill.customer.card: card = bill.customer.card card.deposit += Decimal.from_float(float(i) * CASH_BACK_PERCENTAGE) card.save() return render(request, 'reception/done.html', {'bill': bill})
def payAll(self): #获取购买的书籍信息 sql = "call searchCart('" + self.logininfo[0] + "');" self.cursor.execute(sql) payBookID = [] payPrice = [] payNum = [] totalPrices = Decimal.from_float(0.00) while True: CartInfo = self.cursor.fetchone() if CartInfo == None: break payBookID.append(CartInfo[0]) payNum.append(CartInfo[5]) payPrice.append(CartInfo[4] * CartInfo[5]) totalPrices += CartInfo[4] * CartInfo[5] #检查余量合法 for i in range(len(payBookID)): sql = "select BName,BStock from books where BookID = '" + payBookID[ i] + "'" self.cursor.execute(sql) message = self.cursor.fetchone() if (message[1] < payNum[i]): QMessageBox.critical( self, "Critical", self.tr("库存不足(《" + message[0] + "》仅剩 " + str(message[1]) + " 本)!")) return print("库存检查通过") #减少相应库存 for i in range(len(payBookID)): sql = "update books set BStock = BStock - " + str( payNum[i]) + " where BookID = '" + payBookID[i] + "'" self.cursor.execute(sql) #付款信息输入 self.payDialog = payDialog.payDialog(totalPrices, self) self.payDialog.exec_() payTime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) payType = self.payDialog.payInfo[0] deliverType = self.payDialog.payInfo[1] #插入消费记录 for i in range(len(payBookID)): sql = "insert into records values(null,'" + payBookID[ i] + "','" + self.curUser + "','" + payTime + "'," + str( payNum[i]) + "," + str( payPrice[i] ) + ",'" + payType + "','" + deliverType + "')" self.cursor.execute(sql) #清空购物车 sql = "delete from carts where CusID = '" + self.curUser + "'" self.cursor.execute(sql) #提交 self.connect.commit() self.rightTable("cart")
def make_20ma(r2_sp): """计算20ma MA20 = 20天内收盘价之和/20 """ from copy import deepcopy from decimal import Decimal r2_sp_test = deepcopy(r2_sp) r3_sp_test = deepcopy(r2_sp) r2_sp_test[-1] = r2_sp_test[-2] * Decimal.from_float(1.1) if len(r2_sp_test) == 20: # 如果收盘列表达到20天长度 # print(r2_sp_test[-1],r2_sp_test[-2],r2_sp_test[-3],r2_sp_test[-4],r2_sp_test[-5],r2_sp_test[-6],r2_sp_test[-7], # r2_sp_test[-8],r2_sp_test[-9],r2_sp_test[-10],r2_sp_test[-11],r2_sp_test[-12],r2_sp_test[-13],r2_sp_test[-14], # r2_sp_test[-15],r2_sp_test[-16],r2_sp_test[-17],r2_sp_test[-18],r2_sp_test[-19],r2_sp_test[-20]) ma20 = sum(r2_sp_test) / 20 # 计算ma20 # print(ma20) return ma20, 0 # 返回ma20 和0 elif len(r2_sp_test) > 20: # 如果收盘列表天数 大于20 r2_sp_test.pop(0) # 除去列表头部的天数 ma20 = sum(r2_sp_test) / 20 # 计算ma20 r2_sp.pop(0) return ma20, r2_sp # 返回ma20 和 除去头部天数的新列表
def upgrade(): op.add_column('request', sa.Column('numeric_base_payout', sa.Numeric(precision=15, scale=2), default=0.0) ) request = table('request', column('id', sa.Integer), column('base_payout', sa.Float), column('numeric_base_payout', sa.Numeric(precision=15, scale=2)), ) conn = op.get_bind() requests_sel = select([request.c.id, request.c.base_payout]) requests = conn.execute(requests_sel) for request_id, float_payout in requests: decimal_payout = Decimal.from_float(float_payout) decimal_payout *= 1000000 update_stmt = update(request)\ .where(request.c.id == request_id)\ .values({ 'numeric_base_payout': decimal_payout, }) conn.execute(update_stmt) requests.close() op.drop_column('request', 'base_payout') op.alter_column('request', column_name='numeric_base_payout', new_column_name='base_payout', existing_type=sa.Numeric(precision=15, scale=2), existing_server_default=0.0)
def get_trip_dist(start_lon, start_lat, end_lon, end_lat): """Calculate trip distance from pickup and delivery location When testing, dont calculate using a geocoding webservice. If Geocoding fails, fall back to using Euclidean distance """ if not settings.TESTING: try: origin = str(start_lat) + ',' + str(start_lon) dest = str(end_lat) + ',' + str(end_lon) base_url = 'http://maps.googleapis.com/maps/api/distancematrix/json' headers = {'content-type': 'application/json'} data = {'origins': origin, 'destinations': dest, 'units': 'imperial'} response = requests.get(base_url, params=data, headers=headers) distance_meters = int( response.json()['rows'][0]['elements'][0]['distance']['value']) if distance_meters > 10: print 'using google trip dist' return distance_meters except: pass distance_meters = (sin(radians(start_lat)) * sin(radians(end_lat)) + cos(radians(start_lat)) * cos(radians(end_lat)) * cos(radians(start_lon - end_lon))) distance_meters = (degrees(acos(distance_meters))) * 69.09 * 1609.34 print 'using naive trip dist' return Decimal.from_float(distance_meters)
def price_limit_reached(self, peer): if peer in self.strategy.pending_sent_offers: offer = self.strategy.pending_sent_offers[peer] return (offer.is_too_low and round(Decimal.from_float(offer.rate), 5) >= round( self.strategy.max_rate, 5)) return False
def prices(self, quantities, requirements): """ Return the prices for specified parts at specified quantities. requirements must have a validate function that takes two arguments: an offer and the quantity quantities must be a dictionary mapping reference numbers to quantities """ result = {} for ref,quantity in self.quantities.iteritems(): info = self.match_info(ref) if len(info) > 1: result[ref] = {'error': 'Part not uniquely matched'} continue offers = filter(lambda x: requirements.validate(x, quantity), info[0].offers) best = Decimal.from_float(1e15) best_offer = None for offer in offers: price = offer.best_price(quantity) if price is not None and price < best: best = price best_offer = offer if best_offer is None: result[ref] = {'error', 'No valid offers found'} else: result[ref] = {'price': best, 'offer': offer} return result
def processInteract(session, redis): today = date.today() start = datetime.now() start = start.replace(hour=0, minute=0, second=0, microsecond=0) orders = SinaWeiboInteractOrder.queryTodo(session, today) for order in orders: logging.info('process Interact order: {id}'.format(id=order.order_id)) if SinaWeiboInteractChildOrder.search(session, order.order_id, start): continue child = SinaWeiboInteractChildOrder() child.parent_order_id = order.order_id child.create_at = datetime.now() child.user_id = order.user_id child.sina_blog_info_id = order.sina_blog_info_id child.purchase_number = order.purchase_number child.order_id = '{ss}{us}24'.format( ss=datetime.strftime(datetime.now(), '%Y%m%d%H%M%S'), us=str(Decimal.from_float(time.time()).quantize( Decimal('0.000')))[11:]) child.status = ORDER_STATUS_DOING child.update_at = datetime.now() child.pay_at = order.pay_at child.order_amount = 0 child.center = order.center child.priority = 1 child.flag = ORDER_FLAG_DEFAULT session.add(child) session.commit()
def update_ui(self, state=True): """Updates various UI elements to match current settings, UI selections etc. """ # Cost in_us = self.application.config['settings']['user']['in_us'] cost_per_mb = Decimal("0.15") if in_us else Decimal("0.99") free = self.free_radiobutton.get_active() if free: cost = 0 else: cost = Decimal.from_float( self.filesize / 1024.0 / 1024) / cost_per_mb self.cost_label.set_label("Estimated Cost: $%.2f" % round(cost, 2)) self.cost_label.set_visible(cost!=0) # If not yet configured, force the user to do so first if not self.application.is_configured(): self.send_button.set_label('Setup your Kindle first') self.configure_button.hide() else: self.send_button.set_label('Send to %s' % self.get_recipient()) self.configure_button.show() # State if state: state = self.application.config['state'] self.free_radiobutton.set_active(state['free']) self.objects.get_object('convert-checkbox').set_active( state['convert'])
def test_convert_to(data): if abs(data) < Decimal('1e16'): number = convert_to.decimal(data) assert number == Decimal.from_float(data).quantize(Decimal('1e-8')) else: with pytest.raises(InvalidOperation): convert_to.decimal(data)
def vyhodnot(scoredResults, scoredRunId): scoredRun = Run.objects.get(pk=int(scoredRunId)) for scoredResult in scoredResults: scoredPerson = Person.objects.get(pk=scoredResult[0]) databaseResult = Result.objects.get(run = scoredRun, person = scoredPerson) databaseResult.points = Decimal.from_float(scoredResult[2]) databaseResult.save() databaseResult = None results = Result.objects.all() nullPoints() for i in range(len(results)): try: newPos = Position.objects.get(person=results[i].person, season=results[i].run.season) newPos.points += results[i].points except Position.DoesNotExist: newPos = Position(person=results[i].person, position_season = 0, season = results[i].run.season, position_category = 0, points = results[i].points) newPos.save() position = Position.objects.all().order_by('-points') categories = Category.objects.all() categoryPositionCursor = dict() for category in categories: categoryPositionCursor[category] = 1 for i in range(len(position)): position[i].position_season = i+1 position[i].position_category = categoryPositionCursor[position[i].person.category] categoryPositionCursor[position[i].person.category] += 1 position[i].save()
def to_decimal(value): """ Преобразование значения в большое число с фиксированной дробной частью. При неудаче возвращается None """ value = to_float(value) return None if value is None else Decimal.from_float(value)
def _distance(self, lat2, lng2): a = abs(self.lat - lat2) b = abs(self.lng - lng2) s = 2*math.asin(math.sqrt(math.pow(math.sin(a/2),2)+math.cos(self.lat)*math.cos(lat2)*math.pow(math.sin(b/2),2))) d = EARTH_R*Decimal.from_float(s) d_i = d.to_integral() return d_i
def turtlePath(path): f = open(path, 'r') lines = f.readlines() num_obs, num_paths = lines[0].split(' ') num_obs = int(num_obs) num_paths = int(num_paths[0:len(num_paths)-1]) obs = {} for ob in range(1, num_obs+1): x,y = lines[ob].split(' ') x = int(x) y = int(y[0:len(y)-1]) obs[(x,y)] = True curr_pos = (0,0) #influences curr_pos delta for reach move based on direction turtle is facing curr_dir = (0,1) #max straight line distance from the origin max_dist = 0 for l in range(num_obs+1, len(lines)): command = lines[l] c_type = command[0] # print(c_type) if c_type != 'M': curr_dir = change_dir(c_type, curr_dir) else: dist = int(command[2:len(command)-1]) delta = collision_block(obs, curr_dir, curr_pos, dist) curr_pos = (curr_pos[0]+delta[0], curr_pos[1]+delta[1]) hypotenuse = math.sqrt(curr_pos[0]**2 + curr_pos[1]**2) max_dist = hypotenuse if hypotenuse > max_dist else max_dist f.close() return float(round(Decimal.from_float(max_dist), 2))
def simulation(request): query = request.GET.get('q') if query: # There was a query entered. results = Product.objects.filter(name=query) else: # If no query was entered, simply return all objects results = None #Product.objects.all() date = timezone.now() try: salesID = Sale.objects.latest('id').id+1 except ObjectDoesNotExist: salesID = 1 items = Item.objects.filter(sale_id = salesID) print(items) subtotal = items.aggregate(Sum('total')).values()[0] cash = Cashier.objects.get(id=1) tax = Decimal.from_float((float(cash.tax)/100)).quantize(Decimal("0.00")) if subtotal is not None: total = (subtotal*(1+tax)).quantize(Decimal("0.00")) else: total = 0.00 tax *= 100 session = Sale(date_created = timezone.now(), subtotal = subtotal, tax = tax, payment = total, total = total) form = SaleForm(request.POST, instance=session) return render_to_response("simulation.html",{"form":form,"date": date, "sales": salesID, "ItemsParameter": items, "subtotal": subtotal, "tax":tax, "total":total, "results": results} , context_instance = RequestContext(request))
def to_positive_decimal(value): """ Преобразование значения в неотрицательное большое число с фиксированной дробной частью. При неудаче возвращается None """ value = to_float(value) return None if value is None or value < 0 else Decimal.from_float(value)
def test_deserialize(self): # Given class TestMixResponse(BaseResponse): def __init__(self, text: str, success: bool, dec: Decimal, uid: UUID, dt: datetime.datetime): self.text = text self.success = success self.dec = dec self.uid = uid self.dt = dt time = datetime.datetime.now() uid = uuid.uuid4() mix_response = TestMixResponse(text="bla bla", success=True, dec=Decimal.from_float(1.123), uid=uid, dt=time) # When response = mix_response.to_json() # Then assert response is not None assert mix_response.text == response["text"] assert mix_response.success == response["success"] assert 1.12 == response["dec"] assert str(mix_response.uid) == response["uid"] assert time.isoformat() == str(response["dt"])
def price_advanced(self, reference, quantity, requirements): """ Find the price of a single item subject to various requirements requirements must have a validate function that takes two arguments: an offer and the quantity """ info = self.match_info(reference) if len(info) > 1: return {'error': 'Part not uniquely matched'} offers = filter(lambda x: requirements.validate(x, quantity), info[0].offers) best = Decimal.from_float(1e15) best_offer = None for offer in offers: price = offer.best_price(quantity) if price is not None and price < best: best = price best_offer = offer if best_offer is None: return {'error': 'No valid offers found'} else: return {'price': best, 'offer': offer}
def newround(number, ndigits=None): """ See Python 3 documentation: uses Banker's Rounding. Delegates to the __round__ method if for some reason this exists. If not, rounds a number to a given precision in decimal digits (default 0 digits). This returns an int when called with one argument, otherwise the same type as the number. ndigits may be negative. See the test_round method in future/tests/test_builtins.py for examples. """ return_int = False if ndigits is None: return_int = True ndigits = 0 if hasattr(number, '__round__'): return number.__round__(ndigits) # Use the decimal module for simplicity of implementation (and # hopefully correctness). from decimal import Decimal, ROUND_HALF_EVEN if ndigits < 0: raise NotImplementedError('negative ndigits not supported yet') exponent = Decimal('10') ** (-ndigits) d = Decimal.from_float(number).quantize(exponent, rounding=ROUND_HALF_EVEN) if return_int: return int(d) else: return float(d)
def __init__(self, owner, tag): self.owner = owner self.id = int(tag.attrib["key"]) self.type = int(tag.attrib["type"]) self.name = tag.attrib["name"] self.flags = int(tag.attrib.get("flags", 0)) self._initial = Decimal.from_float(float(tag.attrib["initial"]))
def test_saving_and_retrieving_items(self): create_two_agereements_with_periods() agreements = Agreement.objects.all() self.assertEqual(agreements.count(), 2) self.assertEqual(agreements[1].start_date, date.today()) self.assertEqual(agreements[1].end_date, date(date.today().year+1, date.today().month, date.today().day)) self.assertEqual(agreements[1].negotiator.username, 'testUser') self.assertEqual(agreements[1].company.name, 'company1') self.assertAlmostEqual(agreements[1].credit_turnover, Decimal.from_float(1111.11), places=5) self.assertAlmostEqual(agreements[1].debit_turnover, Decimal.from_float(123.45), places=5) self.assertEqual(agreements[0].start_date, date.today()) self.assertEqual(agreements[0].end_date, date(date.today().year+4, date.today().month, date.today().day)) self.assertEqual(agreements[0].negotiator.username, 'testUser2') self.assertEqual(agreements[0].company.name, 'company2') self.assertAlmostEqual(agreements[0].credit_turnover, Decimal.from_float(5678.11), places=5) self.assertAlmostEqual(agreements[0].debit_turnover, Decimal.from_float(9876.45), places=5)
def get(self, api_type): # TODO: Get data self.lat = RAD_K * Decimal.from_float(_get_float(self.get_argument('lat', ''), DEFAULT_LAT)) self.lng = RAD_K * Decimal.from_float(_get_float(self.get_argument('lng', ''), DEFAULT_LNG)) # TODO: Query out less point presents = self.sql_session.query(Presentation).all() final_presents = [] for present in presents: lat2 = RAD_K*present.lat lng2 = RAD_K*present.lng d = self._distance(lat2, lng2) if d < 1000: present.distance_string = '%d m' % d elif d<=5000: present.distance_string = '%.2f km' % (float(d)/1000) else: continue upload_file = FileList.by_present_id(present.p_key, self.sql_session).scalar() present.file_url = '/download/' + upload_file.key + '/' + upload_file.filename + '.' + upload_file.file_type present.img_url = '/download/' + upload_file.key + '/' + upload_file.filename + '.png' final_presents.append(present) if api_type == None: self.render('querypresent.html', presents = final_presents) elif api_type[1:] == 'json': return_data = [] for present in final_presents: return_data.append({ 'title': present.title, 'owner': present.owner, 'distance': present.distance_string, 'created': present.created.strftime("%Y-%m-%d %H:%M"), 'updated': present.updated.strftime("%Y-%m-%d %H:%M"), 'file_url': present.file_url, 'img_url': present.img_url, 'lat': str(present.lat), 'lng': str(present.lng)} ) self.write(json.dumps(return_data)) else: raise self.HTTPError(500, 'Unknown api type')
def upgrade(): # Add discriminator column op.add_column('modifier', sa.Column('_type', sa.String(length=20))) # Create new subclass tables op.create_table('absolute_modifier', sa.Column('id', sa.Integer, sa.ForeignKey('modifier.id'), primary_key=True), sa.Column('value', sa.Numeric(precision=15, scale=2), nullable=False, server_default='0.0')) op.create_table('relative_modifier', sa.Column('id', sa.Integer, sa.ForeignKey('modifier.id'), primary_key=True), sa.Column('value', sa.Float, nullable=False, server_default='0.0')) # Add new entries to the subclass tables for each modifier conn = op.get_bind() modifier_sel = select([modifier.c.id, modifier.c.value, modifier.c.type_]) modifiers = conn.execute(modifier_sel) absolutes = [] relatives = [] for modifier_id, modifier_value, modifier_type in modifiers: if modifier_type == 'absolute': discriminator = 'AbsoluteModifier' absolutes.append({ 'id': modifier_id, 'value': Decimal.from_float(modifier_value) * 1000000, }) elif modifier_type == 'percentage': discriminator = 'RelativeModifier' relatives.append({ 'id': modifier_id, 'value': modifier_value / 100, }) update_stmt = update(modifier)\ .where(modifier.c.id == modifier_id)\ .values({ '_type': discriminator, }) conn.execute(update_stmt) modifiers.close() op.bulk_insert(abs_table, absolutes) op.bulk_insert(rel_table, relatives) # Drop the old value and type_ columns from modifier op.drop_column('modifier', 'value') op.drop_column('modifier', 'type_') # Add the not-null constraint to the _type column op.alter_column('modifier', column_name='_type', nullable=True, existing_type=sa.String(length=20), )
def recover(self, block): p = block['prime'] points = block['points'] M = 0 for point in points: point['li'] = self.lagrange_interpolate(point['id'], points) coof = point['li'].pop() M += Decimal.from_float(coof) * Decimal(point['shadow']) SECRET = round(M) % p return SECRET
def round(number, ndigits=None): return_int = False if ndigits is None: return_int = True ndigits = 0 if hasattr(number, "__round__"): return number.__round__(ndigits) if ndigits < 0: raise NotImplementedError("negative ndigits not supported yet") exponent = Decimal("10") ** (-ndigits) d = Decimal.from_float(number).quantize(exponent, rounding=ROUND_HALF_EVEN) if return_int: return int(d) else: return float(d)
def get_bin_decimals(v, max_sample=100, default=3): v = v.astype(float, raise_on_error=False) if len(v) <= max_sample: sample = v else: sample = random.sample(v, max_sample) num_decimals = [] for e in sample: # num_decimals.append(str(e).find('.')) num_decimals.append(Decimal.from_float(e).as_tuple().exponent * -1) try: max_decimals = max(num_decimals) except: return default return min((max_decimals + 1), default)
def _parse_expression(self, tokens): expression = u'' for token in tokens: if token in cal_callback._ops: expression += cal_callback._ops[token] else: num = Util.cn2dig(token) if num is None: return None expression += str(num) res = None INFO("expression: " + expression) try: res = eval(expression) res = Decimal.from_float(res).quantize(Decimal('0.00')) except Exception, ex: ERROR("cal expression error:", ex)
def __init__(self, owner, tag): self.owner = owner self.amount = Decimal.from_float(float(tag.attrib["amount"])) self.account = next( x for x in self.owner.accounts if x.id == int(tag.attrib["account"]) ) self.mode_id = int(tag.attrib.get("paymode", 0)) self.flags = int(tag.attrib.get("flags", 0)) or None self.payee_id = int(tag.attrib.get("payee", 0)) or None self.category_id = int(tag.attrib.get("category", 0)) or None self.wording = tag.attrib.get("wording") self.info = tag.attrib.get("info") self.date = from_gdate(int(tag.attrib["date"])) self.dst_account_id = int(tag.attrib.get("dst_account", 0)) or None self.id = None
def price(self, reference, quantity, seller): """ Return the best price for N parts from seller as a Decimal """ info = self.match_info(reference) can_seller = self._canonicalize_name(seller) if len(info) > 1: raise ArgumentError("part is not uniquely matched", reference=reference) offers = filter(lambda x: self._canonicalize_name(x.seller)==can_seller, info[0].offers) best = Decimal.from_float(1e15) for offer in offers: price = offer.best_price(quantity) if price is not None and price < best: best = price return best
def test_binary_floats(self): # check that floats hash equal to corresponding Fractions and Decimals # floats that are distinct but numerically equal should hash the same self.check_equal_hash(0.0, -0.0) # zeros self.check_equal_hash(0.0, D(0)) self.check_equal_hash(-0.0, D(0)) self.check_equal_hash(-0.0, D('-0.0')) self.check_equal_hash(0.0, F(0)) # infinities and nans self.check_equal_hash(float('inf'), D('inf')) self.check_equal_hash(float('-inf'), D('-inf')) for _ in range(1000): x = random.random() * math.exp(random.random()*200.0 - 100.0) self.check_equal_hash(x, D.from_float(x)) self.check_equal_hash(x, F.from_float(x))
def newround(number, ndigits=None): """ See Python 3 documentation: uses Banker's Rounding. Delegates to the __round__ method if for some reason this exists. If not, rounds a number to a given precision in decimal digits (default 0 digits). This returns an int when called with one argument, otherwise the same type as the number. ndigits may be negative. See the test_round method in future/tests/test_builtins.py for examples. """ return_int = False if ndigits is None: return_int = True ndigits = 0 if hasattr(number, '__round__'): return number.__round__(ndigits) if ndigits < 0: raise NotImplementedError('negative ndigits not supported yet') exponent = Decimal('10') ** (-ndigits) if PYPY: # Work around issue #24: round() breaks on PyPy with NumPy's types if 'numpy' in repr(type(number)): number = float(number) if not PY26: d = Decimal.from_float(number).quantize(exponent, rounding=ROUND_HALF_EVEN) else: d = from_float_26(number).quantize(exponent, rounding=ROUND_HALF_EVEN) if return_int: return int(d) else: return float(d)
def ppma(s, D=5): print('<tr><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th></tr>', file=utf8stdout) frmt = '<tr class="{}"><td>{}</td><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>' letters_left = 256 def find_context(i): k = 0 for j in range(min(i,D)+1): f = s.find(s[i-j:i], 0, i-1) if f == -1: break k = j return s[i-k:i] def context_stat(i, cont): stat = defaultdict(lambda: 0) p = 0 while p < i: p = s.find(cont, p, i - 1) if p == -1: break stat[s[p+len(cont)]] += 1 p += 1 return stat def calc_numbers(i, context, seen=set()): c = s[i] stat = context_stat(i, context) for b in seen: del stat[b] sm = sum(stat.values()) if c in stat.keys(): return ([sm], [], Fraction(stat[c], sm+1)) else: # need esc if context: taus, p_escs, p_a = calc_numbers(i, context[1:], set(stat.keys()) | seen) else: nonlocal letters_left taus, p_escs, p_a = [], [], Fraction(1, letters_left) letters_left -= 1 return ([sm] + taus, [Fraction(1, sm + 1)] + p_escs, p_a) def fracs(fs): return ' * '.join(map(frac, fs)) def frac(f): if f.denominator == 1: return str(f.numerator) else: return '{} / {}'.format(f.numerator, f.denominator) i = 0 total = Decimal(0) while i < len(s): letter = s[i] context = find_context(i) taus, p_escs, p_a = calc_numbers(i, context) if not context: context = '-' elif isinstance(context, bytes): context = ' '.join(map(hex, context)) fr1 = fracs(p_escs) #if fr1: # fr1 = '$'+fr1+'$' fr2 = frac(p_a) #if fr2: # fr2 = '$'+fr2+'$' print(frmt.format('odd' if i % 2 == 0 else 'even', letter, context, ';'.join(map(str,taus)), fr1, fr2), file=utf8stdout) i += 1 total += sum(map(lambda p: Decimal.from_float(-log(p, 2)), p_escs + [p_a])) print('<tr><td colspan="5"><center>Total bits: {}</center></td></tr>'.format(ceil(total)+1), file=utf8stdout)
def test_decimal_should_convert_to_model(): field = s.Decimal() assert field.json_to_model(999999.0) == Decimal('999999') assert field.json_to_model(-0.99) == Decimal.from_float(-0.99) assert field.json_to_model(0) == Decimal('0')
try: xrange except NameError: xrange = range def _get_float(s, default): try: f = float(s) except ValueError: return default return f EARTH_R = Decimal('6371009') # Meter RAD_K = Decimal.from_float(math.pi) / Decimal(180) DEFAULT_LAT = 25.0724763 DEFAULT_LNG = 121.5185635 class QueryPresentHandler(BaseHandler): def get(self, api_type): # TODO: Get data self.lat = RAD_K * Decimal.from_float(_get_float(self.get_argument('lat', ''), DEFAULT_LAT)) self.lng = RAD_K * Decimal.from_float(_get_float(self.get_argument('lng', ''), DEFAULT_LNG)) # TODO: Query out less point presents = self.sql_session.query(Presentation).all() final_presents = [] for present in presents:
def cutDot(x): return Decimal.from_float(x).quantize(Decimal('0.0000000'))
def round_decimal(self, x): return Decimal.from_float(x).quantize(Decimal(".01"), rounding=ROUND_HALF_UP)
def __init__(self, payout): self.raw_payout = payout scaled = Decimal.from_float(self.raw_payout) scaled *= 1000000 self.scaled_payout = scaled
def format_picture(conv, value, picture): monetary = False decimal_point = conv['decimal_point'] thousands_sep = conv[monetary and 'mon_thousands_sep' or 'thousands_sep'] percent = '%' per_mille = '\u2030' minus_sign = '-' #grouping = conv[monetary and 'mon_grouping' or 'grouping'] if isinstance(value, float): value = Decimal.from_float(value) elif isinstance(value, _STR_NUM_TYPES): value = Decimal(value) elif not isinstance(value, Decimal): raise ValueError(_('Picture requires a number convertable to decimal or float').format(picture)) if value.is_nan(): return 'NaN' isNegative = value.is_signed() pic, sep, negPic = picture.partition(';') if negPic and ';' in negPic: raise ValueError(_('Picture contains multiple picture sepearators {0}').format(picture)) if isNegative and negPic: pic = negPic if len([c for c in pic if c in (percent, per_mille) ]) > 1: raise ValueError(_('Picture contains multiple percent or per_mille charcters {0}').format(picture)) if percent in pic: value *= 100 elif per_mille in pic: value *= 1000 intPart, sep, fractPart = pic.partition(decimal_point) prefix = '' numPlaces = 0 intPlaces = 0 grouping = 0 fractPlaces = 0 suffix = '' if fractPart: if decimal_point in fractPart: raise ValueError(_('Sub-picture contains decimal point sepearators {0}').format(pic)) for c in fractPart: if c.isdecimal(): numPlaces += 1 fractPlaces += 1 if suffix: raise ValueError(_('Sub-picture passive character {0} between active characters {1}').format(c, fractPart)) else: suffix += c intPosition = 0 for c in reversed(intPart): if c.isdecimal() or c == '#' or c == thousands_sep: if prefix: raise ValueError(_('Sub-picture passive character {0} between active characters {1}').format(c, intPart)) if c.isdecimal(): numPlaces += 1 intPlaces += 1 intPosition += 1 prefix = '' elif c == '#': numPlaces += 1 intPosition += 1 elif c == thousands_sep: if not grouping: grouping = intPosition else: prefix = c + prefix if not numPlaces and prefix != minus_sign: raise ValueError(_('Sub-picture must contain at least one digit position or sign character {0}').format(pic)) if intPlaces == 0 and fractPlaces == 0: intPlaces = 1 return format_decimal(value, intPlaces=intPlaces, fractPlaces=fractPlaces, sep=thousands_sep, dp=decimal_point, grouping=grouping, pos=prefix, neg=prefix if negPic else prefix + minus_sign, trailpos=suffix, trailneg=suffix)