def mcmc_simulation(org_value, eps, step_size, n_steps, n_burns, dQ, is_two=False): values = [0.0 for _ in range(n_steps - n_burns)] curV = org_value for i in range(n_steps): rand_val = random.random() newV = curV + (-step_size + 2.0 * step_size * rand_val) # if is_two: prob = math.exp(eps / (2 * dQ) * (abs(curV - org_value) - abs(newV - org_value)) ) # prefer smaller values of |curV-org_value| else: prob = math.exp( eps / dQ * (abs(curV - org_value) - abs(newV - org_value))) # not 2*dQ if prob > 1.0: prob = 1.0 prob_val = random.random() if prob_val <= prob: # accept newV curV = newV # if i >= n_burns: values[i - n_burns] = curV # return values
def square_root(num): if not isNumber(num): raise(_NON_NUMERIC_ARG) target = abs(Decimal(str(num))) guesses = 0 guess = Decimal('0') while abs(guess * guess - target) > tolerance: guesses += 1 guess += tolerance if guess * guess > target: if _debug: print(guesses) # @IgnorePep8 if _debug: print(guess) # @IgnorePep8 raise(_NO_SOLUTION_FOUND) if _debug: print(guesses) # @IgnorePep8 return(guess)
def abs(obj): """Overloads the built-in abs function for convex optimization.""" try: return __builtin__.abs(obj) except TypeError: if ispos(obj): return obj elif isneg(obj): return -obj else: return absfunction(obj)
def dw_GetGridDimensions(ptid_map): """ Returns number of cells in 1st and 2nd grid directions. input: - ptid_map : PCRaster map with unique id's """ # find number of cells in m and n directions zero_map = scalar(ptid_map) * 0.0 allx = dw_pcrToDataBlock(xcoordinate(boolean(cover(zero_map + 1, 1)))) i = 0 diff = round(__builtin__.abs(allx[i] - allx[i + 1]), 5) diff_next = diff while diff_next == diff: i += 1 diff_next = __builtin__.abs(allx[i] - allx[i + 1]) diff_next = round(diff_next, 5) m = i + 1 n = allx.shape[0] / m m, n = n, m return m, n
def square_root_newton(num, precision=None): ''' See http://mathworld.wolfram.com/NewtonsIteration.html for details. See https://mitpress.mit.edu/sicp/full-text/sicp/book/node12.html for another discussion of the same algorithm. Notice that it is possible to have values for num and precision which will result in an infinite loop, due to not being able to get "close enough" to the correct answer, as specified by the global tolerance variable. This implementation merely detects this situation and raises _NO_SOLUTION_FOUND if it occurs. ''' if isInt(precision): getcontext().prec = precision if not isNumber(num): raise(_NON_NUMERIC_ARG) target = abs(Decimal(str(num))) this_guess = Decimal('1') guesses = 0 while abs(this_guess * this_guess - target) > tolerance: guesses += 1 if _debug: print(this_guess) # @IgnorePep8 prior_guess = this_guess this_guess = Decimal('0.5') * (this_guess + target/this_guess) if this_guess == prior_guess: raise(_NO_SOLUTION_FOUND) if _debug: accuracy = abs(this_guess * this_guess - target) print('Guesses: {0}; final_guess: {1}; accuracy: {2}' .format(guesses, this_guess, accuracy)) # @IgnorePep8 if not (this_guess * this_guess - target) <= tolerance: raise(_NO_SOLUTION_FOUND) return(this_guess)
def on_touch_up(self, touch): from reduction.system import reductor from reduction.component.board import Board if touch.grab_current is self and isinstance(self.parent, Board): board_pos = list(self.parent.coords_to_board_pos(touch.pos)) dp = tuple(map(sub, self.board_pos, board_pos)) if abs(dp[0]) > abs(dp[1]): board_pos[1] = self.board_pos[1] else: board_pos[0] = self.board_pos[0] atoms = list(filter(lambda x: isinstance(x, Atom), self.parent.pieces_at(board_pos))) if self.parent.straight_path_clear_between(self.board_pos, board_pos): if len(atoms) > 0: print "Can atoms reduce? ", reductor.can_reduce(self, atoms[0]) if reductor.can_reduce(self, atoms[0]): self.board_pos = board_pos else: self.board_pos = board_pos touch.ungrab(self) return True
def mcmc_simulation(org_value, eps, step_size, n_steps, n_burns, dQ, is_two = False): values = [0.0 for _ in range(n_steps-n_burns)] curV = org_value for i in range(n_steps): rand_val = random.random() newV = curV + (-step_size + 2.0*step_size*rand_val) # if is_two: prob = math.exp(eps/(2*dQ)*(abs(curV-org_value) - abs(newV-org_value))) # prefer smaller values of |curV-org_value| else: prob = math.exp(eps/dQ*(abs(curV-org_value) - abs(newV-org_value))) # not 2*dQ if prob > 1.0: prob = 1.0 prob_val = random.random() if prob_val <= prob: # accept newV curV = newV # if i >= n_burns: values[i-n_burns] = curV # return values
def normxcorr(self, s, k): from __builtin__ import abs sLen = len(s) kLen = len(k) cLen = sLen + kLen - 1 c = [0.0] * cLen for i in xrange(cLen): j0 = i - (kLen - 1) if i >= kLen - 1 else 0 jN = i + 1 if i < sLen - 1 else sLen s1Sum = 0.0 s2Sum = 0.0 k1Sum = 0.0 k2Sum = 0.0 skSum = 0.0 n = jN - j0 for j in xrange(j0, jN): sVal = s[j ] kVal = k[i - j] s1Sum += sVal s2Sum += sVal * sVal k1Sum += kVal k2Sum += kVal * kVal skSum += sVal * kVal nom = skSum - s1Sum * k1Sum / n denS = s2Sum - s1Sum * s1Sum / n denk = k2Sum - k1Sum * k1Sum / n den = sqrt(denS * denk) if den > 1e-5 * abs(nom): c[i] = nom / den return c
def abs (anObject): return __builtin__.abs (evaluate (anObject))
def __init__(self, path): print ' ' print 'loading file number:', path print ' ' ds = Dataset(path) # df[path] # in case of 4d data ds.__iDictionary__.addEntry('hmm', 'entry1/data/hmm') self.Filename = os.path.basename(path) self.CountTimes = list(ds['entry1/instrument/detector/time']) self.Bex = list(ds['entry1/instrument/crystal/bex']) #self.Angle = list(ds['entry1/instrument/crystal/m2om']) self.MonCts = list(ds['entry1/monitor/bm1_counts']) self.MonCountTimes = list(ds['entry1/monitor/time']) # NEW self.ScanVariablename = str(ds['entry1/instrument/crystal/scan_variable']) self.ScanVariable = list(ds['entry1/instrument/crystal/' + self.ScanVariablename]) self.Angle = copy(self.ScanVariable) if self.ScanVariablename == 'm2om': pass else: if convert2q.value: raise Exception ("Please Untick 'Convert to q'") self.DetCts = [] # more difficult readout self.ErrDetCts = [] # calculated self.TransCts = [] # more difficult readout # read parameters from file self.Wavelength = float(ds['entry1/instrument/crystal/wavelength']) self.MainDeadTime = float(ds['entry1/instrument/detector/MainDeadTime' ]) self.TransDeadTime = float(ds['entry1/instrument/detector/TransDeadTime']) self.dOmega = float(ds['entry1/instrument/crystal/dOmega']) self.gDQv = float(ds['entry1/instrument/crystal/gDQv']) self.ScanVariable = str(ds['entry1/instrument/crystal/scan_variable']) self.TimeStamp = list(ds['entry1/time_stamp']) # read parameters from file and possibly patch self.Thick = TryGet(ds, ['entry1/sample/thickness' ], Thickness.value , Thickness_Patching.value ) / 10.0 # mm to cm self.SampleName = TryGet(ds, ['entry1/sample/name' ], SampleName.value , SampleName_Patching.value ) self.SampleDescr = TryGet(ds, ['entry1/sample/description' ], SampleDescr.value , SampleDescr_Patching.value ) self.SampleBkg = TryGet(ds, ['entry1/experiment/bkgLevel' ], SampleBkg.value , SampleBkg_Patching.value ) self.empLevel = empLevel.value self.empLevel_Error = empLevel_Error.value self.defaultMCR = defaultMCR.value self.TWideMarker = TWideMarker.value self.ActualTime = range(len(self.Angle)) self.widepoints = 0 # tube ids tids = [] if combine_tube0.value: tids.append(0) if combine_tube1.value: tids.append(1) if combine_tube2.value: tids.append(2) if combine_tube3.value: tids.append(3) if combine_tube4.value: tids.append(4) # sum selected tubes data = zeros(len(self.Angle)) for tid in tids: if ds.hmm.ndim == 4: data[:] += ds.hmm[:, 0, :, tid].sum(0) # hmm else: data[:] += ds.hmm[:, :, tid].sum(0) # hmm_xy DeadtimeCorrection(data, self.MainDeadTime, self.CountTimes) self.DetCts = list(data) self.ErrDetCts = [sqrt(cts) for cts in self.DetCts] # transmission counts if abs(self.Wavelength - 4.74) < 0.01: tid = 10 #print 'long wavelength' elif abs(self.Wavelength - 2.37) < 0.01: tid = 9 #print 'short wavelength' else: raise Exception('unsupported wavelength') if ds.hmm.ndim == 4: data[:] = ds.hmm[:, 0, :, tid].sum(0) # hmm else: data[:] = ds.hmm[:, :, tid].sum(0) # hmm_xy DeadtimeCorrection(data, self.TransDeadTime, self.CountTimes) self.TransCts = list(data) # CONVERT TO COUNTRATES self.DetCtr = range(len(self.DetCts)) self.ErrDetCtr = range(len(self.DetCts)) self.TransCtr = range(len(self.DetCts)) self.MonCtr = range(len(self.DetCts)) ctTimes = self.CountTimes # to ignore all the 0 times in the detector for i in xrange(len(self.DetCts)): if ctTimes[i] < 0.5: print 'Please Ignore Data Point: ', i+1 print '' ctTimes[i] = ctTimes[i] + 100.0 for i in xrange(len(ctTimes)): ctTime = ctTimes[i] self.DetCtr[i] = self.DetCts[i] / ctTime self.ErrDetCtr[i] = self.ErrDetCts[i] / ctTime self.TransCtr[i] = self.TransCts[i] / ctTime ctTimes = self.MonCountTimes for i in xrange(len(ctTimes)): ctTime = ctTimes[i] self.MonCtr[i] = self.MonCts[i] / ctTime # TAKE ACCOUNT OF BEAMMONITOR if use_beammonitor.value: mcr = self.defaultMCR for i in xrange(len(self.Angle)): if self.MonCtr[i] <0.0001: #to fix the 0-divison problem self.MonCtr[i] = 1000 f = mcr / self.MonCtr[i] self.DetCtr[i] = self.DetCtr[i] * f self.ErrDetCtr[i] = self.ErrDetCtr[i] * f self.TransCtr[i] = self.TransCtr[i] * f
def abs(argv, **kwargs): return __builtin__.abs(argv)
def abs(x): return builtins.abs(x)
n_steps = 20000 n_burns = 2000 # burn-in loc = 0.0 scale = dQ / eps n_bins = 100 start = time.clock() values = mcmc_simulation(loc, eps, step_size, n_steps, n_burns, dQ, is_two=False) print "mcmc_simulation - DONE, elapsed", time.clock() - start # the histogram of the data with histtype='step' x = np.array(values) n, bins, patches = P.hist( x, n_bins, normed=1, histtype='stepfilled') # bins: ndarray of 51 elements P.setp(patches, 'facecolor', 'g', 'alpha', 0.75) # add a line showing the expected distribution y = np.exp(-abs(bins - loc / scale)) / (2. * scale) l = P.plot(bins, y, 'k--', linewidth=1.5) P.show()
# test against Laplace(0.0, eps=1.0, dQ=1.0) eps = 1.0 dQ = 1.0 step_size = 10.0 n_steps = 20000 n_burns = 2000 # burn-in loc = 0.0 scale = dQ/eps n_bins = 100 start = time.clock() values = mcmc_simulation(loc, eps, step_size, n_steps, n_burns, dQ, is_two=False) print "mcmc_simulation - DONE, elapsed", time.clock() - start # the histogram of the data with histtype='step' x = np.array(values) n, bins, patches = P.hist(x, n_bins, normed=1, histtype='stepfilled') # bins: ndarray of 51 elements P.setp(patches, 'facecolor', 'g', 'alpha', 0.75) # add a line showing the expected distribution y = np.exp(-abs(bins-loc/scale))/(2.*scale) l = P.plot(bins, y, 'k--', linewidth=1.5) P.show()