def OptionPrice(cls, spot, strike, NbExp, vol, rate, q, optionType): # v = float() d1 = float() d2 = float() Nd1 = float() Nd2 = float() T = float() if NbExp < 0: return 0 T = NbExp / 365 if NbExp == 0: if optionType == "c": print "TESTTESTTESTTEST", long((math.max(spot - strike, 0))) return float((math.max(spot - strike, 0))) else: print "TESTTESTTESTTEST", long((math.max(spot - strike, 0))) return float((math.max(strike - spot, 0))) d1 = ((math.log(spot / strike)) + (rate - q + (vol * vol) / 2) * T) / (vol * math.sqrt(T)) d2 = d1 - vol * math.sqrt(T) Nd1 = cls.cdnf(d1) Nd2 = cls.cdnf(d2) if optionType == "c": # call option return float((spot * math.exp(-q * T) * Nd1 - strike * math.exp(-rate * T) * Nd2)) else: # put option return float((-spot * math.exp(-q * T) * (1 - Nd1) + strike * math.exp(-rate * T) * (1 - Nd2)))
def OptionPrice(spot, strike, NbExp, vol, rate, q, optionType): # v = float() d1 = float() d2 = float() Nd1 = float() Nd2 = float() T = float() if NbExp < 0: return 0 T = NbExp / 365 if NbExp == 0: if optionType == "c": print "TESTTESTTESTTEST", long((math.max(spot - strike, 0))) return float((math.max(spot - strike, 0))) else: print "TESTTESTTESTTEST", long((math.max(spot - strike, 0))) return float((math.max(strike - spot, 0))) d1 = ((math.log(spot / strike)) + (rate - q + (vol * vol) / 2) * T) / (vol * math.sqrt(T)) d2 = d1 - vol * math.sqrt(T) Nd1 = cdnf(d1) Nd2 = cdnf(d2) if optionType == "c": # call option return float((spot * math.exp(-q * T) * Nd1 - strike * math.exp(-rate * T) * Nd2)) else: # put option return float((-spot * math.exp(-q * T) * (1 - Nd1) + strike * math.exp(-rate * T) * (1 - Nd2)))
def maxSubArray(self, nums): a = [] MAX = a[0] = nums[0] for i in range(len(nums)): a[i] = math.max(a[i - 1] + nums[i], nums[i]) MAX = math.max(a[i], MAX) return MAX
def payoff(self, contract_size: int = 100, position: int = 1) -> float: # negative position means short if self.type == OptionType.CALL: return ((math.max(0, self.current_stock_price - self.strike)) - self.bid) * contract_size * position else: return ((math.max(0, self.strike, self.current_stock_price)) - self.bid) * contract_size * position
def mul_interval(self, y): p1 = self.lower_bound * y.lower_bound p2 = self.lower_bound * y.upper_bound p3 = self.upper_bound * y.lower_bound p4 = self.upper_bound * y.upper_bound return Interval( math.min(math.min(p1, p2), math.min(p3, p4)), math.max(math.max(p1, p2), math.max(p3, p4)))
def max_intensity(self): try: from numpy import max return max(self.y) except ImportError: from math import max maximum = 0. for i in self.y: maximum = max(maximum, i) return maximum
def onMove(self, context): super.onMove(context) for iterator in draggableList: draggable = iterator.next() draggable.desiredX = context.desiredDraggableX - dropTargetOffsetX + draggable.relativeX draggable.desiredY = context.desiredDraggableY - dropTargetOffsetY + draggable.relativeY draggable.desiredX = math.max( 0, math.min(draggable.desiredX, dropTargetClientWidth - draggable.offsetWidth) ) draggable.desiredY = math.max( 0, math.min(draggable.desiredY, dropTargetClientHeight - draggable.offsetHeight) ) draggable.desiredX = math.round(float(draggable.desiredX) / gridX) * gridX draggable.desiredY = math.round(float(draggable.desiredY) / gridY) * gridY dropTarget.add(draggable.positioner, draggable.desiredX, draggable.desiredY)
def activationFunction(self, input): output = [None] * len(input) for idx in range(0, len(output)): output[idx] = math.max(input[idx], 0.0) return output
def crossover(g1, g2): # Make sure g1 is the highest fitness genome if g2.fitness > g1.fitness: tempg = g1 g1 = g2 g2 = tempg child = newGenome() innovations2 = {} # for gene in g2.genes: for i in range(len(g2.genes)): gene = g2.genes[i] innovations2[gene.innovation] = gene for i in range(len(g1.genes)): gene1 = g1.genes[i] gene2 = innovations2[gene1.innovation] if gene2 != None and math.random(2) == 1 and gene2.enabled: # table.insert(child.genes, copyGene(gene2)) child.genes.append(copyGene(gene2)) else: # table.insert(child.genes, copyGene(gene1)) child.genes.append(copyGene(gene1)) child.maxneuron = math.max(g1.maxneuron, g2.maxneuron) child.mutationRates = g1.mutationRates.copy() """ for mutation, rate in pairs(g1.mutationRates) do child.mutationRates[mutation] = rate """ return child
class Program_BinaryOperation: OPERATIONS = { 'plus': lambda a, b: a + b, 'minus': lambda a, b: a - b, 'times': lambda a, b: a * b, 'divided by': lambda a, b: a / b, 'minimum': lambda a, b: math.min(a, b), 'maximum': lambda a, b: math.max(a, b), 'power': lambda a, b: math.pow(a, b), 'atan2': lambda a, b: math.atan2(a, b) } def __init__(self, name): self.op1 = None self.op2 = None self.operation = None self.result = None def setProperty(self, propertyName, propertyValue): if propertyName == 'Operand1': self.op1 = propertyValue elif propertyName == 'Operand2': self.op2 = propertyValue elif propertyName == 'Operation': if propertyValue in OPERATIONS: self.operation = propertyValue def getProperty(self, propertyName, propertyValue): if propertyName == 'Result': return self.result return None def run(self): self.result = OPERATIONS[self.operation](self.op1, self.op2)
def disjoint(genes1, genes2): i1 = [] for i in range(len(genes1)): gene = genes1[i] i1[gene.innovation] = True i2 = [] for i in range(len(genes2)): gene = genes2[i] i2[gene.innovation] = True disjointGenes = 0 for i in range(len(genes1)): gene = genes1[i] if not i2[gene.innovation]: disjointGenes = disjointGenes + 1 for i in range(len(genes2)): gene = genes2[i] if not i1[gene.innovation]: disjointGenes = disjointGenes + 1 n = math.max(len(genes1), len(genes2)) return disjointGenes / n
def calculateTime(model, altitude): #(model:DescentModel) (altitude:float<Feet>) = aTime = math.pow(altitude, model.TimePower) time = model.TimeIntercept + model.TimeAltitude * aTime maxDescent = math.fabs(float(altitude / model.MaximumRateOfDescent)) result = math.max(maxDescent, time) return result
def getDirections(self): self.__initSeeds() d = self.getNum() MSEa = 0 while (MSEa != self.__MSE): MSEa = self.__MSE MSEp = 0. new_centroids = [Point3() for i in range(d)] classes_sizes = [] for i in range(d): new_centroids[i] = Point3() classes_sizes[i] = 0 # We find the closest centroid for each vertex for i in vertices: l = i.distance2From(self.__centroids[0]) i0 = 0 for i in range(d): ll = i.distance2From(centroids[i]) if (ll < l): l = ll i0 = i new_centroids[i0] = new_centroids[i0] + i classes_sizes[i0] = classes_sizes[i0] + 1 MSEp = MSEp + l for i in range(d): classes_sizes[i] = math.max(classes_sizes[i], 1) self.__centroids[i] = new_centroids[i] * (1. / classes_sizes[i]) self.__MSE = MSEp return self.__centroids
def train(self, data, inputSize=None, outputSize=None, iterations=20000, errorThresh=0.005, logLevel=logging.DEBUG, log=False, logPeriod=10, learningRate=0.3, callback=None, callbackPeriod=10): if inputSize is None: inputSize = len(data[0][0]) if outputSize is None: outputSize = len(data[0][1]) hiddenSizes = self.hiddenSizes if not hiddenSizes: hiddenSizes = [math.max(3, math.floor(inputSize / 2))] self._initialize(list(flatten([inputSize, hiddenSizes, outputSize]))) error = 1 done = 0 for i in range(iterations): done = i if error <= errorThresh: break sum = 0 for d in data: err = self.trainPattern(d[0], d[1], learningRate) sum = sum + err error = sum / len(data) if log and i % logPeriod == 0: logging.log( logLevel, "iterations:{0}, training error: {1}".format(i, error)) if callback is not None and i % callbackPeriod == 0: callback(error=error, iterations=i) return (error, done)
def getActionsInfoSet(h,p): potSize = reduce(lambda a,b : a+b, h.pMPIP) totalChips = len(PLAYERS) * STARTING_STACK potsizeBuckets = math.floor((potSize / totalChips) * 10) playersRemain = reduce(lambda a,b : a+b,map(lambda folded : 0 if folded else 1, h.pFolded)) allBetsSize = reduce(lambda a,b : a+b, h.pBet) potSizeWithBets = potSize + allBetsSize myBet = h.pBet[p] biggestBet = math.max(**h.pBet) toCall = biggestBet - myBet potOdds = toCall / potSizeWithBets potOddsBuckets = math.floor(potOdds * 10) positions = map(lambda p,i : len(PLAYERS)-i, PLAYERS) myPosition = positions[p] p1 = p + 1 while (p1 < len(PLAYERS)): if h.pFolded[p1]: myPosition -= 1 p1 += 1 bettingRound = h.bettingRound actionsString = bettingRound + myPosition + potOddsBuckets + potSizeBuckets + "," + playersRemain
def next_pallindrome(num): fringe = [num] pallindromes = [] # iterate through fringe for i in range(num_digits(num)/2): left_place = 10**i left = digit_at_place(num, left_place) right_place = 10**(num_digits(num)-i-1) right = digit_at_place(num, right_place) smaller, larger = math.min(left, right), math.max(left, right) for j in range(smaller, larger+1): left_diff = (j - left) * left_place right_diff = (j - right) * right_place new_num = num new_num += left_diff new_num += right_diff if is_pallindrome(new_num): pallindromes.appned(new_num) else: fringe.append(new_num)
def point_on_line(self, line, p): min_dist = 1000000000 minX, minY, minI, minT = 0,0,0,0 for i in range(len(line)-1): x, y = line[i][0], line[i][1] dx, dy = (line[i+1][0] - x) * self.kx, (line[i+1][1] - y) * self.ky if dx and dy: t = ((p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy) if t > 1: x = line[i+1][0] y = line[i+1][1] elif t > 0: x += (dx / self.kx) * t y += (dy / self.ky) * t dx = (p[0] - x) * self.kx dy = (p[1] - y) * self.ky sq_dist = dx**2 + dy**2 if sq_dist < min_dist: min_dist = sq_dist minX, minY, minI, minT = x, y, i, t return { 'point': [minX, minY], 'index': minI, 't' : math.max(0, math.min(1,minT)) }
def FrozenSoil(Fdepth,ROOTD,WAS,WCFC,WCL,Tsurf,LAMBDAsoil,RHOwater,LatentHeat,DELT): # Determining the amount of solid water that contributes in transportation of heat to surface 'WCeff' if Fdepth > ROOTD: WCeff = WCFC elif Fdepth > 0: WCeff = (0.001*WAS) / Fdepth else: WCeff = WCL # Calculating potential frost rate 'PFrate' # if ((Fdepth == 0.).and.(Tsurf>0.)) : # No soil frost present AND no frost starting if Fdepth == 0 and Tsurf>0 or WCeff == 0: # No soil frost present AND no frost starting PFrate = 0 else : alpha = LAMBDAsoil / ( RHOwater * WCeff * LatentHeat) PFrate = math.sqrt( math.max(0, math.pow(Fdepth,2) - 2*alpha*Tsurf) ) - Fdepth if PFrate >= 0 and Fdepth > 0 and Fdepth < ROOTD: Frate = PFrate * (0.001*WAS/Fdepth) / WCFC # Soil frost increasing elif (PFrate+Fdepth/DELT) < 0 : Frate = -Fdepth / DELT # Remaining soil frost thaws away else : Frate = PFrate return (WCeff,PFrate,Frate)
def qualityalgo(arg7, arg8, arg9): v0 = 0 v3 = 0x1388 v2 = 0xFF if (arg9 == 0): if (arg7 == 0x63 and arg8 == 0x24): v0 = 0x8A if (v0 < 1): v0 = 1 elif (v0 > v2): v0 = v2 return v0 a = (arg7 * b[arg8] / 0x1000000 + 1) v0 = int(a / 2) elif (arg9 == 1): if arg8 < 0x32: v0 = math.min(int(v3) / arg8, v3) else: v0 = math.max(int(0xC8) - arg8 * 2, 0) v0 = (v0 * arg7 + 0x32) / 0x64 else: print("qualityAlgorithm") return 0 if (v0 < 1): v0 = 1 elif (v0 > v2): v0 = v2 return (v0 & 0xFF)
def run(mass): try: mass = int(mass) except ValueError: return False return math.max(0, math.floor(mass / 3) - 2)
def downscale_evaporation(self, k): """ REQUIRED INPUT: daily evaporation (EpDay) - hour of the day (x; derived from self.thestep) - start of the day (derived from global radiation) - end of the day (derived from global radiation) PARAMETERS: - """ # teller = numpy.nanmax(pcr.pcr2numpy(self.thestep,np.nan)) teller = pcr.pcr2numpy(self.thestep, np.nan)[0, 0] x = teller - math.floor(teller / 24) * 24 * pcr.scalar(self.catchArea) DL = self.DE - self.DS + 1 P = 2 * math.pi / (2 * DL) # period SH = DL - 12 # horizontal shift of new signal aN = -1 * self.EpDay * P # nominator of the amplitude aDN = math.sin((P * (self.DE + SH)) * 180 / math.pi) - math.sin( (P * (self.DS + SH)) * 180 / math.pi ) # denominator of the amplitude ampl = aN / aDN # amplitude of new signal self.EpHour = math.max( pcr.ifthenelse( pcr.pcrand(x >= self.DS, x <= self.DE), -1 * ampl * math.cos((P * (x + SH)) * 180 / math.pi), 0, ), 0, )
def ComputeBreakpointAt(self, y): # we use the equation of the parabola to get the intersection of the two arcs d = 2 * (self.site1.y - y) a1 = 1 / d b1 = -2 * self.site1.x / d c1 = y + d / 4 + self.site1.x * self.site1.x / d d = 2 * (self.site2.y - y) a2 = 1 / d b2 = -2 * self.site2.x / d c2 = y + d / 4 + self.site2.x * self.site2.x / d # minor adjustment a = a1 - a2 b = b1 - b2 c = c1 - c2 # since this is a quadratic equation, so it will have 2 solutions discremenant = b * b - 4 * a * c x1 = (-b + math.sqrt(discremenant)) / (2 * a) x2 = (-b - math.sqrt(discremenant)) / (2 * a) # the two solutions are basically the left and the right breakpoint values (just x) if self.site1.x <= self.site2.x: return math.min(x1, x2) else: return math.max(x1, x2)
def getActions(h): betsAreEqual = allEqual(filter( lambda p,i : !h.pFolded[i], h.pBet )) highestBet = math.max(**h.pBet) currentBet = h.pBet[h.currentPlayer] diff = highestBet - currentBet hasChips = h.pChips[h.currentPlayer] > diff hasFolded = h.pFolded[h.currentPlayer] let actions = [] if (hasFolded): actions = ["none"] else: if betsAreEqual: actions = ["check"] if hasChips: actiosn = actions + ["bet"] else: actions = ["fold", "call"] if hasChips: actions = actions + ["bet"] return actions
def search_thread(): global iters_per_search global parallel_threads global candidate def search(): global lists lists = lists[:] global min_number global batch_size global iters_per_batch loop = True return_list = [] while loop: batch = [] # create batch for i in range(batch_size): try: batch.append(lists[0]) del lists[0] except IndexError: # list is empty now, break loop loop = False # perform on batch new = random_from_lists_bestof(batch, saved_profiles + return_list, min_number, iters_per_batch) return_list += new[:] return return_list for i in range(math.ceil(iters_per_search/math.max(parallel_threads, 1))): new_candidate = search() if len(new_candidate) < len(candidate): candidate = new_candidate[:]
class Program_Function1D: FUNCTIONS = { 'min': lambda a, b: math.min(a, b), 'max': lambda a, b: math.max(a, b), 'pow': lambda a, b: math.pow(a, b), 'atan': lambda a, b: math.atan(a, b) } def __init__(self, name): self.argument = None self.function = None self.result = None def setProperty(self, propertyName, propertyValue): if propertyName == 'Argument': self.argument = propertyValue elif propertyName == 'Function': if propertyValue in FUNCTIONS: self.function = propertyValue def getProperty(self, propertyName, propertyValue): if propertyName == 'Result': return self.result return None def run(self): self.result = FUNCTIONS[self.function](self.argument)
def sweepCollisionTest(self, bb1, bb2, p1, p2, v1, v2): """ Where p1 and p2 are position vectors and v1 and v2 are velocity vectors NOTE: sweep tests are only supported for AABB-AABB. SAT sweeps are a little outside my expertise. """ type1 = 0 type2 = 0 for type in range(len(self.boundingArray)): if bb1.getBoundType == self.boundingArray[type]: type1 = type if bb1.getBoundType == self.boundingArray[type]: type2 = type if type1 == 1 and type2 == 1: """Simple AABB collision""" #bb1 controls the collision: translate movement to bb2's frame of reference rvel = v1 - v2 #sweep for a collision #check x path if rvel.x != 0: t_min_x = ((p2.x - bb2.half_width) - p1.x) / rvel.x t_max_x = ((p2.x + bb2.half_width) - p1.x) / rvel.x else: if (p2.x - bb2.half_width) <= (p1.x + bb1.half_width) or (p2.x + bb2.half_width) >= (p1.x - bb1.half_width): #if they have the same x velocity but still intersect on the x axis... t_min_x = t_max_x = 0 else: t_min_x = 2 t_max_x = -2 #check y path if rvel.y != 0: t_min_y = ((p2.y - bb2.half_height) - p1.y) / rvel.y t_max_y = ((p2.y + bb2.half_height) - p1.y) / rvel.y else: if (p2.y - bb2.half_height) <= (p1.y + bb1.half_height) or (p2.y + bb2.half_height) >= (p1.y - bb1.half_height): #if they have the same x velocity but still intersect on the x axis... t_min_y = t_max_y = 0 else: t_min_y = 2 t_max_y = -2 if t_min_x <= t_max_x and t_min_y <= t_max_y: intersect_time = math.max(t_min_x, t_min_y) else: intersect_time = -1 return intersect_time else: raise TypeError('Sweep tests are not supported for non-AABB collisions')
def hex_linedraw(a, b): N = hex_distance(a, b) a_nudge(a['q'] + 1e-6, a['r'] + 1e-6, a['s'] - 2e-6) b_nudge(b['q'] + 1e-6, b['r'] + 1e-6, b['s'] - 2e-6) results = [] step = 1.0 / math.max(N, 1) for i in range(N): results.append(hex_round(hex_lerp(a_nudge, b_nudge, step * i))) return results
def update_state(time): global wheelbase global steering_command global state, last_update if steering_command is not None: v0 = steering_command.speed a0 = steering_command.acceleration j0 = steering_command.jerk time_diff = time - last_update dt = time_diff.secs + time_diff.nsecs * 1e-9 ds = v0 * dt + a0 * dt**2 / 2 + j0 * dt**3 / 6 v = v0 + a0 * dt + j0 * dt**2 / 2 delta = steering_command.steering_angle if max_steering_angle > 0: delta = max(-max_steering_angle, min(delta, max_steering_angle)) if max_steering_angle_velocity > 0: delta = math.max( state.delta - max_steering_angle_velocity * dt, min(delta, state.delta + max_steering_angle_velocity * dt)) state.delta = delta if isclose(delta, 0.0): # Approximate movement as linear motion state.x += ds * math.cos(state.th) state.y += ds * math.sin(state.th) else: # Treat movement as circular motion # Calculate radius of curvature (positive sign = left turn) r = wheelbase / math.tan(delta) # Calculate coordinates of the center of curvature cx = state.x - r * math.sin(state.th) cy = state.y + r * math.cos(state.th) # Calculate current yaw and angular velocity state.th += ds / r state.vth = v / r # Calculate new position state.x = cx + r * math.sin(state.th) state.y = cy - r * math.cos(state.th) # Calculate instantaneous velocity state.vx = v * math.cos(state.th) state.vy = v * math.sin(state.th) last_update = time return state
def prox_f(q, x, t): if len(locals()) < 3: print("[RPCA_c : prox_f] Not enough arguments") V = math.sqrt(np.sum(np.power(x, 2), 1)) s = 1 - np.divide(1, math.max(np.divide(v, np.multiply(t, q)), 1)) m = len(s) x = scipy.sparse.spdiags(x, 0, m, m) * x return x
def calcOut(self, inputs): if self.operation == 'AND': self.output = 1.0 for i in self.inputIndex: self.output *= inputs[i] elif self.operation == 'OR': for i in self.inputIndex: self.output = math.max(self.output, inputs[i]) else: self.output = 0.0
def _compute_tree_structures(self, current_layer, current_depth): layer_actions_count = 0 layer_terminal_actions_count = 0 next_layer = [] for n in range(1, len(current_layer)): node = current_layer[n] layer_actions_count = math.max(layer_actions_count, len(node.children)) node_terminal_actions_count = 0 for c in range(1, len(current_layer[n].children)): if node.children[c].terminal or node.children[c].current_player == constants.players.chance: node_terminal_actions_count = node_terminal_actions_count + 1 layer_terminal_actions_count = math.max(layer_terminal_actions_count, node_terminal_actions_count) ###--add children of the node to the next layer for later pass of BFS if not node.terminal: for c in range(1, len(node.children)): next_layer.append(node.children[c]) assert ((layer_actions_count == 0) == (len(next_layer) == 0)) assert ((layer_actions_count == 0) == (current_depth == self.lookahead.depth)) ##--set action and bet counts self.lookahead.bets_count[current_depth] = layer_actions_count - layer_terminal_actions_count self.lookahead.nonallinbets_count[ current_depth] = layer_actions_count - layer_terminal_actions_count - 1 # - -remove allin ###--if no alllin... if layer_actions_count == 2: assert (layer_actions_count == layer_terminal_actions_count) self.lookahead.nonallinbets_count[current_depth] = 0 self.lookahead.terminal_actions_count[current_depth] = layer_terminal_actions_count self.lookahead.actions_count[current_depth] = layer_actions_count if len(next_layer) > 0: assert (layer_actions_count >= 2) ##--go deeper self._compute_tree_structures(next_layer, current_depth + 1)
def getExpectationOfProperties(self, iin, out, cnt): inHs, outHs = [], [] res = [12] for i in range(len(iin)): res[0] += cnt[i] res[1] += iin[i] * cnt[i] res[7] = math.max(res[7], iin[i]) res[8] = math.max(res[8], out[i]) inHs.add(iin[i]) outHs.add(out[i]) res[2] = res[1] / res[0] for i in range(len(iin)): res[3] += math.min(1, iin[i] * iin[i]/res[0]) * cnt[i] res[4] += math.min(1, out[i] * out[i]/res[0]) * cnt[i] res[11] += math.min(1, out[i] * iin[i]/res[0]) * cnt[i] res[11] /= res[2] tmp = res[0] * (res[0] - 1) for i in range(len(iin)): for j in range(len(out)): if iin[i] != 0 and out[j] != 0: res[5] += iin[i] * out[j] / res[1] * cnt[i] * cnt[j] / tmp res[6] = len(iin) res[9] = np.size(inHs) res[10] = np.size(outHs) print("\n Expectations:" "\n\t num Node: " "\n\t num Edge: " "\n\t expected In/Out Degree: " "\n\t Second Moment In Degree: " "\n\t Second Moment out Degree: " "\n\t expected connection probability: " "\n\t num unique joint in/out degree: " "\n\t max In Degree: " "\n\t max out degree: " "\n\t num of unique in degree: " "\n\t num of unique out degree: " "\n\t expected num of self loop \n", res[0], res[1], res[2], res[3], res[4], res[5], res[6], res[7], res[8], res[9], res[10, res[11]]) return res
def _lorentz_smooth(self, vi=4.0): import numpy as np from math import min, max, sqrt intbuf = np.copy(self.y) prefac = [ e_step * vi / ((e_step * i)**2 + vi**2) for i in range(len(self.y)) ] # First check if vi is nonzero if vi < 0.001: raise ValueError('vi is too small') # Sort IV curve if not yet done if not self.sorted: self.sort() # smooth IV curve if self.equidistant: e_step = self.x[1] - self.x[0] if e_step == 0.: raise ValueError("energy step is too small") # Find energy range for integral n_range = vi * sqrt((1. / 0.001) - 1.) / e_step # scan over all energies for i in range(len(self.y)): # store original intensities and calculate # first element of integral sum self._data[1][i] *= prefac[0] norm_sum = prefac[0] # upper branch: i_hi = min(i + n_range, len(self.x)) for i_sum in range(i + 1, i_hi): self._data[1][i] += self.y[i_sum] * prefac[i_sum - i] norm_sum += prefac[i_sum - i] # lower branch: i_lo = max(i - n_range + 1, 0) for i_sum in range(i_lo, i): self._data[1][i] += intbuf[i_sum] * prefac[i - i_sum] norm_sum += prefac[i - i_sum] # normalize intensity self._data[1][i] /= norm_sum # set smooth flag self.smoothed = True
def _max(a, b): if isNum(a) and isNum(b): try: result = math.max(a, b) except: return 0 return result if not isNum(a) and isNum(b): return _max(parse(a), b) if isNum(a) and not isNum(b): return _max(a, parse(b)) if not isNum(a) and not isNum(b): return _max(parse(a), parse(b))
def main(): #store size of L1 CPU cache in bytes L1D_CACHE_SIZE = 32768 #32*1024 = 32Kbytes print('What is the largest number you want primes to go upto in the prime list?') N_initial = raw_input() if N_initial.isdigit() is False: print('You have not entered an integer. Please reenter.') sys.exit() #now convert type for N into a long: N = long(N_initial) #Simple Checks for N: if N==0: print('Number entered is 0. Please choose another number.') sys.exit() if N==1: print('1 is not a prime. Please choose another number.') sys.exit() if N<0: print('Number entered is negative. Please enter another number') sys.exit() #Store square root of N sqrt_N = math.sqrt(N) #Set segment_size to be max of CPU's L1 data cache size and sqrt_N segment_size = math.max(L1D_CACHE_SIZE,sqrt_N) if limit < 2: count=0 else: count=1 s = 3 n = 3 #Now need to generate sieving primes less than sqrt_N - which are needed to cross off multiples #is_prime="" #This needs to be a vector containing characters ??? is_prime = [] #is_prime = [sqrt_N + 1,1] i = 2 for i * i <= sqrt_N: #N=10000. Hence sqrt_N=100. 1st loop i=2 hence i*i=4. 4 <= 100 #if is_prime[i]: #is_prime[4] This doesn't exist!!! if i not in is_prime: j = i * i for j <= sqrt_N: is_prime.append(0) j = j + i
def SA(P, Tmax, Ftarget, dT): # 1. start point P: start random or defined value T = Tmax # 2. set temperature to Tmax while (true): # 3. objective function F evaluate samples if P.F(P) >= Ftarget or T<=0: return P # 4. return P as solution neighbors = P.Gn(P) # 5. generate n neighbors of P for i in range(len(neighbors)): eneighbors[i] = P.F(neighbors[i]) # 6. Evaluate each neighbor Pmax = math.max(eneighbors) # 7. Let Pmax be the neighbor with the highest evaluation q = (P.F(Pmax) - P.F(P)) / P.F(p) # 8. q = (F(Pmax) - F(P)) / F(p) p = math.min[1, math.e ** (-q / T)] # 9. x = random.uniform(0.0, 1.0) # 10. generate x = random [0,1] if x > p: P = Pmax # 11. else: P = random.choice(eneighbors) # 12. a random choice among n neighbors T = T - dT # 13.
def __init__(self, rawLat, rawLng, noWrap): lat = float(rawLat) lng = float(rawLng) if not noWrap: lat = math.max(math.min(lat, 90), -90) lng = (lng + 180) % 360 if (lng < -180 or lng == 180): lng_fix = 180 else: lng_fix = -180 lng += lng_fix self.lat = lat self.lng = lng
def fuelBurn(ascentModel, descentModel, cruiseModel, weight, altitude, airSpeed, vertical): # (ascentModel, descentModel, cruiseModel, _) (weight:float<Pounds>) (altitude:float<Feet>) # (airSpeed:float<Knots>) (vertical:VerticalMovement) = cruiseFuelBurn = Cruise.fuelBurn(cruiseModel, weight, altitude, airSpeed) #assertNumber "cruiseFuelBurn" cruiseFuelBurn #assertNonNegative "cruiseFuelBurn" cruiseFuelBurn (modelBurn, verticalVelocity) = if vertical == 'Descent': (descentRate, descentFuelBurn)= Descent.calculateRates(descentModel, altitude, weight) (modelBurn, verticalVelocity) = (descentFuelBurn, descentRate) elif vertical == 'Cruise': # | Cruise -> (0.0<FuelPounds/Hours>, 0.0<Feet/Hours>) (modelBurn, verticalVelocity) = (0, 0) elif vertical == 'Ascent': (ascentRate, rawAscentFuelBurn) = Ascent.calculateRates(ascentModel, altitude, weight) ascentFuelBurn = math.max(rawAscentFuelBurn, cruiseFuelBurn) (modelBurn, verticalVelocity) = (ascentFuelBurn, ascentRate) verticalCruiseFuelDiff = modelBurn - cruiseFuelBurn return (cruiseFuelBurn, verticalCruiseFuelDiff, verticalVelocity)
def poll(**kwargs): global joy portName = "COM4" analogChannel = 4 serPort = serial.Serial(portName, 19200, timeout=.05) #or 15200? while True: etime = time.time() try: serPort.write("adc read "+ str(analogChannel) + "\r") ret = serPort.read(read_duration) print ret[12:-3] except: print 'no ret' joy = inter poll_delay = math.max(time.time() - etime - (1.0 / float(pollHz)),0) if poll_delay > 0: time.sleep(poll_delay) return
def addItem(self, name, amount): self.items[name][1] = math.max(_itemMax, self.items[name][1]+amount)
def drop(self, widget, left, top): left = math.max(0, math.min(left, dropTarget.getOffsetWidth() - widget.getOffsetWidth())) top = math.max(0, math.min(top, dropTarget.getOffsetHeight() - widget.getOffsetHeight())) left = math.round(float(left) / gridX) * gridX top = math.round(float(top) / gridY) * gridY dropTarget.add(widget, left, top)
def removeItem(self, name, amount): self.items[name][1] = math.max(_itemMax, self.items[name][1]-amount)
def run(self): self.active = True packetIdToRetransmit = -1 yield hold, self, self.startTime while True: packetIdToRetransmit = self.getPacketIdToRetransmit() # First time we get 3DA if self.enabledCCA and not self.fastRecovery and packetIdToRetransmit!= -1: # Enter Fast Recovery if necessary self.fastRecovery = True self.ssthresh = math.max(math.ceil(self.windowSize/2), 2) self.windowSize = self.ssthresh + 3 # Further times we get 3DA if self.fastRecovery and packetIdToRetransmit != -1: # For every 3 dup acks received, get the packetID for retransmit self.acks[packetIdToRetransmit-1] = 0 assert(packetIdToRetransmit != -1) # Create a new packet based on the packetID, and resent the packet message = "Packet " + str(packetIdToRetransmit) + "'s data goes here!" # packetId, timesent, sourceID, destid, isroutermsg, isack, msg newPacket = Packet(packetIdToRetransmit, now(), self.ID, self.destinationID, False, False, message) activate(newPacket, newPacket.run()) self.sendPacketAgain(newPacket) yield hold, self, newPacket.size/float(self.link.linkRate) # resend anything, if need to elif len(self.toRetransmit) > 0: (didtransmit, p) = self.retransmitPacket() if (didtransmit): # if transmitted, wait yield hold, self, p.size/float(self.link.linkRate) # collect stats if not now() == 0: self.link.buffMonitor.observe(len(self.link.queue)) self.link.dropMonitor.observe(self.link.droppedPackets) self.sendRateMonitor.observe(PACKET_SIZE*self.numPacketsSent / float(now())) # If everything has been sent, go to sleep elif (PACKET_SIZE * self.numPacketsSent >= self.bitsToSend): self.active = False yield passivate, self self.active = True # otherwise, send new packets! elif len(self.outstandingPackets) < self.windowSize: # send a new packet packet = self.createPacket() self.sendPacket(packet) # wait yield hold, self, packet.size/float(self.link.linkRate) # collect stats if not now() == 0: self.link.buffMonitor.observe(len(self.link.queue)) self.link.dropMonitor.observe(self.link.droppedPackets) self.sendRateMonitor.observe(PACKET_SIZE*self.numPacketsSent / float(now())) # nothing to retransmit and cannot send new packets else: self.active = False yield passivate, self self.active = True
def findMax(node): if node==None: return 0 return 1+math.max(findMax(node.right),findMax(node.left))
def conductClientExperiment(serverExperiment): clientExperiment = FunExperimentClient() clientExperiment.index = serverExperiment.index clientExperiment.newProperty.value = math.max(0, math.min(0xFFFFFFFF, math.round(random.gauss(serverExperiment.default.value, serverExperiment.deviation)))) return clientExperiment
def eta(viscousDamping): ''' correction coefficient "eta" to obtain the elastic response spectrum. according SIA 261 2003 (16.2.3.1). ''' return math.max(mat.sqrt(1/(0.5+10*viscousDamping),0.55))
# start of the dict completion (type and total) # ################################################# i=0 #print("start of the dict completion") #for debogue while i < len(tabDict): tabDict[i].total=tabDict[i].numA+tabDict[i].numG+tabDict[i].numC+tabDict[i].numT #fill the total attribut if tabDict[i].total!=0: tabDict[i].numA=float(tabDict[i].numA/tabDict[i].total) tabDict[i].numT=float(tabDict[i].numT/tabDict[i].total) tabDict[i].numG=float(tabDict[i].numG/tabDict[i].total) tabDict[i].numC=float(tabDict[i].numC/tabDict[i].total) #fill the now attribut if tabDict[i].total==0: tabDict[i].now=tabDict[i].ref if (max(tabDict[i].numA, tabDict[i].numT, tabDict[i].numG, tabDict[i].numC)== tabDict[i].numA): tabDict[i].now='A' if (max(tabDict[i].numA, tabDict[i].numT, tabDict[i].numG, tabDict[i].numC)== tabDict[i].numT): tabDict[i].now='T' if (max(tabDict[i].numA, tabDict[i].numT, tabDict[i].numG, tabDict[i].numC)== tabDict[i].numC): tabDict[i].now='C' if (max(tabDict[i].numA, tabDict[i].numT, tabDict[i].numG, tabDict[i].numC)== tabDict[i].numG): tabDict[i].now='G' #fill the type attribut if tabDict[i].total==0: tabDict[i].type="Reference" elif tabDict[i].total < cut_Off_Uncertainty and tabDict[i].ref==tabDict[i].now:
import FlightTypes import Aircraft import Units import math def grossWeight(flightParameters, flightState): # (flightParameters:FlightParameters) (flightState:FlightState) = # // Passengers average 190 lb # // Luggage is an average of 10-20 lb per passenger aircraft = flightParameters.AircraftType payload = flightParameters.Payload payloadWeight = (payload.PremiumPassengerCount + payload.StandardPassengerCount)*190.0 + payload.PremiumPassengerCount * 20.0 + payload.StandardPassengerCount * 10.0 initialFuel = flightParameters.InitialFuel fuelWeight = math.max(0.0, (initialFuel - flightState.FuelConsumed)) return aircraft.OperatingEmptyWeight + payloadWeight + fuelWeight
def max(self, a, b): self[0] = math.max(a[0], b[0]) self[1] = math.max(a[1], b[1]) self[2] = math.max(a[2], b[2]) return self
def equals(self, obj): margin = math.max( math.abs(self.lat - obj.lat), math.abs(self.lon - obj.lon)) return margin <= self.MAX_MARGIN