def find_interval(self, y): order = int(y, 2) # convert to integer n = self.msg_len if n != len(y): print("ERROR! Y has invalid length:{}".format(y)) exit() # prob of intervals to be scaled up unit_prob = 1 / 2**n lb = bf.BigFloat(order) / 2**n ub = bf.BigFloat(order + 1) / 2**n return order, lb, ub
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 check_ending(self): v = self.peak # boundaries of decoded real number bin_seq, order = self.real_to_bin(v, len(self.seq)) # bounaries of pmf l = len(bin_seq) prob_lower_bound = bf.BigFloat(order) / 2**l prob_upper_bound = bf.BigFloat(order + 1) / 2**l p1 = self.tree.PMF(prob_lower_bound) p2 = self.tree.PMF(prob_upper_bound) return True if p2 - p1 > 1 - self.errP else False
def degdist_bigfloat(self, maxdeg, n, mindeg=0): """Returns the degree distribution from 0 to maxdeg degree. It should be use with the (iterated) link probability measure. Parameters: maxdeg: the maximal degree for we calculate the degree distribution n: the size of the network (the number of vertices) Returns: rho: the degree distribution as a list with length of maxdeg+1. The index k gives the probability of having degree k. """ assert isinstance(n, int) and isinstance(maxdeg, int) and n > maxdeg import bigfloat context = bigfloat.Context(precision=10) divs = self.divs n_intervals = len(divs) lengths = [divs[i] - divs[i - 1] for i in xrange(1, n_intervals)] lengths.insert(0, divs[0]) log_lengths = numpy.log(lengths) # Eq. 5, where ... avgdeg = [ bigfloat.BigFloat(n * sum( [self.probs[i][j] * lengths[j] for j in xrange(n_intervals)]), context=context) for i in xrange(n_intervals) ] #log_factorial = [ 0.5*bigfloat.log(2*math.pi, context=context) + (d+.5)*bigfloat.log(d, context=context) - d # for d in xrange(1,maxdeg+1) ] log_factorial = [ bigfloat.log(bigfloat.factorial(k), context=context) for k in xrange(1, maxdeg + 1) ] log_factorial.insert(0, 0) rho = [bigfloat.BigFloat(0, context=context)] * (maxdeg + 1) # Eq. 4 for i in xrange(n_intervals): # Eq. 5 log_rho_i = [ (bigfloat.mul(k, bigfloat.log(avgdeg[i]), context=context) - log_factorial[k] - avgdeg[i]) for k in xrange(mindeg, maxdeg + 1) ] log_rho_i_length = [ log_rho_i[k] + log_lengths[i] for k in xrange(mindeg, maxdeg + 1) ] for k in xrange(mindeg, maxdeg + 1): rho[k] += bigfloat.exp(log_rho_i_length[k], context=context) return rho
def get_noise(obj): if float(obj.token.value).is_integer and float( obj.token.value) == obj.token.value: return 0 if bf.sub(bf.BigFloat(obj.token.value, bf.precision(113)), bf.BigFloat(obj.token.value, bf.precision(50)), bf.precision(1024)) == 0: return 0 v = math.log(abs(obj.token.value), 2) if (v - math.floor(v) != 0.0): if (obj.token.value <= 0): return -pow(2, math.floor(v)) else: return pow(2, math.floor(v)) return 0.0 #obj.token.value
def run_benchmark(log_error_bound: int, benchmark: Benchmark, configuration_increment: Optional[Callable] = None, use_ad: bool = False): exact_program, variables = benchmark.benchmark(), benchmark.variables init_prec = 50 context = bf.RoundTowardZero + bf.precision(100000) assert log_error_bound < 0, "Log error bound should be negative!" error_bound = bf.BigFloat(f'0.{"0"*(-log_error_bound-1)}1', context) [var.sample() for var in variables] if use_ad: params = [ exact_program, error_bound, [init_prec] * exact_program.subtree_size() ] time, (num_refinements, precision_configuration) = time_wrap(evaluate_using_derivatives, params) else: params = [ exact_program, error_bound, configuration_increment, True, init_prec ] time, (num_refinements, precision_configuration) = time_wrap(evaluate, params) data = { "time": time.total_seconds(), "num_refinements": num_refinements, "log_error_bound": float(log_error_bound), "last_prec_config": precision_configuration, } return data
def FLOAT(self, t): #t.value = float(t.value) #t.value = np.float128(t.value) t.value = bf.BigFloat(t.value, bf.precision(128)) #t.value = t.value #print("value -> ", t.value) return t
def sum_likelihood_result(population): """ Sums all the likelihood results values on a population. Args: population : LIST[Chromosome(), Chromosome(), ...] A list filled with 'Chromosome' objects Returns: INT The sum of all likelihood results on a population """ with bf.quadruple_precision: total = bf.BigFloat("0.0") for i in range(0, len(population)): log_likelihood_result = bf.exp(bf.BigFloat(str(population[i].get_log_likelihood_result()))) total = bf.add(total, log_likelihood_result) return total
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 relative_likelihood_result_calculator(population): """ Given a population, this function calculates the relative likelihood result (it is a way to make the likelihood result bigger) to every chromosome. Args: population : LIST[Chromosome(), Chromosome(), ...] A list filled with 'Chromosome' objects """ with bf.quadruple_precision: total = sum_likelihood_result(population) for i in range(0, len(population)): log_likelihood_result = bf.exp(bf.BigFloat(str(population[i].get_log_likelihood_result()))) population[i].set_relative_likelihood_result(float(bf.div(log_likelihood_result, total)))
def get_score_for_metric(metric, metrics_summary): mean_metrics = metrics_summary['means'] if metric == 'mutual information': mi_metrics = metrics_summary['mean mutual inf'] mean_mi = mi_metrics['mutual inf'] # really conditional entropy return bf.BigFloat(mean_mi) # make sure we actually use bigfloat elif metric == 'total trace': return mean_metrics['mean total trace'] elif metric == 'final trace': return mean_metrics['mean final trace'] elif metric == 'final differential entropy': return mean_metrics['mean final differential entropy'] elif metric == 'total differential entropy': return mean_metrics['mean total differential entropy'] else: raise Exception("Unknown metric: {0}".format(metric))
def input(self, c: str, flags: object): # NEWIT запятой заведует объект числа # NEWIT если новый ввод, создаем новый объект числа if flags.IS_NEW_INPUT: self._value = bf.BigFloat() if c == '.': # Ошибка при вводе второй точки if self._value.comma: raise ValueError( "could not convert string to float: '{0}{1}'".format( self._value, c)) else: self._value.comma = c elif self._value.comma: self._value.fraction += c # в том числе отсекает ввод незанчащих 0 целой части # TODO ??? заменить self.__integer на len == 0 elif self._value.integer or c != '0': self._value.integer += c
for c in reversed(num_coeffs): num = num * z + c den = 0.0 for c in reversed(den_coeffs): den = den * z + c return num/den def gamma(z, g, N): return (z+g-0.5)**(z-0.5) / exp(z+g-0.5) * L(g, z, N) # Now express everything as a rational function; we want to be # able to figure out the coefficient of p_j z^k in the numerator. # Let's call this coefficient b(j, k). It depends on N. # b(j, N)[k] is the coefficient of p_j z^k in the numerator. # except: b(0, N)[k] is the coefficient of p_0/2 z^k in the numerator. p = 300 # bits of precision to use for computation g = bigfloat.BigFloat(6.024680040776729583740234375) N = 13 with bigfloat.precision(p): print("Numerator coefficients:") for c in Lg_num_coeffs(g, N): print(c) print("Denominator coefficients:") for c in Lg_den_coeffs(g, N): print(c)
def transmit(self, seq, max_channel_use=None, err_num=None, msg_len=4): # PMS settings self.msg_point = self.bin_to_real(seq) print("Message: {}, Px: {}".format(self.msg_point, self.XoverP)) # hamming code settings self.msg_len = msg_len # hamming code message length self.redundant_bits = HammingCode.calc_redundant_bits(msg_len) self.block_len = msg_len + self.redundant_bits print("Hamming Code ({}, {})".format(self.block_len, msg_len)) self.undecodable = False #TODO # h_err_p = self.XoverP # h_err_p = hamming_err_prob(self.XoverP, self.msg_len, self.block_len) h_err_p = hamming_err_prob(self.XoverP / 2, self.msg_len, self.block_len) # estimated by leading order # h_err_p = hamming_LOEP(self.XoverP, self.block_len) # h_err_p = 0.1179648 max_default_use = 500 MCU = max_channel_use if max_channel_use is not None else max_default_use for i in range(MCU): # np.random.seed(i) # debug mode # split probability tree, figure out which block msg belongs to msg_pmf = self.tree.PMF(self.msg_point) msg_seq, msg_order = self.real_to_bin(msg_pmf, msg_len) self.X = msg_seq # print("X: {}".format(self.X)) # hamming encoding: h = HammingCode(self.X) U = h.encode() # msg to be send thru channel # print("U: {}".format(U)) # Binary Symmetric Channel transmission: v = self.channel_transmit(U, err_num) # print("V: {}".format(v)) # hamming decoding: err_pos = h.detectError(v) # reverse order if err_pos == 0: # no error self.Y = self.X elif err_pos <= len(v): # able to recover u from v err_pos = len(v) - err_pos lost_bit = '1' if v[ err_pos] == '0' else '0' # flip the error bit correct_v = v[:err_pos] + lost_bit + v[err_pos + 1:] self.Y = h.decode(correct_v[::-1]) else: #TODO # print("Hamming code can't correct error in {} with error position".format(v, err_pos)) self.undecodable = True # self.Y = h.decode(v) continue # print("Y: {}".format(self.Y)) ''' Update probability: scale up the prob block msg belongs to, and scale down the other prob block. Divide tree into three parts by l- ower/upper bounds of Y's interval: the left part, the middle part, and the right part. Assume the crossover probability is a, so we s- hould scale up P([lb, ub]) by a, and scale down P([0,lb], [ub,1]) by 1 - a. The procedures consist of two steps: 1. Scale down the left part and scale up the other parts. 2. Scale up the middle part and scale down the right part. Note that if either the left part or the right part is empty, the situation is the same as standard posterior matching scheme. ''' # probability lower/upper bounds of Y's interval Y_order, Y_pmf_lb, Y_pmf_ub = self.find_interval(self.Y) if Y_order == 0: # left part is empty Y_node_ub = self.tree.quantile(Y_pmf_ub) self.peak = Y_node_ub.start_value self.tree = Y_node_ub.parent.rotate() self.tree.left.p, self.tree.right.p = 1 - h_err_p, h_err_p elif Y_order == 2**self.msg_len - 1: # right part is empty Y_node_lb = self.tree.quantile(Y_pmf_lb) self.peak = Y_node_lb.start_value self.tree = Y_node_lb.parent.rotate() self.tree.left.p, self.tree.right.p = h_err_p, 1 - h_err_p else: # nodes of lower/upper bounds of Y's interval Y_node_lb = self.tree.quantile(Y_pmf_lb) Y_node_ub = self.tree.quantile(Y_pmf_ub) # number of intervals in the left\right part left_num = Y_order right_num = 2**self.msg_len - 1 - Y_order unit_prob = bf.div(h_err_p, (2**self.msg_len - 1)) self.peak = (Y_node_lb.start_value + Y_node_ub.start_value) / 2 # step 1 self.tree = Y_node_lb.parent.rotate() self.tree.left.p = unit_prob * left_num self.tree.right.p = 1 - self.tree.left.p # step 2 sub = self.tree.right sub.parent = None self.tree.right = None sub = Y_node_ub.parent.rotate() sub_total = 1 - h_err_p + unit_prob * right_num sub.left.p = bf.BigFloat(1 - h_err_p) / sub_total sub.right.p = 1 - sub.left.p self.tree.right = sub sub.parent = self.tree # print("-"*80) # self.tree.visualize() if self.check_ending(): bin_seq, _ = self.real_to_bin(self.peak, len(self.seq)) return bin_seq, i + 1, self.block_len bin_seq, _ = self.real_to_bin(self.peak, len(self.seq)) print("You have reached the maximum expected channel use!") return bin_seq, MCU, self.block_len
means = metrics['means'] # multiply partial means and variances by number of bags num_bags = means['num_bags'] for key in agg_means: if key == 'num_bags': agg_means[key] += num_bags elif not key.startswith('stddev'): agg_means[key] += num_bags * means[key] # stddevs will be * 0 so ignore if args.compute_MI: # also expand mutual information same way mi = metrics['mean mutual inf'] mi_num_bags = mi['num_bags'] # add how many bags were comptued over agg_MI['num_bags'] += mi_num_bags agg_MI['mutual inf'] += mi_num_bags * bf.BigFloat(mi['mutual inf']) agg_MI['variance'] += mi_num_bags * bf.BigFloat(mi['variance']) # since variance is just mean of squared diffs # re-average to compute overall means total_num_bags_means = agg_means['num_bags'] for key in agg_means: if key == 'num_bags': continue agg_means[key] = agg_means[key]/total_num_bags_means if key.startswith('var'): # also insert a stddev key, should already exist or python complains stddev_key = 'stddev' + key[3:] agg_means[stddev_key] = agg_means[key]**0.5 if args.compute_MI: # re-average MI
def clear(self): # NEWIT просто создаем новый пустой объект self._value = bf.BigFloat()
def __init__(self, name: str): self.__name = name # буква регистра # TODO Можно закрыть изменение извне, если реализовать свойства в класса регистра Z ??? self._value = bf.BigFloat( ) # значение регистра как объект числа BigFloat
def norm(ts): vs = ts.values vs = [ 0.0-float( bigfloat.log10(bigfloat.BigFloat(v)) ) for v in vs] ts = pd.Series(vs,index=ts.index) return ts
codedfile.write(sigm) """ bytearray=np.ubyte(np.append(bytearray,sigma%(2**8))) #LSB of sigma bytearray=np.ubyte(np.append(bytearray, sigma*(2**(-8)))) #MSB of sigma """ #Convert prec in BigFloat to number of bytes in int: numbytes = int(np.ceil(prec / 8.0)) print("number of bytes in subband ", k, "and channel", chan, "=", numbytes, "for", numblocks, " samples") print("Hence bytes per sample: ", numbytes * 1.0 / numblocks) #Convert BigFloat number which encodes many samples into a byte array: for bytenum in range(numbytes): #print("bytenum=", bytenum) bytearray = np.append( bytearray, np.ubyte( encblock * (bigfloat.BigFloat(2)** 8))) #left shift by 8 bits, keep int part encblock = encblock * (bigfloat.BigFloat(2)** 8) % 1 #keep fractional part ba = struct.pack('B' * len(bytearray), *bytearray) #'B' for unsigned byte codedfile.write(ba) totalbytes += len(bytearray) numsamples = np.prod(x.shape) print("Total number of bytes=", totalbytes) print("Total number of samples:", numsamples) print("bytes per sample=", totalbytes * 1.0 / numsamples) print("Hence bis per sample=", 8 * 1.0 * totalbytes / numsamples)
def __init__(self, start_value, length, prob): self.start_value = bf.BigFloat(start_value) self.length, self.p = bf.BigFloat(length), bf.BigFloat(prob) self.parent, self.left, self.right = None, None, None