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 decpi(memo={}):
"""Compute Pi to the current precision.
>>> print pi()
3.141592653589793238462643383
Taken from the Python Decimal documentation and memoized.
"""
prec = getcontext().prec
pi = memo.get(prec, None)
if pi is not None:
return pi
getcontext().prec += 2 # extra digits for intermediate steps
three = Decimal(3) # substitute "three=3.0" for regular floats
lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
while s != lasts:
lasts = s
n, na = n+na, na+8
d, da = d+da, da+32
t = (t * n) / d
s += t
getcontext().prec -= 2
pi = +s # unary plus applies the new precision
memo[prec] = pi
return pi
def read_decimal_from_fixed(self, precision, scale, size):
"""
Decimal is encoded as fixed. Fixed instances are encoded using the
number of bytes declared in the schema.
"""
datum = self.read(size)
unscaled_datum = 0
msb = struct.unpack('!b', datum[0])[0]
leftmost_bit = (msb >> 7) & 1
if leftmost_bit == 1:
modified_first_byte = ord(datum[0]) ^ (1 << 7)
datum = chr(modified_first_byte) + datum[1:]
for offset in range(size):
unscaled_datum <<= 8
unscaled_datum += ord(datum[offset])
unscaled_datum += pow(-2, (size*8) - 1)
else:
for offset in range(size):
unscaled_datum <<= 8
unscaled_datum += ord(datum[offset])
original_prec = getcontext().prec
getcontext().prec = precision
scaled_datum = Decimal(unscaled_datum).scaleb(-scale)
getcontext().prec = original_prec
return scaled_datum
def dms2decimal(degrees, minutes, seconds):
""" Converts degrees, minutes, and seconds to the equivalent
number of decimal degrees. If parameter 'degrees' is negative,
then returned decimal-degrees will also be negative.
NOTE: this method returns a decimal.Decimal
Example:
>>> dms2decimal(121, 8, 6)
Decimal('121.135')
>>> dms2decimal(-121, 8, 6)
Decimal('-121.135')
"""
decimal = D(0)
degs = D(str(degrees))
mins = libdecimal.getcontext().divide(D(str(minutes)), D(60))
secs = libdecimal.getcontext().divide(D(str(seconds)), D(3600))
if degrees >= D(0):
decimal = degs + mins + secs
else:
decimal = degs - mins - secs
return libdecimal.getcontext().normalize(decimal)
def f0():
print("--- f0 ---")
import decimal as dec
dec.getcontext().prec = 110
dec.getcontext().rounding = dec.ROUND_DOWN
Nmax = 100
# Find all squares up to Nmax:
i = 1
squares = []
while i*i < Nmax + 1:
squares.append(i*i)
i += 1
# Loop over all sqrts, and add decimals as requested:
total = 0
for N in range(1,Nmax+1):
if not N in squares:
N = dec.Decimal(N)
s = N.sqrt()
s = s*10**100
s = str(s)[:100]
s = sum([ int(x) for x in s ])
total += s
# Final result:
print(total)
def _minimum_variable_cost(self, average_orders, reorder_cost, unit_cost) -> Decimal:
getcontext().prec = 2
getcontext().rounding = ROUND_HALF_UP
holding_cost = self.__holding_cost
step = float(0.2)
previous_eoq_variable_cost = Decimal(0)
Decimal(reorder_cost)
order_factor = float(0.002)
vc = 0.00
counter = 0
order_size = 0
while previous_eoq_variable_cost >= Decimal(vc):
previous_eoq_variable_cost = Decimal(vc)
# reorder cost * average demand all divided by order size + (demand size * holding cost)
if counter < 1:
order_size = self._order_size(average_orders=average_orders, reorder_cost=reorder_cost,
unit_cost=unit_cost, holding_cost=holding_cost,
order_factor=order_factor)
vc = self._variable_cost(float(average_orders), float(reorder_cost), float(order_size), float(unit_cost), float(holding_cost))
order_size += int(float(order_size) * step)
if counter < 1:
previous_eoq_variable_cost = Decimal(vc)
while counter == 0:
counter += 1
return Decimal(previous_eoq_variable_cost)
def float_hex_2_float(str_pi_hex_digits, precisao) -> decimal:
getcontext().prec = precisao
getcontext().rounding = ROUND_FLOOR
mypi10 = decimal(0)
for i in range(len(str_pi_hex_digits)-1, -1, -1):
mypi10 += decimal(int(str_pi_hex_digits[i], base=16) * 16 ** -i)
return mypi10
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 convert_interest_rate(new_comp_period, interest_rate): getcontext().prec = InterestRate.DEFAULT_PRECISION old_rate = 1 + interest_rate.periodic_interest_rate e = Decimal(interest_rate.compounding_period / new_comp_period) return getcontext().power(old_rate, e) - 1
def cos(x):
"""Return the cosine of x as measured in radians.
>>> print cos(Decimal('0.5'))
0.8775825618903727161162815826
>>> print cos(0.5)
0.87758256189
>>> print cos(0.5+0j)
(0.87758256189+0j)
"""
x = Decimal(str(x)) % (2 * _pi())
if isnan(x):
return Decimal('NaN')
getcontext().prec += 2
i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
while s != lasts:
lasts = s
i += 2
fact *= i * (i - 1)
num *= x * x
sign *= -1
s += num / fact * sign
getcontext().prec -= 2
return +s
def acos(x):
"""Return the arc cosine (measured in radians) of Decimal x."""
x = Decimal(str(x))
if abs(x) > 1:
raise ValueError("Domain error: acos accepts -1 <= x <= 1")
if x == -1:
return _pi()
elif x == 0:
return _pi() / 2
elif x == 1:
return Decimal(0)
getcontext().prec += 2
one_half = Decimal('0.5')
i, lasts, s, gamma, fact, num = Decimal(0), 0, _pi() / 2 - x, 1, 1, x
while s != lasts:
lasts = s
i += 1
fact *= i
num *= x * x
gamma *= i - one_half
coeff = gamma / ((2 * i + 1) * fact)
s -= coeff * num
getcontext().prec -= 2
return +s
def sin(x):
"""Return the sine of x as measured in radians.
>>> print sin(Decimal('0.5'))
0.4794255386042030002732879352
>>> print sin(0.5)
0.479425538604
>>> print sin(0.5+0j)
(0.479425538604+0j)
"""
x = Decimal(str(x)) % (2 * _pi())
if isnan(x):
return Decimal('NaN')
getcontext().prec += 2
i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
while s != lasts:
lasts = s
i += 2
fact *= i * (i - 1)
num *= x * x
sign *= -1
s += num / fact * sign
getcontext().prec -= 2
return +s
def PHI(n=2): ''' PHI(int) -> Decimal -- returns (1+√5)/2 to int precision, increasing the precision of Decimal if required''' from decimal import getcontext,Decimal if n > getcontext().prec: getcontext().prec = n s5 = Decimal(5).sqrt() return (1 + s5)/2
def atan(x):
"""Return the arc tangent (measured in radians) of Decimal x."""
x = Decimal(str(x))
if x == Decimal('-Inf'):
return _pi() / -2
elif x == 0:
return Decimal(0)
elif x == Decimal('Inf'):
return _pi() / 2
if x < -1:
c = _pi() / -2
x = 1 / x
elif x > 1:
c = _pi() / 2
x = 1 / x
else:
c = 0
getcontext().prec += 2
x_squared = x ** 2
y = x_squared / (1 + x_squared)
y_over_x = y / x
i, lasts, s, coeff, num = Decimal(0), 0, y_over_x, 1, y_over_x
while s != lasts:
lasts = s
i += 2
coeff *= i / (i + 1)
num *= y
s += coeff * num
if c:
s = c - s
getcontext().prec -= 2
return +s
def _trade_budget(self, sum_, offers):
"""
Calculates maximum volume purchasabale with given money sum and offers.
Usable for both sell and buy offers.
:param amount: int or float
:param offers: list of lists in format [price, vol, timestamp]
:return: float
"""
d = decimal.Decimal
decimal.getcontext().prec = 8
decimal.getcontext().rounding = decimal.ROUND_DOWN
wallet = d(sum_)
basket = d(0.0)
for offer in offers:
p = d(offer[0]) # convert string to float
vol = d(offer[1]) # convert string to float
if wallet > 0.0:
if p * vol <= wallet:
wallet -= p * vol
basket += vol
elif p * vol > wallet:
basket += wallet / p
wallet -= wallet
return float(basket)
def _trade_vol(self, amount, offers):
"""
Calculates total price for given amount and offers. Can be used to calc
sell or buy price.
:param pair: str
:param amount: float or int
:param bids: list of lists format[price, vol, timestamp]
:return:
"""
d = decimal.Decimal
decimal.getcontext().prec = 8
decimal.getcontext().rounding = decimal.ROUND_DOWN
basket = d(0.0)
left_to_trade = d(amount)
total = d(0.0)
for offer in offers:
p = d(offer[0])
vol = d(offer[1])
if left_to_trade > d(0.0):
if vol > left_to_trade:
total += left_to_trade * p
left_to_trade -= left_to_trade
elif vol < amount:
left_to_trade -= vol
total += vol * p
return float(total)
def from_decimal(self, decimal_degrees, hemisphere = ''):
degrees = D(int(decimal_degrees))
decimal_minutes = libdecimal.getcontext().multiply((D(str(decimal_degrees)) - degrees).copy_abs(), D(60))
minutes = D(int(decimal_minutes))
seconds = libdecimal.getcontext().multiply((decimal_minutes - minutes), D(60))
return DMSCoordinate(degrees, minutes, seconds, hemisphere)
def decimals_integers_division (number1=decimal.Decimal(), number2=0):
if number1 == decimal.Decimal() or number2 == 0:
number1 = generate_decimal(4,99)
number2 = random.randint (4,9)
original_precision = decimal.getcontext().prec
decimal.getcontext().prec=5
answer = number1 / number2
decimal.getcontext().prec = original_precision
question = "{} divided by {} = ______".format (number1, number2)
return (question, answer)
def __init__(self, reorder_quantity: float, holding_cost: float, reorder_cost: float, average_orders: float,
unit_cost: float, total_orders: float):
getcontext().prec = 2
getcontext().rounding = ROUND_HALF_UP
self.__reorder_quantity = Decimal(reorder_quantity)
self.__holding_cost = holding_cost
self.__reorder_cost = reorder_cost
self.__unit_cost = unit_cost
self.__min_variable_cost = minimum_variable_cost(total_orders, reorder_cost, unit_cost, holding_cost)
self.__economic_order_quantity = economic_order_quantity(total_orders, reorder_cost, unit_cost,holding_cost, reorder_quantity)
def integers_decimals_division (number1=0, number2= decimal.Decimal()):
if number1 == 0 or number2 == decimal.Decimal():
number1 = random.randint (19, 300)
number2 = generate_decimal(9,9)
original_precision = decimal.getcontext().prec
decimal.getcontext().prec=4
answer = number1 / number2
decimal.getcontext().prec = original_precision
question = "{} divided by {} = ______".format (number1, number2)
return (question, answer)
def binary_to_decimal(man, exp, n):
"""Represent as a decimal string with at most n digits"""
import decimal
prec_ = decimal.getcontext().prec
decimal.getcontext().prec = n
if exp >= 0: d = decimal.Decimal(man) * (1<<exp)
else: d = decimal.Decimal(man) / (1<<-exp)
a = str(d)
decimal.getcontext().prec = prec_
return a
def product_tax_calculator(self, tax_rate):
""" Return product final price based on the provided `tax_rate`
Decimal module used for precision and rounding purposes
"""
#setup decimal context
getcontext().prec = 4
getcontext().round = ROUND_HALF_EVEN
total = Decimal(self.price) * Decimal(tax_rate)
self.product_tax = round_nearest(total.__float__())
return round(float(self.price) + self.product_tax, 2)
def _prec(stack, arg):
"""set or query precision in digits"""
if arg is not None and arg.strip():
decimal.getcontext().prec = int(arg.strip())
for i, v in enumerate(stack):
if isinstance(v, Decimal) or isinstance(v, ComplexDec):
stack[i] = v.normalize()
else:
stack.append(Decimal(decimal.getcontext().prec))
def decimals_division (number1=decimal.Decimal(), number2=decimal.Decimal()):
if number1 == decimal.Decimal() or number2 == decimal.Decimal():
number1 = generate_decimal(99,9999)
number2 = generate_decimal(9,99)
current_precision = decimal.getcontext().prec
decimal.getcontext().prec = 6
answer = number1 / number2
decimal.getcontext().prec = current_precision
question = "Divide {} by {}. Stop the division at 4 places after decimal point.".format (number1, number2)
return (question, answer)
def arccos_d(x):
"""
Returns the inverse sine of x as measured in radians.
"""
dp.getcontext().prec += 2
ac = pi / dp.Decimal('2') - arcsin_d(x)
dp.getcontext().prec -= 2
return ac
def rule_coordinate_pair(self, next_val_fn, token):
# Inline these since this rule is so common.
if token[0] not in self.number_tokens:
raise SyntaxError("expecting a number; got %r" % (token,))
x = getcontext().create_decimal(token[1])
token = next_val_fn()
if token[0] not in self.number_tokens:
raise SyntaxError("expecting a number; got %r" % (token,))
y = getcontext().create_decimal(token[1])
token = next_val_fn()
return [x, y], token
def _pi(self):
getcontext().prec += 2
lasts, t, s, n, na, d, da = 0, Decimal(3), 3, 1, 0, 0, 24
while s != lasts:
lasts = s
n, na = n + na, na + 8
d, da = d + da, da + 32
t = (t * n) / d
s += t
getcontext().prec -= 2
return +s
def pi(n=None):
''' Estimate pi using n terms of the Chudnovsky brothers' formula. By
default this will attempt to calculate it to the maximum number of digits
storable in a decimal number. '''
from math import factorial
D = Decimal
if n == None: n = round(getcontext().prec/D(14)) + 10
with localcontext():
getcontext().prec += 5
f = lambda k: factorial(6*k)*D(13591409 + 545140134*k)\
/ (factorial(3*k)*factorial(k)**3*D(-640320)**(3*k))
return 426880*D(10005)**D('0.5') / sum(f(k) for k in range (100))
def pi(context=None):
"""Compute Pi to the current precision."""
getcontext().prec += 2
lasts = 0; t = D(3); s = 3; n = 1; na = 0; d = 0; da = 24
while s != lasts:
lasts = s
n, na = n + na, na + 8
d, da = d + da, da + 32
t = (t * n) / d
s += t
getcontext().prec -= 2
return +s
def load_calc(places=100):
old_result = None
getcontext().prec = 2*places
for n in range(10*places):
getcontext().prec = 2*places
result = pi_archimedes(n)
getcontext().prec = places
result = +result
if result == old_result:
break
old_result = result
return result
def __init__(self, context=None):
self.context = context or decimal.getcontext()
def coverage_measures(all_num, match_num):
# 小数点３桁まで出力
decimal.getcontext().prec = 3
coverage = decimal.Decimal(match_num) / decimal.Decimal(all_num)
return coverage
__email__ = "*****@*****.**"
# Python 3 compatibility
from six.moves import xrange as range
_IS_PYTHON_3 = sys.version_info[0] == 3
identity = lambda x: x
if _IS_PYTHON_3:
u = identity
else:
import codecs
def u(string):
return codecs.unicode_escape_decode(string)[0]
getcontext().rounding = ROUND_HALF_EVEN
# Function Library
def GetRewardWeights(M, Rep=-1, Alpha=.1, Verbose=False):
"""Calculates the new reputations using Weighted Principal Components Analysis"""
if type(Rep) is int:
Rep = DemocracyCoin(M)
if Verbose:
print("****************************************************")
print("Begin 'GetRewardWeights'")
print("Inputs...")
print("Matrix:")
print(M)
import click
import csv
from decimal import Decimal, getcontext
import itertools
import numpy as np
getcontext().prec = 4 # Intentionally kept fuzzy to allow learning.
OFFSET_SEQ_DAYS = 5
VALIDATION_RATIO = 0.20 # Fraction of batches to reserve for validation
def get_rows(filename):
with open(filename, 'r') as file:
reader = csv.reader(file)
for row in reader:
yield row
def count_lines(filename):
i = 0
with open(filename, 'r') as file:
for i, l in enumerate(file, 1):
continue
return i
def compute_delta(new, old):
delta = (Decimal(new) - Decimal(old)) / (Decimal(old) + Decimal(0.0000001))
return delta
# last_char = char
# return len(num)
#def find_pattern(x):
# num = str(x)[2:-2]
# for i in xrange(len(num)-1,-1,-1):
# if num[i:] == num[i-len(num[i:]):i]:
# return len(num[i:])
# return -1
getcontext().prec = 2000
#0.14285714285714285714285714285714285714285714285714
most = 0
high = 0
num = 0
rval = 0
for i in xrange(11,1001):
#ans = Decimal(1)/Decimal(i)
num = str(Decimal(1)/Decimal(i))[:-1]
rval = -1
for z in xrange(len(num)-1,-1,-1):
if num[z:] == num[z-len(num[z:]):z]:
rval = len(num[z:])
break
if rval > most:
most = rval
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
""" 산술 콘텍스트의 정밀도를 변경해보는 예제
pages 465~469; 한글 기준
"""
import decimal
ctx = decimal.getcontext()
ctx.prec = 40
num = decimal.Decimal('1') / decimal.Decimal('3')
print(num) # 0.3333333333333333333333333333333333333333
print(num == +num) # True
ctx.prec = 29
print(num == +num) # False
print(+num) # 0.33333333333333333333333333333
def decimal(b: bytes, precision=16):
getcontext().prec = precision
return int(b)
return mismatch
# User Input parameters
LOGLEVEL = str(arcpy.GetParameterAsText(0)).upper()
LOGDIR = arcpy.GetParameterAsText(1)
CHECK_PROJ = arcpy.GetParameterAsText(2) # Boolean result received as text
HAZAREA_FC = arcpy.GetParameterAsText(3)
RIVERS_FC1 = arcpy.GetParameterAsText(4)
RIVERS_FC2 = arcpy.GetParameterAsText(5)
BUFFER_DIST = arcpy.GetParameterAsText(6) # buffer distance in meters
UPDATE_ONLY = arcpy.GetParameterAsText(7) # Boolean result received as text
# Tool Parameters
arcpy.env.addOutputsToMap = False
getcontext().prec = 4 # Set decimal precision
REQUIRED_FIELDS = ['RIVERS', 'RIVERS_BUFFER_DIST']
FILTER_FIELD = "RIVERS" # Which field must we filter on and check for?
RIVERSFEATCLASS_LIST = [
] # Empty list that will store the feature classes to process
RIVERSFEATLAYER_LIST = [] # Empty list that will store feature layers
# Append the Meters qualifier required for the buffer distance parameter
BUFFER_DISTM = BUFFER_DIST + " Meters"
COUNTER = 0
# Tool configuration:
# Set up the logging parameters and inform the user
DATE_STRING = time.strftime("%Y%m%d")
LOGFILE = unicode(LOGDIR + '\\' + DATE_STRING +
'_mcdatool.log').encode('unicode-escape')
MAXBYTES = 10485760 # 10MB
a = decimal.Decimal('0.1') + decimal.Decimal('0.10') + decimal.Decimal(
'0.10') - decimal.Decimal('0.30')
print(a)
#it’s also possible to create a decimal object from a floating point object
#conversion is exact but can sometimes yield a large default number of digits, unless they are fixed per the next section:
print(
decimal.Decimal(0.1) + decimal.Decimal(0.1) + decimal.Decimal(0.1) -
decimal.Decimal(0.3)) # will output : 2.775557561565156540423631668E-17
# TIP : In Python 3.3 and later, the decimal module was also optimized to improve its performance radically: the reported speedup for the
# new version is 10X to 100X, depending on the type of program benchmarked
# The precision is applied globally for all decimals created in the calling thread
decimal.getcontext(
).prec = 2 #now we will have 2 precession points ! i.e. 0.00 [2 digits after decimal point]
print(
decimal.Decimal(0.1) + decimal.Decimal(0.1) + decimal.Decimal(0.1) -
decimal.Decimal(0.3)) #closer to 0, but not 0.00 !
# better to pass on string to Decimal() constructor since passing on floats does not give required results (especially in monetary applications)
#it’s also possible to reset precision temporarily by using the with context manager statement.
# The precision is reset to its original value on statement exit
with decimal.localcontext() as ctx:
ctx.prec = 5
print(decimal.Decimal('1.00') / decimal.Decimal('3.00'))
print(decimal.Decimal('1.00') / decimal.Decimal('3.00'))
"""
TOPIC : Fractions
def tearDown(self):
# set up decimal precision to make comparisons easier
decimal_context = getcontext()
decimal_context.prec = self.__prev_decimal_prec
def split_transaction(node,
prevouts,
toAddrs,
txfeePer=DEFAULT_TX_FEE_PER_BYTE,
**kwargs):
"""
Create a transaction that divides the sum of all the passed utxos into all the destination addresses
pass:
node: (node object) where to send the RPC calls
prevouts: a single UTXO description dictionary, or a list of them
toAddrs: a list of strings specifying the output addresses
"sendtx=False" if you don't want to transaction to be submitted.
Returns (transaction in hex, Vin list, Vout list)
"""
if type(prevouts) == type({}):
prevouts = [
prevouts
] # If the user passes just one transaction then put a list around it
txid = None
inp = []
decContext = decimal.getcontext().prec
try: # try finally block to put the decimal precision back to what it was prior to this routine
decimal.getcontext(
).prec = 8 + 8 # 8 digits to get to 21million, and each bitcoin is 100 million satoshis
amount = Decimal(0)
iamount = 0
count = 0
for tx in prevouts:
inp.append({"txid": str(tx["txid"]), "vout": tx["vout"]})
amount += tx["amount"] * Decimal(BTC)
iamount += int(tx["amount"] * Decimal(BTC))
count += 1
assert (amount == iamount
) # make sure Decimal and integer math is consistent
txLen = (len(prevouts) * 100) + (len(toAddrs) * 100
) # Guess the tx Size
while 1:
outp = {}
if amount - Decimal(txfeePer * txLen
) < 0: # fee too big, find something smaller
txfeePer = (float(amount) / txLen) / 1.5
txfee = int(math.ceil(txfeePer * txLen))
amtPer = (Decimal(amount - txfee) /
len(toAddrs)).to_integral_value()
# print "amount: ", amount, " amount per: ", amtPer, "from :", len(prevouts), "to: ", len(toAddrs), "tx fee: ", txfeePer, txfee
for a in toAddrs[0:-1]:
if PerfectFractions:
outp[str(a)] = str(amtPer / Decimal(BTC))
else:
outp[str(a)] = float(amtPer / BTC)
a = toAddrs[-1]
amtPer = (amount - ((len(toAddrs) - 1) * amtPer)) - txfee
# print "final amt: ", amtPer
if PerfectFractions:
outp[str(a)] = str(amtPer / BTC)
else:
outp[str(a)] = float(amtPer / BTC)
totalOutputs = sum([Decimal(x) for x in outp.values()])
assert (totalOutputs < amount)
txn = node.createrawtransaction(inp, outp)
if kwargs.get("sendtx", True):
#print time.strftime('%X %x %Z')
try:
s = str(txn)
# print "tx len: ", len(binascii.unhexlify(s))
signedtxn = node.signrawtransaction(s)
txLen = len(
binascii.unhexlify(signedtxn["hex"])
) # Get the actual transaction size for better tx fee estimation the next time around
finally:
#print time.strftime('%X %x %Z')
pass
if signedtxn["complete"]:
try:
txid = node.sendrawtransaction(
signedtxn["hex"], True
) # In the unit tests, we'll just allow high fees
return (txn, inp, outp, txid)
except JSONRPCException as e:
tmp = e.error["message"]
(code, msg) = tmp.split(":")
if int(code) == 64: raise # bad transaction
if int(code) == 258: # txn-mempool-conflict
# we are reusing inputs so this is all the splitting we can do
return (txn, inp, outp, txid)
# print tmp
if e.error["code"] == -26: # insufficient priority
txfeePer = txfeePer * 2
print(str(e))
print(
"Insufficient priority, raising tx fee per byte to: ",
txfeePer)
continue
else:
raise
else:
for err in signedtxn["errors"]:
print(err["error"])
else:
return (txn, inp, outp, txid)
finally:
decimal.getcontext().prec = decContext
def setUp(self):
# set up decimal precision to make comparisons easier
decimal_context = getcontext()
self.__prev_decimal_prec = decimal_context.prec
decimal_context.prec = 4
self.plugin = Team
# usage type
self.usage_type = models.UsageType(
name='Teams',
symbol='Teams',
by_team=True,
type='BU',
)
self.usage_type.save()
# teams
self.team_time = models.Team(
name='T1',
billing_type='TIME',
show_percent_column=True,
)
self.team_time.save()
self.team_devices_cores = models.Team(
name='T2',
billing_type='DEVICES_CORES',
)
self.team_devices_cores.save()
self.team_devices = models.Team(
name='T3',
billing_type='DEVICES',
)
self.team_devices.save()
self.team_distribute = models.Team(
name='T4',
billing_type='DISTRIBUTE',
)
self.team_distribute.save()
self.teams = models.Team.objects.all()
# dateranges
self.daterange1 = models.TeamDaterange(
team=self.team_time,
start=date(2013, 10, 1),
end=date(2013, 10, 10),
)
self.daterange1.save()
self.daterange2 = models.TeamDaterange(
team=self.team_time,
start=date(2013, 10, 11),
end=date(2013, 10, 30),
)
self.daterange2.save()
# costs
# team time
up = models.UsagePrice(
type=self.usage_type,
cost=300,
forecast_cost=600,
start=date(2013, 10, 1),
end=date(2013, 10, 15),
team=self.team_time,
team_members_count=10,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=900,
forecast_cost=450,
start=date(2013, 10, 16),
end=date(2013, 10, 30),
team=self.team_time,
team_members_count=20,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=300,
forecast_cost=600,
start=date(2013, 10, 1),
end=date(2013, 10, 30),
team=self.team_devices_cores,
team_members_count=20,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=800,
forecast_cost=1600,
start=date(2013, 10, 1),
end=date(2013, 10, 10),
team=self.team_devices,
team_members_count=20,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=100,
forecast_cost=200,
start=date(2013, 10, 11),
end=date(2013, 10, 30),
team=self.team_devices,
team_members_count=10,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=3000,
forecast_cost=1500,
start=date(2013, 10, 1),
end=date(2013, 10, 15),
team=self.team_distribute,
team_members_count=10,
)
up.save()
up = models.UsagePrice(
type=self.usage_type,
cost=6000,
forecast_cost=3000,
start=date(2013, 10, 16),
end=date(2013, 10, 30),
team=self.team_distribute,
team_members_count=10,
)
up.save()
# ventures
self.venture1 = models.Venture(name='V1', venture_id=1, is_active=True)
self.venture1.save()
self.venture2 = models.Venture(name='V2', venture_id=2, is_active=True)
self.venture2.save()
self.venture3 = models.Venture(name='V3', venture_id=3, is_active=True)
self.venture3.save()
self.ventures = models.Venture.objects.all()
# ventures percentage (only for time team)
percentage = (
(self.daterange1, [30, 30, 40]),
(self.daterange2, [20, 50, 30]),
)
for team_daterange, percent in percentage:
for venture, p in zip(self.ventures, percent):
tvp = models.TeamVenturePercent(
team_daterange=team_daterange,
venture=venture,
percent=p,
)
tvp.save()
from copy import deepcopy
from decimal import Decimal, getcontext
from src.hyperplane import Hyperplane
from src.vector import Vector
getcontext().prec = 15
class LinearSystem(object):
ALL_PLANES_MUST_BE_IN_SAME_DIM_MSG = 'All planes in the system should live in the same dimension'
NO_SOLUTIONS_MSG = 'No solutions'
INF_SOLUTIONS_MSG = 'Infinitely many solutions'
NO_NONZERO_ELTS_FOUND_MSG = 'No nonzero elements found'
def __init__(self, planes):
try:
d = planes[0].dimension
for p in planes:
assert p.dimension == d
self.planes = planes
self.dimension = d
except AssertionError:
raise Exception(self.ALL_PLANES_MUST_BE_IN_SAME_DIM_MSG)
def swap_rows(self, row1, row2):
temp = self[row1]
self[row1] = self[row2]
def check_d2d_reward_discount_py(self, nowprice, vipprice, isgenba=0):
if isgenba == 0:
member_discount = 0.95
bronze_discount = 0.92
silver_discount = 0.88
gold_discount = 0.85
platinum_discount = 0.8
else:
member_discount = 0.98
bronze_discount = 0.96
silver_discount = 0.94
gold_discount = 0.92
platinum_discount = 0.9
print("now price " + nowprice)
nprice = re.sub('[!@#$]', '', nowprice)
print("vip price " + vipprice)
vprice = re.sub('[!@#$]', '', vipprice)
#convert to float type
f_nprice = float(nprice)
f_vprice = float(vprice)
decimal.getcontext().rounding = decimal.ROUND_UP
# decimal.getcontext().prec = 3
# print decimal.getcontext()
if f_nprice < 9.99:
# print "member_discount"
f_nprice = f_nprice * member_discount
f_nprice = decimal.Decimal(f_nprice).quantize(Decimal("1.0"))
f_vprice = decimal.Decimal(f_vprice).quantize(Decimal("1.0"))
if float(f_nprice) == float(f_vprice):
# print "pass"
status = 1
else:
# print "fail"
# print f_nprice
# print f_vprice
status = 0
elif 9.99 <= f_nprice < 19.99:
# print "bronze_discount"
f_nprice = f_nprice * bronze_discount
f_nprice_2 = decimal.Decimal(f_nprice).quantize(Decimal("1.0"))
f_vprice = decimal.Decimal(f_vprice).quantize(Decimal("1.0"))
if float(f_nprice_2) == float(f_vprice):
# print "pass"
status = 1
else:
# print "fail"
# print f_nprice_2
# print f_vprice
status = 0
elif 19.99 <= f_nprice < 29.99:
# print "silver_discount"
f_nprice = f_nprice * silver_discount
f_nprice_2 = decimal.Decimal(f_nprice).quantize(Decimal("1.0"))
f_vprice = decimal.Decimal(f_vprice).quantize(Decimal("1.0"))
if float(f_nprice_2) == float(f_vprice):
# print "pass"
status = 1
else:
# print "fail"
# print f_nprice_2
# print f_vprice
status = 0
elif 29.99 <= f_nprice < 59.99:
# print "gold_discount"
f_nprice = f_nprice * gold_discount
f_nprice_2 = decimal.Decimal(f_nprice).quantize(Decimal("1.0"))
f_vprice = decimal.Decimal(f_vprice).quantize(Decimal("1.0"))
if float(f_nprice_2) == float(f_vprice):
# print "pass"
status = 1
else:
# print "fail"
# print f_nprice_2
# print f_vprice
status = 0
elif f_nprice >= 59.99:
# print "platinum_discount"
f_nprice = f_nprice * platinum_discount
f_nprice_2 = decimal.Decimal(f_nprice).quantize(Decimal("1.0"))
f_vprice = decimal.Decimal(f_vprice).quantize(Decimal("1.0"))
if float(f_nprice_2) == float(f_vprice):
# print "pass"
status = 1
else:
# print "fail"
# print f_nprice_2
# print f_vprice
status = 0
else:
print("exception happen")
return status
def truncate_digits(cls, in_number: float, max_digits: int) -> float:
"""Restrict maximum decimal digits by removing them"""
getcontext().prec = max_digits
working_num = int(Decimal(str(in_number)) * Decimal(Decimal("10") ** Decimal(str(max_digits))))
return working_num / (10 ** max_digits)
def pdf_get_all_pageinfo(infile):
pdf = pypdf.PdfFileReader(infile)
getcontext().prec = 6
return [_pdf_get_pageinfo(infile, n) for n in range(pdf.numPages)]
import bisect
from collections import deque
from copy import deepcopy
import decimal
import heapq
from itertools import combinations, permutations
from itertools import combinations_with_replacement
import sys
import math
from sys import modules
sys.setrecursionlimit(100_000)
input = lambda: sys.stdin.readline().rstrip()
decimal.getcontext().rounding = decimal.ROUND_HALF_UP
test = True
if test:
try:
sys.stdin = open('input_data.txt', 'r')
print('sys.stdin = input.txt')
except FileNotFoundError:
pass
directions = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1),
(-1, -1)]
n, fm, k = map(int, input().split())
q = deque()
for _ in range(fm):
r, c, m, s, d = map(int, input().split())
q.append((r - 1, c - 1, m, s, d))
def decimal_to_precision(n,
rounding_mode=ROUND,
precision=None,
counting_mode=DECIMAL_PLACES,
padding_mode=NO_PADDING):
assert precision is not None and isinstance(precision, numbers.Integral)
assert rounding_mode in [TRUNCATE, ROUND]
assert counting_mode in [DECIMAL_PLACES, SIGNIFICANT_DIGITS]
assert padding_mode in [NO_PADDING, PAD_WITH_ZERO]
context = decimal.getcontext()
precision = min(context.prec - 2, precision)
# all default except decimal.Underflow (raised when a number is rounded to zero)
context.traps[decimal.Underflow] = True
context.rounding = decimal.ROUND_HALF_UP # rounds 0.5 away from zero
dec = decimal.Decimal(n)
string = str(dec)
precise = None
def power_of_10(x):
return decimal.Decimal('10')**(-x)
if rounding_mode == ROUND:
if counting_mode == DECIMAL_PLACES:
precise = str(dec.quantize(
power_of_10(precision))) # ROUND_HALF_EVEN is default context
elif counting_mode == SIGNIFICANT_DIGITS:
q = precision - dec.adjusted() - 1
sigfig = power_of_10(q)
if q < 0:
string_to_precision = string[:precision]
# string_to_precision is '' when we have zero precision
below = sigfig * decimal.Decimal(
string_to_precision if string_to_precision else '0')
above = below + sigfig
precise = str(min((below, above), key=lambda x: abs(x - dec)))
else:
precise = str(dec.quantize(sigfig))
elif rounding_mode == TRUNCATE:
# Slice a string
if counting_mode == DECIMAL_PLACES:
before, after = string.split('.') if '.' in string else (string,
'')
precise = before + '.' + after[:precision]
elif counting_mode == SIGNIFICANT_DIGITS:
if precision == 0:
return '0'
dot = string.index('.') if '.' in string else 0
start = dot - dec.adjusted()
end = start + precision
# need to clarify these conditionals
if dot >= end:
end -= 1
precise = string[:end].ljust(dot, '0')
precise = precise.rstrip('.')
if padding_mode == NO_PADDING:
return precise.rstrip('0').rstrip('.') if '.' in precise else precise
elif padding_mode == PAD_WITH_ZERO:
if '.' in precise:
if counting_mode == DECIMAL_PLACES:
before, after = precise.split('.')
return before + '.' + after.ljust(precision, '0')
elif counting_mode == SIGNIFICANT_DIGITS:
fsfg = len(
list(
itertools.takewhile(lambda x: x == '.' or x == '0',
precise)))
if '.' in precise[fsfg:]:
precision += 1
return precise[:fsfg] + precise[fsfg:].rstrip('0').ljust(
precision, '0')
else:
if counting_mode == SIGNIFICANT_DIGITS:
if precision > len(precise):
return precise + '.' + (precision - len(precise)) * '0'
elif counting_mode == DECIMAL_PLACES:
if precision > 0:
return precise + '.' + precision * '0'
return precise
- prázdné mapování ({})
"""
xl = 'abcdefghchijklmno'
'd' in xl #true
'd' not in xl #false
##### decimal #####
# je to supr věc, můžu si zvolit přesnost výpočtů jakou chci
import decimal
D = decimal.Decimal
a = D(1)/D(7) #0.1428571428571428571428571429
print(a)
decimal.getcontext().prec = 5
# decimal.getcontext() vrací aktuální nastavení
print(D(1)/D(7)) #0.14286
decimal.getcontext().prec = 28
D(str(3 * 0.1)) - D('0.3') #0.0 (bez decimal by to vyhodilo komplexní číslo, což nemáme rádi a nechceme
D('1.30') + D('1.20') #2.50 -> drží nastavený počet významných míst
D('-Infinity') + D('-Infinity') #-Infinity
D(1).exp() #Decimal('2.718281828459045235360287471')
#umi i treba ln nebo sqrt
##### fractions #####
import fractions
#dalsi supercool vec, umi pracovat se zlomky
F = fractions.Fraction
F('-16/10') + F('3/5') #Fraction(-1/1)
def get_random_num():
x = [random.random()]
decimal.getcontext().prec = 16
return decimal.Decimal(x[0]) * 1
"""hum E1011 on .prec member is justifiable since Context instance are built using setattr/locals :( 2007/02/17 update: .prec attribute is now detected by astroid :o) """ from __future__ import print_function import decimal decimal.getcontext().prec = 200 print(decimal.getcontext().prec)
'''
Violates the spirit of the problem. Thanks python for being the best
'''
import decimal
if __name__ == '__main__':
decimal.getcontext().prec = 110
out = 0
for i in range(2, 100):
if int(i**.5)**2 == i:
continue
d = decimal.Decimal(i)**decimal.Decimal(.5)
val = str(d).replace('.', '')[:100]
v = sum([int(i) for i in list(val)])
out += v
print(out)
# only ufixed256x80 type supports 2-80 decimals
('reflect', Decimal(2**256 - 1) / 10**80), # maximum allowed value
('reflect', Decimal(1) / 10**80), # smallest non-zero value
# minimum value (for ufixed8x1)
('reflect_short_u', 0),
# maximum value (for ufixed8x1)
('reflect_short_u', Decimal('25.5')),
),
)
def test_reflect_fixed_value(web3, fixed_reflection_contract, function, value):
contract_func = fixed_reflection_contract.functions[function]
reflected = contract_func(value).call({'gas': 420000})
assert reflected == value
DEFAULT_DECIMALS = getcontext().prec
@pytest.mark.parametrize(
'function, value, error',
(
# out of range
('reflect_short_u', Decimal('25.6'), "no matching argument types"),
('reflect_short_u', Decimal('-.1'), "no matching argument types"),
# too many digits for *x1, too large for 256x80
('reflect', Decimal('0.01'), "no matching argument types"),
# too many digits
('reflect_short_u', Decimal('0.01'), "no matching argument types"),
(
'reflect_short_u',
def __init__(self,
start: tc.optional(tc.any(int, float)) = None,
stop: tc.optional(tc.any(int, float)) = None,
step: tc.optional(tc.any(int, float)) = None,
num: tc.optional(int) = None,
function: tc.optional(callable) = None,
precision: tc.optional(int) = None,
custom_spec=None):
self.custom_spec = custom_spec
if self.custom_spec:
# Assumes receiver of SampleIterator will get this and know what to do with it,
# therefore no other attributes are needed and, to avoid confusion, they should not be available;
# so just assign and return.
return
self._precision = precision or SAMPLE_SPEC_PRECISION
# Save global precision for later restoration
_global_precision = getcontext().prec
# Set SampleSpec precision
getcontext().prec = self._precision
if function is None:
if start is None or stop is None:
raise SampleIteratorError(
"If 'function' is not specified, then 'start' and 'stop' must be "
"specified.")
if num is None and step is not None:
num = int(Decimal(1.0) + Decimal(stop - start) / Decimal(step))
# num = 1.0 + (stop - start) / step
elif step is None and num is not None:
step = (Decimal(stop) - Decimal(start)) / (num - 1)
elif num is None and step is None:
raise SampleIteratorError(
"Must specify one of {}, {} or {}.".format(
repr('step'), repr('num'), repr('function')))
else:
if not np.isclose(num, 1.0 + (stop - start) / step):
raise SampleIteratorError(
"The {} ({}) and {} ({}} values specified are not comaptible."
.format(repr('step'), step, repr('num'), num))
elif callable(function):
_validate_function(self, function)
if start is not None:
raise SampleIteratorError(
"Only one of {} ({}) and {} ({}} may be specified.".format(
repr('start'), start, repr('function'), function))
if step is not None:
raise SampleIteratorError(
"Only one of {} ({}) and {} ({}} may be specified.".format(
repr('step'), step, repr('function'), function))
else:
raise SampleIteratorError(
"{} is not a valid function for {}.".format(
function, self.__name__))
# FIX: ELIMINATE WHEN UPGRADING TO PYTHON 3.5.2 OR 3.6, (AND USING ONE OF THE TYPE VERSIONS COMMENTED OUT ABOVE)
# Validate entries of specification
#
self.start = start
self.stop = stop
self.step = step
self.num = num
self.function = function
# Restore global precision
getcontext().prec = _global_precision
def getRMSValue(self, dataPoints):
getcontext().prec = 5
return np.sqrt(np.mean(np.square(dataPoints)))
def __init__(self, *args, **kwargs):
super(Person, self).__init__(*args, **kwargs)
money_context = getcontext()
money_context.prec = 16
money_context.rounding = ROUND_FLOOR
#coding:utf-8
"""
Pi = SUM k=0 to infinity 16^-k [ 4/(8k+1) - 2/(8k+4) - 1/(8k+5) - 1/(8k+6) ]
ref: https://www.math.hmc.edu/funfacts/ffiles/20010.5.shtml
https://github.com/Flowerowl/Projects/blob/master/solutions/numbers/find_pi_to_the_nth_digit.py
"""
from __future__ import division
import math
from decimal import Decimal as D
from decimal import getcontext
getcontext().prec = 400
MAX = 10000
pi = D(0)
for k in range(MAX):
pi += D(math.pow(16, -k)) * (D(4 / (8 * k + 1)) - D(2 / (8 * k + 4)) -
D(1 / (8 * k + 5)) - D(1 / (8 * k + 6)))
print('PI=', pi)
# Precision and Rounding
# ctx = decimal.getcontext() --> context (global in the case)
# ctx.prec --> get or set the precision (value is in int)
# ctx.rounding() --> get or set the rounding mechanism (value is a string)
# --> In this we have the following rounding algorithms:
# - ROUND_UP (rounds away from zero)
# - ROUND_DOWN (rounds towards zero)
# - ROUND_CEILING (round to ceiling, towards + inf)
# - ROUND_FLOOR (round to floor, towards -inf)
# - ROUND_HALF_UP (rounds to nearest, ties away from zero)
# - ROUND_HALF_DOWN (rounds to nearest, ties towards zero)
# - ROUND_HALF_EVEN (rounds to nearest, ties to even)
print('\n\n----Decimals----')
print('----Context----')
g_ctx = decimal.getcontext()
print(g_ctx)
g_ctx.rounding = decimal.ROUND_HALF_DOWN
# or g_ctx.rounrding = 'ROUND_HALF_UP'
print(g_ctx)
print('type(decimal.getcontext()): ', type(g_ctx))
print('type(decimal.localcontext()): ', type(decimal.localcontext()))
# which is similar to default (or global) context in this case
x = Decimal('1.25')
y = Decimal('1.35')
# using context manager of localcontext
print('----Context Manager----')
with decimal.localcontext() as ctx:
ctx.prec = 6
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
"input_video_file",
help="clip to load"
)
parser.add_argument(
"input_label_file",
help="label to load"
)
parser.add_argument(
"output_file_prefix",
help="Output file path."
)
parser.add_argument(
"convert_video",
help="Want to convert video (y/n ?)."
)
parser.add_argument(
"width",
help="Scale to resize images and labels."
)
parser.add_argument(
"height",
help="Scale to resize images and labels."
)
parser.add_argument(
"ignore_smaller",
help="ignore labels that are smaller than what is specified."
)
args = parser.parse_args()
getcontext().prec = 3
capture = cv2.VideoCapture(args.input_video_file)
orig_width = capture.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)
orig_height = capture.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)
scale_x = float(orig_width) / float(args.width)
scale_y = float(orig_height) / float(args.height)
print scale_x, scale_y
min_size = args.ignore_smaller
# LABEL
label_file = np.loadtxt(args.input_label_file)
not_labbeled_list = []
for index in range(0,int(np.amax(label_file[:,0]))):
# print index
# gt_file = open(args.output_file_prefix + '_' + str(index) + '.txt', 'w')
# Check which lines have index "index"
index_lookup = (label_file[:, 0] == index * np.ones_like(label_file[:, 0]))
index_lookup = index_lookup.astype(int)
if np.count_nonzero(index_lookup) != 0:
gt_file = open(args.output_file_prefix + '_' + str(index) + '.txt', 'w')
# pass
# print np.nonzero(index_lookup)
for nonz_index in range(0,np.count_nonzero(index_lookup.astype(int))):
if min_size == 0:
position_to_read = int(np.nonzero(index_lookup)[0][nonz_index])
left_number = float(label_file[position_to_read, 1]) / float(scale_x)
top_number = float(label_file[position_to_read, 2])/float(scale_y)
right_number = (float(label_file[position_to_read, 3]) / float(scale_x) + float(label_file[position_to_read, 1]) / float(scale_x))
bottom_number = float(label_file[position_to_read, 2]) / float(scale_y) + float(label_file[position_to_read, 4]) / float(scale_y)
left = "%.2f" % left_number
top = "%.2f" % top_number
right = "%.2f" % right_number
bottom = "%.2f" % bottom_number
gt_file.write('Car' + ' ' + '0.00' + ' '+'0' + ' ' + '0.00'+' ' + str(left)+' '+ str(top) + ' ' + str(right) + ' ' + str(bottom) + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00\n')
# class truncated occluded alpha left top right bottom
else:
position_to_read = int(np.nonzero(index_lookup)[0][nonz_index])
if float((label_file[position_to_read, 3])) > float(min_size) and float(label_file[position_to_read, 4]) > float(min_size):
left_number = float(label_file[position_to_read, 1]) / float(scale_x)
top_number = float(label_file[position_to_read, 2]) / float(scale_y)
right_number = (float(label_file[position_to_read, 3]) / float(scale_x) + float(label_file[position_to_read, 1]) / float(scale_x))
bottom_number = float(label_file[position_to_read, 2]) / float(scale_y) + float(label_file[position_to_read, 4]) / float(scale_y)
left = "%.2f" % left_number
top = "%.2f" % top_number
right = "%.2f" % right_number
bottom = "%.2f" % bottom_number
gt_file.write('Car' + ' ' + '0.00' + ' ' + '0' + ' ' + '0.00' + ' ' + str(left) + ' ' + str(top) + ' ' + str(right) + ' ' + str(
bottom) + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00' + ' ' + '0.00\n')
else:
pass
gt_file.close()
elif np.count_nonzero(index_lookup) == 0:
not_labbeled_list = np.append(not_labbeled_list, index)
print('not_labbeled_list ', not_labbeled_list)
if args.convert_video == 'y':
# VIDEO
# capture = cv2.VideoCapture(args.input_video_file)
# print capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)
for index in range(0, int(capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))):
# capture.set(cv2.cv.CV_CAP_PROP_POS_FRAMES, index)
print capture.get(cv2.cv.CV_CAP_PROP_POS_FRAMES)
rect , img = capture.read()
if np.any(not_labbeled_list == index * np.ones_like(not_labbeled_list)):
pass
else:
img = cv2.resize(img,(int(args.width), int(args.height)))
cv2.imwrite(args.output_file_prefix + '_' + str(index) + '.jpg', img)
import sys
import random
import FormulaSolidityPort
from decimal import Decimal
from decimal import getcontext
getcontext(
).prec = 80 # 78 digits for a maximum of 2^256-1, and 2 more digits for after the decimal point
def formulaTest(supply, balance1, weight1, balance2, weight2, amount1):
amount2 = FormulaSolidityPort.crossReserveTargetAmount(
balance1, weight1, balance2, weight2, amount1)
amount3 = FormulaSolidityPort.crossReserveTargetAmount(
balance2 - amount2, weight2, balance1 + amount1, weight1, amount2)
before, after = amount1, amount3
if after > before:
error = ['Implementation Error:']
error.append('supply = {}'.format(supply))
error.append('balance1 = {}'.format(balance1))
error.append('weight1 = {}'.format(weight1))
error.append('balance2 = {}'.format(balance2))
error.append('weight2 = {}'.format(weight2))
error.append('amount1 = {}'.format(amount1))
error.append('amount2 = {}'.format(amount2))
error.append('amount3 = {}'.format(amount3))
error.append('before = {}'.format(before))
error.append('after = {}'.format(after))
raise BaseException('\n'.join(error))
return Decimal(after) / Decimal(before)