def theo_error_curve(m=80, R=20, s=0, saveimage=False): '''It computes the actual error and theoretical error in relative sense for a fixed m,s and R''' print(f'm:{m}, s:{s} and R:{R}') M = m f_m = [((-R)**k / (2**(k * s) * factorial(k))) for k in range(0, M + 1)] Error = np.zeros(M + 1) # theoretical error for idx, m in enumerate(np.arange(M + 1)): error = (power(R, m + 1) * np.exp(R / (2**s))) / (power(2, s * m) * factorial(m + 1)) Error[idx] = error plt.figure(figsize=(12, 9)) ax = plt.subplot(1, 1, 1) ax.plot(np.arange(M + 1), np.log10( np.abs((np.cumsum(f_m))**(2**s) - np.exp(-R)) / np.exp(-R)), '-k', lw=4, label=fr'Computed error') ax.plot(np.arange(M + 1), np.log10(Error), '--r', lw=4, label=fr'Theoretical error') #plt.plot(range(0,M+1),np.log10(np.absolute((1/np.cumsum(f_m))**(power(2,s))-np.exp(-R))/np.exp(-R)),'-k',lw=3,label = fr'relative error$'); #plt.axhline(y=np.log10(np.exp(-R)),xmin=0,ls='--',color = 'b',lw=2, label=fr'Order of $\exp({-R})$') #plt.axhline(y=np.log10(np.spacing(1)*0.5),xmin=0,ls='--',color = 'b',lw=2, label = r'$\epsilon_{mach}\approx 1\times 10^{-16}$') #machine precision ax.minorticks_on() ax.grid(which='minor', linestyle=':', linewidth='0.3', color='black') plt.grid(which='major', linestyle='-', linewidth='0.5', color='k') start, end = ax.get_xlim() ax.xaxis.set_ticks(np.arange(0, end, 10)) plt.xlabel('Truncation parameter $m$ for $T_m(-R/2^s)^{2^s}$', fontsize=24) plt.ylabel(r"$\log_{10}$ Relative Error", fontsize=24) #plt.title(fr'Relative Error for Composite Taylor for $s={s}$ at $z={-R}$',fontsize=18) plt.legend(loc=1, prop={'size': 25}) plt.tick_params(labelsize=14) plt.tight_layout() if saveimage: # creates a folder plots to save graphs in the folder path = r'C:\Users\xxxxx\OneDrive - Nexus365\Oxford Masters\Modules\Dissertation\Code\Candidate_no_1040706\plots\theoretical_plots' if not os.path.exists(path): os.mkdir(path) print('Folder `plots/theoretical_plots` is created\n') plt.savefig(path + f'/theo_s{s}.pdf', format='pdf', dpi=1200) plt.show()
def rsa(msg): pn = 7.0 qn = 17.0 nn = pn * qn t_of_n = (pn - 1)(qn - 1) ee = 17 dd = 2753 cc = math.power(msg, ee) % nn print cc mm = math.power(cc, dd) % nn print mm
def _optimalval(s, R): '''Calculating the truncation parameter m where we see line flattening''' e_mach = 0.5 * np.spacing(1) max_m = int(R / 2**s) #value of m where we have the largesr error delta = np.abs( np.exp(-R / 2**s) - ((-R / 2**s)**max_m) / factorial(max_m)) * e_mach #as shown in the above equation m = 0 error = R**(m + 1) / (power(2, s * (m + 1)) * factorial(m + 1)) while error > delta: m += 1 error = R**(m + 1) / (power(2, s * (m + 1)) * factorial(m + 1)) return m
def solve_for_lower_right(number, base): corner = power(base, 2) opposing_corner = power(base - 1, 2) + 1 middle_corner = corner - ((corner - opposing_corner) / 2) if number < middle_corner: if number <= opposing_corner + ((middle_corner - opposing_corner) / 2): return base - 1 - (number - opposing_corner) else: return base - 1 - (middle_corner - number) else: if number <= middle_corner + ((corner - middle_corner) / 2): return base - 1 - (number - middle_corner) else: return base - 1 - (corner - number)
def Distance(lon1, lat1, lon2, lat2): earth_padius = 6378.137 # 地球赤道半径(千米),地球平均半径=6371.004 千米 PI = 3.14159265358979324 s = 0 radlon1 = lon1 * PI / 180.0 radlon2 = lon2 * PI / 180.0 s = 2 * math.asin( math.sqrt( math.power(math.sin((radlon1 - radlon2) / 2), 2) + math.cos(radlon1) * math.cos(radlon2) * math.power(math.sin(((lat1 - lat2) * PI / 180.0) / 2), 2))) s = s * earth_padius return round(s * 1000, 2) # 精确到米
def solve_for_upper_left(number, base): corner = power(base, 2) opposing_corner = power(base - 1, 2) + 1 middle_corner = corner - ((corner - opposing_corner) / 2) if number < middle_corner: if number < opposing_corner + ceil( (middle_corner - opposing_corner) / 2): return base - 1 - (number - opposing_corner) else: return base - (middle_corner - number) else: if number < middle_corner + ceil((corner - middle_corner) / 2): return base - (number - middle_corner) else: return base - 1 - (corner - number)
def main(): number = 325489 base = ceil(sqrt(number)) if is_even(power(base, 2)): print(int(solve_for_upper_left(number, base))) else: print(int(solve_for_lower_right(number, base)))
def calculate_poster(j, data_item, alpha_set, mean_vec, variance_vec): # wait to be filled upper_probablity = (alpha_set[j] * np.exp(-(1.0 / 2) * np.dot( np.dot(data_item - np.array(mean_vec[j]), np.linalg.inv( variance_vec[j])), (data_item - np.array(mean_vec[j])).T))) / ( math.power(2 * math.pi, variance_vec[j].shape[0] / 2) * math.sqrt(np.linalg.det(variance_vec[j]))) lower_probablity = 0 for i in range(len(alpha_set)): lower_probablity += (alpha_set[i] * np.exp(-(1.0 / 2) * np.dot( np.dot(data_item - np.array(mean_vec[i]), np.linalg.inv(variance_vec[i])), (data_item - np.array(mean_vec[i])).T))) / ( math.power(2 * math.pi, variance_vec[i].shape[0] / 2) * math.sqrt(np.linalg.det(variance_vec[i]))) return upper_probablity / lower_probablity
def mv_trans_hot_temp(vol_value): """ tc的mv电压换算成热端温度 :param vol_value:电压值 :return dst_data:目标数据 """ para_below0_k = [ 0.0000000E+00, 2.5173462E+01, -1.1662878E+00, -1.0833638E+00, -8.9773540E-01, -3.7342377E-01, -8.6632643E-02, -1.0450598E-02, -5.1920577E-04, 0.0000000E+00 ] para_below500_k = [ 0.000000E+00, 2.508355E+01, 7.860106E-02, -2.503131E-01, 8.315270E-02, -1.228034E-02, 9.804036E-04, -4.413030E-05, 1.057734E-06, -1.052755E-08 ] para_above500_k = [ -1.318058E+02, 4.830222E+01, -1.646031E+00, 5.464731E-02, -9.650715E-04, 8.802193E-06, -3.110810E-08, 0.000000E+00, 0.000000E+00, 0.000000E+00 ] p_para = [] hot_temp = 0 if -3.852 <= vol_value < 0: p_para = para_below0_k elif 0 <= vol_value < 20.644: p_para = para_below500_k elif 20.644 <= vol_value <= 49.202: p_para = para_above500_k else: return 0x7FFF for i in range(0, 10): hot_temp += p_para[i] * power(vol_value, i) hot_temp = hot_temp * 10 return hot_temp
def cold_temp_trans_mv(cold_temp): """ tc的冷端温度转毫伏电压 :param cold_temp:冷端温度 :return dst_data:目标数据 """ cjcbelow_k = [ 0.000000000000E+00, 0.394501280250E-01, 0.236223735980E-04, -0.328589067840E-06, -0.499048287770E-08, -0.675090591730E-10, -0.574103274280E-12, -0.310888728940E-14, -0.104516093650E-16, -0.198892668780E-19, -0.163226974860E-22 ] cjcabove0_k = [ -0.176004136860E-01, 0.389212049750E-01, 0.185587700320E-04, -0.994575928740E-07, 0.318409457190E-09, -0.560728448890E-12, 0.560750590590E-15, -0.320207200030E-18, 0.971511471520E-22, -0.121047212750E-25 ] para_value_a0 = 0.118597600000E+00 para_value_a1 = -0.118343200000E-03 para_value_a2 = 0.126968600000E+03 if -270 <= cold_temp <= 0: return __calc_array_value(cold_temp, cjcbelow_k, 10) if 0 < cold_temp <= 1372: return __calc_array_value( cold_temp, cjcabove0_k, 10) + para_value_a0 * myexp( para_value_a1 * power(cold_temp - para_value_a2, 2)) return 0
def color2zs(self,color): """Get the range of values (zs) associated with a particular color, color. """ i = self.color_range.index(color) n = len(self.color_range) (xmin,ymin,xmax,ymax) = self.get_world() if self.yaxis.scale==LINEAR_SCALE: zmin = float(i)/float(n)*(ymax - ymin) + ymin zmax = float(i+1)/float(n)*(ymax - ymin) + ymin else: zmin = ymin*math.power(zmax/zmin,float(i)/float(n)) zmax = ymin*math.power(zmax/zmin,float(i+1)/float(n)) return zmin,zmax
def color2zs(self, color): """Get the range of values (zs) associated with a particular color, color. """ i = self.color_range.index(color) n = len(self.color_range) (xmin, ymin, xmax, ymax) = self.get_world() if self.yaxis.scale == LINEAR_SCALE: zmin = float(i) / float(n) * (ymax - ymin) + ymin zmax = float(i + 1) / float(n) * (ymax - ymin) + ymin else: zmin = ymin * math.power(zmax / zmin, float(i) / float(n)) zmax = ymin * math.power(zmax / zmin, float(i + 1) / float(n)) return zmin, zmax
def getNumberOfIntegers(L,R,K): L = int(L) R = int(R) n = [] for i in range(L+1,R+1): n.append(i) a = list(filter(check,n)) return len(a)%(math.power(10,9)+7)
def convert_size(size_bytes): """convert Btye Value to Pretty Value""" if size_bytes == 0: return "0B" size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB") size_index = int(floor(log(size_bytes, 1024))) return "%s%s" % ( round(size_bytes / power(1024, size_index), 2), size_name[size_index], )
def __calc_array_value(base, array, count): """ 转换公式计算 :param vol_value:电压值 :return dst_data:目标数据 """ ret_val = 0 for i in range(0, count): ret_val += array[i] * power(base, i) return ret_val
def returnSubsets(List, Sublist): numSublists = int(power(2, len(List))) bitArray = [int(digit) for digit in bin(numSublists - 1)[2:]] mostSigBit = int(power(2, len(bitArray) - 1)) msbIndx = len(bitArray) - 1 #iterate from 0b0000000 to 0b1111111 #each task is given a bit, when that bit is 1, add its value to the sum for this subset #append that as a new subset for i in range(1, numSublists): Indexes = [] sum = 0 j = mostSigBit k = msbIndx while j != 0: if i & j == j: sum += List[k][lengthIndx] Indexes.append(k) j /= 2 k -= 1 Sublist.append([sum,Indexes])
def great_deluge(self, number=1600, debug=False): # init solution generated by some constructive feasable h. solution = self.init_solution # best_solution = deepcopy( solution ) # best feasable solution best_solution_w_e = deepcopy(solution) # best feasable/unfeasable price best_price = price = self.count(solution) # best only feasable price best_price_w_e = price # debug statistics stats1 = { "switch two jobs": 0, "switch max and random jobs": 0, "switch two workers": 0, "rearange 2-5 workers": 0, "rearange greedy 2-5 workers": 0, } if debug: print "Begin parameters:" print self.count(solution, True) # level of decay level = ( best_price * self.START_LEVEL_MULTIPLY_BEST + self.AVERAGE_ERRORS * self.PENALTY_LIN + power(self.AVERAGE_ERRORS, self.PENALTY_EXP) ) # for number of interations or too low decay for i in range(number): level = self._decay(level) new_price, (new_solution, source) = self.select_step(self.available_steps(solution)) # if step is acceptable if new_price < price + level: price = new_price solution = new_solution # if step is optimal if new_price < best_price: # if new price doesnt have any error if self.count(new_solution, True)[2] == 0: best_price_w_e = min(new_price, best_price_w_e) best_solution_w_e = deepcopy(solution) if debug: print self.count(new_solution, True), " l:", round(level), source # best infeasable or feasable solution stats1[source] += 1 best_price = min(new_price, best_price) # best_solution = deepcopy( solution ) # finish condition if level <= max(self.PENALTY_LIN, 1): if debug: print "level", level break return self.output_format(best_solution_w_e)
def compute_R_and_phi_at(t): R = [0., 0., 0., 0., 0.] phi = [0., 0., 0., 0., 0.] T = floor(30.6001 * (1 + self.month + 12 * floor(1 / (self.month + 1.0) + 0.7)) ) + floor(365.25 * (self.year - floor(1 / (self.month + 1.0) + 0.7)) ) + self.day + t / 24 - 723258 h = 279.82 + 0.98564734 * T s = 78.16 + 13.17639673 * T p = 349.5 + 0.11140408 * T N = 208.1 + 0.05295392 * T p1 = 282.6 + 0.000047069 * T D = 90 for j in range(5): if j != 3: Xj = 0 Yj = 0 for i in range(11): Vij = 15 * j * t + Tmgpm.n1[j][i] * s + Tmgpm.n2[j][i] * h + Tmgpm.n3[j][i] * p + \ Tmgpm.n4[j][i] * N + Tmgpm.n5[j][i] * p1 + Tmgpm.n6[j][i] * D Xj += self.A[j][i] * cos(radians(Vij - self.G[j][i])) Yj += self.A[j][i] * sin(radians(Vij - self.G[j][i])) R[j] = sqrt(power(Xj, 2) + power(Yj, 2)) if R[j] == 0: phi[j] = 90 else: phi[j] = degrees(acos(Xj / R[j])) * sign( degrees(asin(Yj / R[j]))) return R, phi
def count(self, solution, parts=False): cost = 0 weight_penalty = copy(self.w_capacity) penalty_cost = 0 for worker_id in solution.keys(): for job_id in solution[worker_id]: cost += self.w_price[worker_id][job_id] weight_penalty[worker_id] -= self.w_space[worker_id][job_id] for item in weight_penalty: if item < 0: penalty_cost += self.PENALTY_LIN + power(-1 * item, self.PENALTY_EXP) if parts == True: return round(cost + penalty_cost), cost, round(penalty_cost) else: return float(cost + penalty_cost)
def mean_std(L, denom=0): """ - Takes a list L and returns a tuple of (mean, standard deviation) - If denom = 0, std will have a denominator of n. If denom = -1, it will have a denominator of n-1 """ try: L = [float(x) for x in L] avg = sum(L) / len(L) squared = [power(x - avg, 2) for x in L] std = sqrt(sum(squared) / (len(L) + denom)) except ZeroDivisionError: print "NO ENTRIES IN LIST!" avg = None std = None return avg, std
def getResult(entries): e = (float(eval(entries[epsilon].get(), evalDic))) e *= 8.85 * math.pow(10, -12) s = (float(eval(entries[sigma].get(), evalDic))) sc = (float(eval(entries[sigmaSubC].get(), evalDic))) u = 12.57 * math.pow(10, -7) h = (float(eval(entries[height].get(), evalDic))) w = (float(eval(entries[width].get(), evalDic))) f = (float(eval(entries[freq].get(), evalDic))) select = int(selector.get()) try: RS = math.sqrt(math.pi * f * (u / sc)) if (select == coax): R = (RS / (2 * math.pi)) * ((1 / h) + (1 / w)) L = (u / (2 * math.pi)) * (math.log(h / w)) G = (2 * math.pi * s) / (math.log(h / w)) C = (2 * math.pi * e) / (math.log(h / w)) elif (select == twoWire): x = math.log((h / w) + math.sqrt(math.power((h / w), 2) - 1)) R = (2 * RS) / (math.pi * w) L = (u / math.pi) * x G = (math.pi * s) / x C = (math.pi * e) / x elif (select == parPlate): R = (2 * RS) / w L = (u * h) / w G = (s * w) / h C = (e * w) / h result = "R' : {} \u03A9/m\n".format(R) result += "L' : {} H/m\n".format(L) result += "G' : {} S/m\n".format(G) result += "C' : {} F/m\n".format(C) b1.configure(text=result) except Exception as e: b1.configure(text="Error, input variables please\n" + str(e)) print(e)
import numpy as np #import numpy, for arrays import math #import math, for power and abs n = 10 #size of the arrays matrix = np.zeros((n, n)) #create an array of zeros of size n for i in range(n): #loop over i for j in range(n): #loop over j matrix[i][j] = math.power(math.abs(i - j), 2) #compute |i-j|^2 for i in range(n): #loop over i for j in range(n): #loop over j print(str(matrix[i][j]) + " ", end="") #print matrix element. print("")
def __init__(self, card): self.CurrentFanNum = card.BaseFanNum self.CurrentAtk = card.BaseAtk self.CurrentDef = card.BaseDef self.CurrentRep = card.BaseRep self.BarNormalization = power(card.Zhi*card.Chuang*card.Fu,1.0/3)
def distance(point1, point2): #计算两点距离 return power(point1.color[0]-point2.color[0],2)\ +power(point1.color[1]-point2.color[1],2)\ +power(point1.color[2]-point2.color[2],2)
def main(): # Input parameters args = get_args() num_tasks = int(args.tasks) if args and args.tasks else DEFAULT_NUM_TASKS num_workers = int( args.workers) if args and args.workers else DEFAULT_NUM_WORKERS high_quality_configuration = str( args.configuration ) if args and args.configuration else DEFAULT_HIGH_QUALITY_CONFIGURATION iterations = int(args.iterations) if args and args.iterations else 1 # Create results directory. DIR = './results/np_%d' % (num_workers) if not os.path.exists(DIR): os.makedirs(DIR) # Initial configuration, 0.1115 from parameter tuning team_likelihood = {} team_likelihood[2000] = 0.0255 team_likelihood[200] = 0.1115 team_likelihood[50] = 0.2515 team_likelihood[25] = 0.4215 # for collecting stats stats = {} initial_high_quality_percent = [] for i in range(num_tasks): stats[i] = ([], []) for i in range(iterations): is_first_iteration = True if i < 1 else False G = generate_points(num_workers, team_likelihood[num_workers], high_quality_configuration) # Get the layout of the graph. pos = nx.spring_layout(G, None, None, None, 30, 'weight', 200) # Plot the team size if is_first_iteration: plot_team_info(num_workers, G, DIR) if is_first_iteration: plot_points(G, pos, 0, DIR) # initial stats initial_average_state = sum([node.state for node in G]) / num_workers initial_high_quality = len( [node for node in G if node.state >= HIGH_QUALITY_THRESHOLD]) initial_high_quality_percent = initial_high_quality_percent + [ float(initial_high_quality) / num_workers ] #run the simulation for j in range(num_tasks): if is_first_iteration: plot_frequency = power(10, len(str(j)) - 1) if j % plot_frequency == 0: plot_points(G, pos, j, DIR) complete_task(G) # collect stats intermediate_average_state = [ 1.0 * sum([node.state for node in G]) / num_workers ] intermediate_high_quality = [ 1.0 * len([ node for node in G if node.state >= HIGH_QUALITY_THRESHOLD ]) ] stats[j] = (stats[j][0] + intermediate_average_state, stats[j][1] + intermediate_high_quality) # final stats output_sample = 100 file_name = '%s_employees_%s_training_strategy_%s_tasks' % ( num_workers, high_quality_configuration, num_tasks) with open('./%s_average_state.csv' % file_name, 'w') as csvfile: fieldnames = [ 'iteration', 'state', 'num_high_quality', 'high_quality_percent' ] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() for it, values in stats.items(): state_list = values[0] num_high_quality_list = values[1] state = float(sum(state_list) / len(state_list)) num_high_quality = float( sum(num_high_quality_list) / len(num_high_quality_list)) high_quality_percent = 100.0 * num_high_quality / num_workers if it % output_sample == 0: writer.writerow({ 'iteration': it, 'state': state, 'num_high_quality': num_high_quality, 'high_quality_percent': high_quality_percent }) with open('./initial_high_quality_%s.csv' % file_name, 'w') as csvfile: fieldnames = ['configuration', 'initial_percent'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() average = sum(initial_high_quality_percent) / len( initial_high_quality_percent) writer.writerow({ 'configuration': high_quality_configuration, 'initial_percent': average }) # make the gif, requires imageMagick system( '/opt/local/bin/convert -delay 50 results/*/random_graph_* -loop 1 ./%s.gif' % file_name)
def euclideanDistance(feature1,feature2): ''' 计算两个向量的欧式距离 ''' return math.sqrt(sum(math.power(feature1-feature2,2)))
def disEclud(vecA, vecB): return math.sqrt(sum(math.power(vecA - vecB)))
def linear_space(self, log_prob): return math.power(e, log_prob)
def mag(self, raw_mag): self.logger.info(f"Calculating SQM Mag") try: return 7.93 - 5 * (log10(power(10, (4.316 - (raw_mag / 5))) + 1)) except Exception as e: self.logger.error(e)
def get_distance(start, end): return math.sqrt( math.power(start[0] - end[0], 2) + math.power(start[1] - end[1], 2))
def euclidean_distance(vec1, vec2): ''' calculate euclidean distance ''' return math.sqrt(sum(math.power(vec1 - vec2, 2)))
def my_power(a, b): if not (isNumType(a) and isNumType(b)): return else: return math.power(a, b)
def kForce(freq): """ Function to assign to each restraint a force proportional to the underlying experimental value. """ return power(fabs(freq), 0.5 )
def hypothesisTest(self, seq1, seq2, totalSeq1, totalSeq2): if (seq1 == 0 and seq2== 0) or (seq1 == totalSeq1 and seq2 == totalSeq2): # if the measured effect size is zero, the probability of observing a table # more extreme will be large (not strictly 1.0, but large and this degenerate # case is problematic to calculate exactly) return 1.0, 1.0 # calculate Wald statistic (standardized difference between proportions) for observed data pooledP = float(seq1 + seq2) / (totalSeq1 + totalSeq2) stdDev = math.sqrt(pooledP * (1.0 - pooledP) * (1.0/totalSeq1 + 1.0/totalSeq2)) obsDiff = float(seq1) / totalSeq1 - float(seq2) / totalSeq2 obsStdDiff = abs(obsDiff / stdDev) # determine tables more extreme than the observed data extremeTables = [] for a in xrange(0, totalSeq1+1): p1 = float(a) / totalSeq1 for b in xrange(0, totalSeq2+1): if (a == 0 and b == 0) or (a == totalSeq1 and b == totalSeq2): # difference in proportions is zero so this is not an extreme table # but will cause a division by zero exception continue # calculate Wald statistic for current table pooledP = float(a + b) / (totalSeq1 + totalSeq2) stdDev = math.sqrt(pooledP * (1.0 - pooledP) * (1.0/totalSeq1 + 1.0/totalSeq2)) p2 = float(b) / totalSeq2 diff = p1 - p2 stdDiff = abs(diff / stdDev) if stdDiff >= obsStdDiff: # Barnard recommends adding extreme tables under symmetrical and convexity conditions. # The latter will be handled here simply by considering all tables. Symmetry may not # occur unless explicitly enforced. Note, that there is no concrete mathematical argument # to enforce symmetry. In fact, Barnard describes his general method for finding extreme tables # as "laziness". if [a,b] not in extremeTables: extremeTables.append([a,b]) extremeTables.append([totalSeq1 - a, totalSeq2 - b]) # calculate Barnard's p-value (must find optimal population proportion) steps = 100 dPi = 0.5 / float(steps) pi = 0.0 pValueTwoSided = 0 for dummy in xrange(0,steps): pi += dPi pValue = 0 for table in extremeTables: c1, c2 = table nCr1 = math.exp(self.logChoose(totalSeq1,c1)) nCr2 = math.exp(self.logChoose(totalSeq2,c2)) prob = nCr1 * nCr2 * math.power(pi,c1+c2) * math.power(1.0 - pi,totalSeq1+totalSeq2-c1-c2) pValue += prob if pValue > pValueTwoSided: pValueTwoSided = pValue return float('inf'), pValueTwoSided
def colourDist(self, c): distance = math.sqrt( math.pow(c.r - self.r, 2) + math.pow(c.g - self.g, 2) + math.power(c.b - self.b, 2) * 1.0) return distance
def k_force(Zscore): """ Function to assign to each restraint a force proportional to the underlying experimental value. """ return power(fabs(Zscore), 0.5)
def CalucalateCallSocre(self): Res = 0 BombCount = self.GetCardParse().GetBombCount() if BombCount > 0: Res += BombCount * 8 + math.power(2.0, BombCount - 1) * 6 return Res