def interval_fifthroot(interval, context_down, context_up):
lower, upper = interval
fifthrt_down, fifthrt_up = bf.pow(lower, 0.2, context_down), bf.pow(
upper, 0.2, context_up)
out_interval = [fifthrt_down, fifthrt_up]
derivs = [bf.pow(lower, -0.8, context_down) / 5,
0], [0, bf.pow(upper, -0.8, context_up) / 5]
return out_interval, derivs
def interval_cuberoot(interval, context_down, context_up):
lower, upper = interval
sqrt_down, sqrt_up = bf.pow(lower, 1 / 3,
context_down), bf.pow(upper, 1 / 3, context_up)
out_interval = [sqrt_down, sqrt_up]
derivs = [bf.pow(lower, -2 / 3, context_down) / 3,
0], [0, bf.pow(upper, -2 / 3, context_up) / 3]
return out_interval, derivs
def interval_pow10(interval, context_down, context_up):
lower, upper = interval
ten_down, ten_up = bf.BigFloat("10", context_down), bf.BigFloat(
"10", context_up)
out_lower, out_upper = [
bf.pow(ten_down, lower, context_down),
bf.pow(ten_up, upper, context_up)
]
out_interval = [out_lower, out_upper]
derivs = [out_lower, 0], [0, out_upper]
return out_interval, derivs
def factorial(n, approx_threshold=100):
# start_time = time.time()
if approx_threshold < 0 or n < approx_threshold:
result = bf.factorial(n)
else:
result = math.sqrt(2 * math.pi * n) * bf.pow(n / math.e, n)
# end_time = time.time()
# print(end_time - start_time)
return result
def get_reserves_graphql(self,
token_a: str, token_b: str,
block_number: int) -> List[int]:
import requests
import bigfloat # type: ignore
(token0, token1) = UniswapV2Utils.sort_tokens(token_a, token_b)
pairs = self.get_pair(token_a, token_b)
query = """
{
pair (block: {number: %d},
id: "%s"
) {
id
reserve0
reserve1
token0 {
id
decimals
}
token1 {
id
decimals
}
createdAtTimestamp
}
}
""" % (block_number, pairs.lower())
request = requests.post(
'https://api.thegraph.com/subgraphs/name/{}'.format(self.subgraph_endpoint),
json={'query': query}
)
if request.status_code != 200:
raise Exception("Query failed to run by returning code of {}. {}".format(request.status_code, query))
j = request.json()['data']['pair']
reserve0 = int(bigfloat.round((bigfloat.BigFloat(j['reserve0']) * \
bigfloat.pow(10, int(j['token0']['decimals'])))))
reserve1 = int(bigfloat.round((bigfloat.BigFloat(j['reserve1']) * \
bigfloat.pow(10, int(j['token1']['decimals'])))))
return [reserve0, reserve1, int(j['createdAtTimestamp'])] \
if j['token0']['id'] == token_a.lower() \
else [reserve1, reserve0, int(j['createdAtTimestamp'])]
def GenTable(self):
for i in range(0, self.table_size):
idx = float(i) / self.table_size
h1 = 0.0
with precision(200):
h1 = bigfloat.pow(2.0, idx)
fm, fh, fl = split_double(h1)
#print("{", fh.hex(), ", ", fl.hex(), "},\n", endl='')
print("{", double_to_hex(fm), ", ", double_to_hex(fh), ", ",
double_to_hex(fl), "},")
if i % 16 == 0:
print("// i = %d" % i)
def lasum(self, x):
return 1 + sum(bigfloat.pow(x, f) / bigfloat.factorial(f) for f in range(1, self.f))
print((Fore.LIGHTBLUE_EX + 'M/D/1:' + Fore.GREEN + ' %f' + Style.RESET_ALL) % Wmd1)
mu1 = B / (1500 * 8)
mu2 = B / (64 * 8)
Es = 0.5 * (1 / mu1) + 0.5 * (1 / mu2)
Es2 = 0.5 * (1 / mu1) ** 2 + 0.5 * (1 / mu2) ** 2
Wmg1 = ((lamb * Es2) / 2 * (1 - (lamb * Es))) + Es
print((Fore.LIGHTBLUE_EX + 'M/G/1:' + Fore.GREEN + ' %f' + Style.RESET_ALL) % Wmg1)
rho = 1.0 * lamb / mu
som = 0
for i in range(0, K+1):
som += bigfloat.pow(rho, i)
pb = 1.0 * (bigfloat.pow(rho, K)) / som
lambm = (1 - pb)*lamb
Wmmk = (1.0 / lambm) * (
(rho * 1.0 / (1 - rho)) - 1.0 * ((K + 1) * bigfloat.pow(rho, (K + 1))) / (1 - bigfloat.pow(rho, (K + 1))))
print((Fore.LIGHTBLUE_EX + 'M/M/1/%d:' + Fore.GREEN + ' %f' + Style.RESET_ALL) % (K, Wmmk))
print((Fore.LIGHTBLUE_EX + 'M/M/1/%d:' + Fore.GREEN + ' %.2f%%' + Style.RESET_ALL) % (K, pb))
loss_probability = 100.0 * (tx.packets_sent-rx.packets_recv)/tx.packets_sent
average_delay = (1.0 * rx.overalldelay / rx.packets_recv)
trans_band = (1.0 * rx.overallbytes / simtime)
array_node1 += [{'lambda': lamb,
print('M/D/1: %f' % Wmd1)
mu1 = B / (1500 * 8)
mu2 = B / (64 * 8)
Es = 0.5 * (1 / mu1) + 0.5 * (1 / mu2)
Es2 = 0.5 * (1 / mu1)**2 + 0.5 * (1 / mu2)**2
Wmg1 += ((lam * Es2) / 2 * (1 - (lam * Es))) + Es
print('M/G/1: %f' % Wmg1)
row = 1.0 * lam / mu
som = 0
for i in range(0, k + 1):
som += bigfloat.pow(row, i)
pb += 1.0 * (bigfloat.pow(row, k)) / som
pbtmp = 1.0 * (bigfloat.pow(row, k)) / som
lambm = (1 - pbtmp) * lam
Wmmk += (1.0 / lambm) * ((row * 1.0 / (1 - row)) - 1.0 *
((k + 1) * bigfloat.pow(row,
(k + 1))) /
(1 - bigfloat.pow(row, (k + 1))))
print('M/M/1/%d: %f' % (k, Wmmk))
print('M/M/1/%d: %.2f%%' % (k, pb))
print("M/D/1: %f" % Wmd1)
mu1 = B / (1500 * 8)
mu2 = B / (64 * 8)
Es = 0.5 * (1 / mu1) + 0.5 * (1 / mu2)
Es2 = 0.5 * (1 / mu1) ** 2 + 0.5 * (1 / mu2) ** 2
Wmg1 += ((lam * Es2) / 2 * (1 - (lam * Es))) + Es
print("M/G/1: %f" % Wmg1)
row = 1.0 * lam / mu
som = 0
for i in range(0, k + 1):
som += bigfloat.pow(row, i)
pb += 1.0 * (bigfloat.pow(row, k)) / som
pbtmp = 1.0 * (bigfloat.pow(row, k)) / som
lambm = (1 - pbtmp) * lam
Wmmk += (1.0 / lambm) * (
(row * 1.0 / (1 - row))
- 1.0 * ((k + 1) * bigfloat.pow(row, (k + 1))) / (1 - bigfloat.pow(row, (k + 1)))
)
print("M/M/1/%d: %f" % (k, Wmmk))
print("M/M/1/%d: %.2f%%" % (k, pb))
print('M/D/1: %f' % Wmd1)
mu1 = 1.0 * B / (1500 * 8)
mu2 = 1.0 * B / (64 * 8)
Es = 0.5 * (1.0 / mu) + 0.5 * (1.0 / mu)
Es2 = 0.5 * (1.0 / mu)**2 + 0.5 * (1.0 / mu)**2
Wmg1 += ((lam * Es2) / 2 * (1 - (lam * Es))) + Es
print('M/G/1: %f' % Wmg1)
rho = 1.0 * lam / mu
som = 0
for i in range(0, k + 1):
som += bigfloat.pow(rho, i)
pb += (bigfloat.pow(rho, k)) / som
pbtmp = 1.0 * (bigfloat.pow(rho, k)) / som
lambm = (1 - pbtmp) * lam
Wmmk += (1.0 / lambm) * ((rho * 1.0 / (1 - rho)) - 1.0 *
((k + 1) * bigfloat.pow(rho,
(k + 1))) /
(1 - bigfloat.pow(rho, (k + 1))))
print('M/M/1/%d: %f' % (k, Wmmk))
print('M/M/1/%d: %.2f%%' % (k, pb))
import bigfloat
from bigfloat import precision as preci
# define double_to_hex (or float_to_hex)
def double_to_hex(f):
return hex(struct.unpack('<Q', struct.pack('<d', f))[0])
def hex_to_double(h):
return float(struct.unpack("<d",struct.pack("<Q",h))[0])
table_size = 1024
for i in range(0, table_size):
idx = float(i)/table_size
h1 = 0.0
with preci(80):
h1 = bigfloat.pow(2, idx)
myhex = double_to_hex(h1)
print("{ %s,"%myhex, end='')
b = int(myhex, base=16) & ~( (1 << 26) - 1)
print("\t0x%x,\t"%b, end='')
d = h1 - hex_to_double(b)
print("%s },"%double_to_hex(d))
if i % 16 == 0:
print()
mu1 = B / (1500 * 8)
mu2 = B / (64 * 8)
Es = 0.5 * (1 / mu1) + 0.5 * (1 / mu2)
Es2 = 0.5 * (1 / mu1)**2 + 0.5 * (1 / mu2)**2
Wmg1 = ((lamb * Es2) / 2 * (1 - (lamb * Es))) + Es
print((Fore.LIGHTBLUE_EX + 'M/G/1:' + Fore.GREEN + ' %f' +
Style.RESET_ALL) % Wmg1)
rho = 1.0 * lamb / mu
som = 0
for i in range(0, K + 1):
som += bigfloat.pow(rho, i)
pb = 1.0 * (bigfloat.pow(rho, K)) / som
lambm = (1 - pb) * lamb
Wmmk = (1.0 / lambm) * ((rho * 1.0 / (1 - rho)) - 1.0 *
((K + 1) * bigfloat.pow(rho, (K + 1))) /
(1 - bigfloat.pow(rho, (K + 1))))
print((Fore.LIGHTBLUE_EX + 'M/M/1/%d:' + Fore.GREEN + ' %f' +
Style.RESET_ALL) % (K, Wmmk))
print((Fore.LIGHTBLUE_EX + 'M/M/1/%d:' + Fore.GREEN + ' %.2f%%' +
Style.RESET_ALL) % (K, pb))
loss_probability = 100.0 * (tx.packets_sent -
