我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用math.floor()。
def set_pwm_freq(self, freq_hz): """Set the PWM frequency to the provided value in hertz.""" prescaleval = 25000000.0 # 25MHz prescaleval /= 4096.0 # 12-bit prescaleval /= float(freq_hz) prescaleval -= 1.0 logger.debug('Setting PWM frequency to {0} Hz'.format(freq_hz)) logger.debug('Estimated pre-scale: {0}'.format(prescaleval)) prescale = int(math.floor(prescaleval + 0.5)) logger.debug('Final pre-scale: {0}'.format(prescale)) oldmode = self._device.readU8(MODE1); newmode = (oldmode & 0x7F) | 0x10 # sleep self._device.write8(MODE1, newmode) # go to sleep self._device.write8(PRESCALE, prescale) self._device.write8(MODE1, oldmode) time.sleep(0.005) self._device.write8(MODE1, oldmode | 0x80)
def invoke(self, context, event): sequencer = bpy.ops.sequencer # get current frame and channel the mouse hovers x, y = context.region.view2d.region_to_view( x=event.mouse_region_x, y=event.mouse_region_y) frame, channel = round(x), floor(y) # Strip selection sequencer.select_all(action='DESELECT') to_select = find_strips_mouse(frame, channel) if not to_select: return {"CANCELLED"} for s in to_select: s.mute = not s.mute return {"FINISHED"}
def create_vote(self, action, player, finished_event): new_vote = Vote() new_vote.action = action new_vote.requester = player new_vote.votes_current = [] needed_votes = math.ceil(self.instance.player_manager.count_players / 2) if needed_votes == math.floor(self.instance.player_manager.count_players / 2): needed_votes += 1 if needed_votes > self.instance.player_manager.count_players: needed_votes = self.instance.player_manager.count_players new_vote.votes_required = needed_votes new_vote.vote_added = self.vote_added new_vote.vote_removed = self.vote_removed new_vote.vote_finished = finished_event asyncio.ensure_future(self.vote_reminder(new_vote)) return new_vote
def pay_to_player(self, player, data, **kwargs): try: amount = abs(int(data.amount)) planets = await self.instance.gbx('GetServerPlanets') if amount <= (planets - 2 - math.floor(amount * 0.05)): async with self.lock: bill_id = await self.instance.gbx('Pay', data.login, amount, 'Payment from the server') self.current_bills[bill_id] = dict(bill=bill_id, admin=player, player=data.login, amount=-amount) else: message = '$i$f00Insufficient balance for paying $fff{}$f00 ($fff{}$f00 inc. tax) planets, only got $fff{}$f00.'.format( amount, (amount + 2 + math.floor(amount * 0.05)), planets ) await self.instance.chat(message, player) except ValueError: message = '$z$s$fff» $i$f00The amount should be a numeric value.' await self.instance.chat(message, player)
def format_time(time): """ Format time from integer milliseconds to string format that could be displayed to the end-user. :param time: Integer time in milliseconds. :type time: int :return: String output :rtype: str """ hours = math.floor((time / 1000 / 60 / 60)) minutes = math.floor((time - (hours * 60 * 60 * 1000)) / 1000 / 60) seconds = math.floor((time - (hours * 60 * 60 * 1000) - (minutes * 60 * 1000)) / 1000) millis = (time - (hours * 60 * 60 * 1000) - (minutes * 60 * 1000) - (seconds * 1000)) formatted_time = '' if hours > 0: formatted_time += '{:02d}:{:02d}:'.format(hours, minutes) else: formatted_time += '{}:'.format(str(minutes)) return formatted_time + '{:02d}.{:03d}'.format(seconds, millis)
def split_episodes(self, episode_paths, n_train, n_valid, n_test, seed=None, use_all=True): """Split episodes between training, validation and test sets. seed: random seed (have split performed consistently every time)""" if seed is not None: random_state = np.random.get_state() np.random.seed(seed) np.random.shuffle(episode_paths) np.random.set_state(random_state) else: np.random.shuffle(episode_paths) if use_all: multiplier = float(len(episode_paths)) / float(n_train + n_valid + n_test) n_train = int(math.floor(multiplier * n_train)) n_valid = int(math.floor(multiplier * n_valid)) n_test = int(math.floor(multiplier * n_test)) assert n_train + n_valid + n_test <= len(episode_paths) return (episode_paths[:n_train], episode_paths[n_train:n_train + n_valid], episode_paths[n_train + n_test:n_train + n_test + n_test])
def interclick(clicktime1, clicktime2): second1 = clicktime1 % 100 clicktime1 = clicktime1 // 100 min1 = clicktime1 % 100 hour1 = math.floor((clicktime1 % 10000) / 100) day1 = math.floor(clicktime1 / 10000) second2 = clicktime2 % 100 clicktime2 = clicktime2 // 100 min2 = clicktime2 % 100 hour2 = math.floor((clicktime2 % 10000) / 100) day2 = math.floor(clicktime2 / 10000) interclicktime_min = ((day2 * 1440 + hour2 * 60 + min2) - (day1 * 1440 + hour1 * 60 + min1)) interclicktime_second = ((day2 * 1440 + hour2 * 60 + min2) * 60 + second2) - ( (day1 * 1440 + hour1 * 60 + min1) * 60 + second1) return interclicktime_min, interclicktime_second
def lumogon(file): """ Lumogon scans the output from the lumogon container inspection tool """ cve_data = load_vulnerability_database() containers = load_data(file)["containers"] for container in containers: click.secho("==> Scanning %s" % containers[container]["container_name"], fg="blue") packages = containers[container]["capabilities"]["dpkg"]["payload"] host = containers[container]["capabilities"]["host"]["payload"] os = DEBIAN_CODENAMES[math.floor(float(host["platformversion"]))] for package in sorted(packages): version = packages[package] vulns = determine_cves(package, version, os, cve_data) print_vulns(package, vulns)
def __nearest_pow_2(self,x): """ Find power of two nearest to x >>> _nearest_pow_2(3) 2.0 >>> _nearest_pow_2(15) 16.0 :type x: float :param x: Number :rtype: Int :return: Nearest power of 2 to x """ a = math.pow(2, math.ceil(np.log2(x))) b = math.pow(2, math.floor(np.log2(x))) if abs(a - x) < abs(b - x): return a else: return b # calculate spectrogram of signals
def _nearest_pow_2(x): """ Find power of two nearest to x >>> _nearest_pow_2(3) 2.0 >>> _nearest_pow_2(15) 16.0 :type x: float :param x: Number :rtype: Int :return: Nearest power of 2 to x """ a = M.pow(2, M.ceil(np.log2(x))) b = M.pow(2, M.floor(np.log2(x))) if abs(a - x) < abs(b - x): return a else: return b
def compute_logarithmic_scale(min_, max_, min_scale, max_scale): """Compute an optimal scale for logarithmic""" if max_ <= 0 or min_ <= 0: return [] min_order = int(floor(log10(min_))) max_order = int(ceil(log10(max_))) positions = [] amplitude = max_order - min_order if amplitude <= 1: return [] detail = 10. while amplitude * detail < min_scale * 5: detail *= 2 while amplitude * detail > max_scale * 3: detail /= 2 for order in range(min_order, max_order + 1): for i in range(int(detail)): tick = (10 * i / detail or 1) * 10 ** order tick = round_to_scale(tick, tick) if min_ <= tick <= max_ and tick not in positions: positions.append(tick) return positions
def percentile(N, percent, key=lambda x:x): """ Find the percentile of a list of values. @parameter N - is a list of values. Note N MUST BE already sorted. @parameter percent - a float value from 0.0 to 1.0. @parameter key - optional key function to compute value from each element of N. @return - the percentile of the values """ if not N: return None k = (len(N)-1) * percent f = math.floor(k) c = math.ceil(k) if f == c: return key(N[int(k)]) d0 = key(N[int(f)]) * (c-k) d1 = key(N[int(c)]) * (k-f) return d0+d1 # median is 50th percentile.
def package(): sent_package = {} sent_package['get_requests'] = get_requests def has_requests(project, branch): return len(get_requests(project, branch)) > 0 sent_package['has_requests'] = has_requests sent_package['get_log_diff'] = get_log_diff sent_package['last_modified'] = last_modified sent_package['get_branch_by_name'] = get_branch_by_name sent_package['hash'] = lambda x: hashlib.sha256(x).hexdigest() sent_package['_'] = _ sent_package['url_encode'] = lambda x: urllib.quote(x, safe='') sent_package['current_user'] = current_user sent_package['floor'] = math.floor sent_package['len'] = len sent_package['getattr'] = getattr sent_package['commit_diff'] = commit_diff return sent_package
def stop_foraging(self): if self.last_action and self.last_action[0] == "foraging": item = self.last_action[1] time_spent = math.ceil(time.time() - self.last_action_time) / 60 self.last_action = None self.last_action_time = None item_amount = math.floor(time_spent * self.foraging_rate) self.inventory[item] = self.inventory.get(item, 0) + item_amount if self.inventory[item] == 0: del self.inventory[item] self.foraging_xp += item_amount secondary_item = forageables[item][0] tertiary_item = forageables[item][1] secondary_amount = random.randint(0, item_amount) tertiary_amount = math.floor(random.randint(0, item_amount) / 100) self.inventory[secondary_item] = self.inventory.get(secondary_item, 0) + secondary_amount if self.inventory[secondary_item] == 0: del self.inventory[secondary_item] self.inventory[tertiary_item] = self.inventory.get(tertiary_item, 0) + tertiary_amount if self.inventory[tertiary_item] == 0: del self.inventory[tertiary_item] self.write_data() return item, time_spent, item_amount, secondary_amount, tertiary_amount else: return False, self.last_action
def stop_woodcutting(self): if self.last_action and self.last_action[0] == "woodcutting": wood_type = self.last_action[1] time_spent = math.ceil(time.time() - self.last_action_time) / 60 self.last_action = None self.last_action = None current_wood_lvl = wood_lvl(wood_type) wood_amount = math.floor(time_spent * self.wood_rate(wood_type) * self.woodcutting_rate) xp_amount = current_wood_lvl * wood_amount self.inventory[wood_type] = self.inventory.get(wood_type, 0) + wood_amount if self.inventory[wood_type] == 0: del self.inventory[wood_type] self.woodcutting_xp += xp_amount self.write_data() return wood_type, time_spent, wood_amount, xp_amount else: return False, self.last_action
def __init__(self, archivelist): self.node_archives = archivelist self.jobdir = os.path.dirname(archivelist[0]) self.job_id = "1" self.end_str = "end" self.walltime = 9751 self.nodecount = len(archivelist) self.acct = {"end_time": 12312, "id": 1, "uid": "sdf", "user": "werqw"} self.nodes = ["node" + str(i) for i in xrange(len(archivelist))] self._data = {} archive_starts = [] archive_ends = [] for archive in archivelist: context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, archive) mdata = context.pmGetArchiveLabel() archive_starts.append(datetime.datetime.utcfromtimestamp(math.floor(mdata.start))) archive_ends.append(datetime.datetime.utcfromtimestamp(math.ceil(context.pmGetArchiveEnd()))) self.start_datetime = min(archive_starts) self.end_datetime = max(archive_ends)
def adjust_job_start_end(job): """ Set the job node start and end times based on the presence of the special job-X-begin and job-X-end archives. Do nothing if these archives are absent """ startarchive = "job-{0}-begin".format(job.job_id) endarchive = "job-{0}-end".format(job.job_id) for nodename, filepaths in job.rawarchives(): begin = None end = None for fname in filepaths: filename = os.path.basename(fname) if filename.startswith(startarchive): context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, fname) mdata = context.pmGetArchiveLabel() begin = datetime.datetime.utcfromtimestamp(math.floor(mdata.start)) if filename.startswith(endarchive): context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, fname) end = datetime.datetime.utcfromtimestamp(math.ceil(context.pmGetArchiveEnd())) job.setnodebeginend(nodename, begin, end)
def __init__(self, data, batch_size, big_batch=10): self.data_inp = [item + [_EOS_ID] for item in data['input']] self.data_spc = data['speaker_code'] self.data_out = data['output'] self.samples = len(self.data_inp) self.batch_size = batch_size self.big_batch = big_batch self.big_batch_step = 0 if batch_size == 'all': self.batch_size = self.samples self.big_batch = 1 if self.samples < self.big_batch * self.batch_size: self.max_batch_step = ceil(self.samples / (self.big_batch * self.batch_size)) else: self.max_batch_step = floor(self.samples / (self.big_batch * self.batch_size)) - 1 self.run_through = 0 self.perm = None self.perm_index = np.arange(min(self.big_batch * self.batch_size, self.samples)) self.batch = None
def tileAddress(self, zoom, point): "Returns a tile address based on a zoom level and \ a point in the tile" [x, y] = point assert x <= self.extent[2] and x >= self.extent[0] assert y <= self.extent[3] and y >= self.extent[1] assert zoom in range(0, len(self.RESOLUTIONS)) tileS = self.tileSize(zoom) offsetX = abs(x - self.MINX) if self.originCorner == 'bottom-left': offsetY = abs(y - self.MINY) elif self.originCorner == 'top-left': offsetY = abs(self.MAXY - y) col = offsetX / tileS row = offsetY / tileS # We are exactly on the edge of a tile and the extent if x in (self.MINX, self.MAXX) and col.is_integer(): col = max(0, col - 1) if y in (self.MINY, self.MAXY) and row.is_integer(): row = max(0, row - 1) return [ int(math.floor(col)), int(math.floor(row)) ]
def __init__(self, inplanes, planes, cardinality, base_width, stride=1, downsample=None): super(ResNeXtBottleneck, self).__init__() D = int(math.floor(planes * (base_width/64.0))) C = cardinality self.conv_reduce = nn.Conv2d(inplanes, D*C, kernel_size=1, stride=1, padding=0, bias=False) self.bn_reduce = nn.BatchNorm2d(D*C) self.conv_conv = nn.Conv2d(D*C, D*C, kernel_size=3, stride=stride, padding=1, groups=cardinality, bias=False) self.bn = nn.BatchNorm2d(D*C) self.conv_expand = nn.Conv2d(D*C, planes*4, kernel_size=1, stride=1, padding=0, bias=False) self.bn_expand = nn.BatchNorm2d(planes*4) self.downsample = downsample
def predict(self, x): x = NNDist._transfer_x(np.asarray(x)) rs = [] batch_size = floor(1e6 / np.prod(x.shape[1:])) epoch = int(ceil(len(x) / batch_size)) output = self._sess.graph.get_tensor_by_name(self._output) bar = ProgressBar(max_value=epoch, name="Predict") bar.start() for i in range(epoch): if i == epoch - 1: rs.append(self._sess.run(output, { self._entry: x[i * batch_size:] })) else: rs.append(self._sess.run(output, { self._entry: x[i * batch_size:(i + 1) * batch_size] })) bar.update() return np.vstack(rs).astype(np.float32)
def _vernal_equinox(y): """???????????????????3??????????? """ if y <= 1947: d = 0 elif y <= 1979: d = math.floor( 20.8357 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) elif y <= 2099: d = math.floor( 20.8431 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) elif y <= 2150: d = math.floor( 21.8510 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) else: d = 99 return d
def _autumn_equinox(y): """???????????????????9??????????? """ if y <= 1947: d = 0 elif y <= 1979: d = math.floor( 23.2588 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) elif y <= 2099: d = math.floor( 23.2488 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) elif y <= 2150: d = math.floor( 24.2488 + 0.242194 * (y - 1980) - math.floor((y - 1980) / 4)) else: d = 99 return d
def mask_func(pattern): """ Return the mask function for the given mask pattern. """ if pattern == 0: # 000 return lambda i, j: (i + j) % 2 == 0 if pattern == 1: # 001 return lambda i, j: i % 2 == 0 if pattern == 2: # 010 return lambda i, j: j % 3 == 0 if pattern == 3: # 011 return lambda i, j: (i + j) % 3 == 0 if pattern == 4: # 100 return lambda i, j: (math.floor(i / 2) + math.floor(j / 3)) % 2 == 0 if pattern == 5: # 101 return lambda i, j: (i * j) % 2 + (i * j) % 3 == 0 if pattern == 6: # 110 return lambda i, j: ((i * j) % 2 + (i * j) % 3) % 2 == 0 if pattern == 7: # 111 return lambda i, j: ((i * j) % 3 + (i + j) % 2) % 2 == 0 raise TypeError("Bad mask pattern: " + pattern) # pragma: no cover
def setPWMFreq(self, freq): "Sets the PWM frequency" prescaleval = 25000000.0 # 25MHz prescaleval /= 4096.0 # 12-bit prescaleval /= float(freq) prescaleval -= 1.0 if (self.debug): print "Setting PWM frequency to %d Hz" % freq print "Estimated pre-scale: %d" % prescaleval prescale = math.floor(prescaleval + 0.5) if (self.debug): print "Final pre-scale: %d" % prescale oldmode = self.i2c.readU8(self.__MODE1); newmode = (oldmode & 0x7F) | 0x10 # sleep self.i2c.write8(self.__MODE1, newmode) # go to sleep self.i2c.write8(self.__PRESCALE, int(math.floor(prescale))) self.i2c.write8(self.__MODE1, oldmode) time.sleep(0.005) self.i2c.write8(self.__MODE1, oldmode | 0x80)
def _getOutputSizes(self, input): outW = self.outW outH = self.outH if self.ratioW != None and self.ratioH != None: assert input.ndimension() == 4 outW = int(math.floor(input.size(3) * self.ratioW)) outH = int(math.floor(input.size(2) * self.ratioH)) # Neither can be smaller than 1 assert outW > 0 assert outH > 0 else: assert outW != None and outH != None return outW, outH # Call this to turn off regeneration of random pooling regions each # updateOutput call.
def test_plugin_interval(self): for interval in self.intervals: self.setUp() simple_plugin = SimplePlugin(interval) self.trainer.register_plugin(simple_plugin) self.trainer.run(epochs=self.num_epochs) units = { ('iteration', self.num_iters), ('epoch', self.num_epochs), ('batch', self.num_iters), ('update', self.num_iters) } for unit, num_triggers in units: call_every = None for i, i_unit in interval: if i_unit == unit: call_every = i break if call_every: expected_num_calls = math.floor(num_triggers / call_every) else: expected_num_calls = 0 num_calls = getattr(simple_plugin, 'num_' + unit) self.assertEqual(num_calls, expected_num_calls, 0)
def _test_shuffle(self, loader): found_data = {i: 0 for i in range(self.data.size(0))} found_labels = {i: 0 for i in range(self.labels.size(0))} batch_size = loader.batch_size for i, (batch_samples, batch_targets) in enumerate(loader): for sample, target in zip(batch_samples, batch_targets): for data_point_idx, data_point in enumerate(self.data): if data_point.eq(sample).all(): self.assertFalse(found_data[data_point_idx]) found_data[data_point_idx] += 1 break self.assertEqual(target, self.labels.narrow(0, data_point_idx, 1)) found_labels[data_point_idx] += 1 self.assertEqual(sum(found_data.values()), (i+1) * batch_size) self.assertEqual(sum(found_labels.values()), (i+1) * batch_size) self.assertEqual(i, math.floor((len(self.dataset)-1) / batch_size))
def test_abs(self): size = 1000 max_val = 1000 original = torch.rand(size).mul(max_val) # Tensor filled with values from {-1, 1} switch = torch.rand(size).mul(2).floor().mul(2).add(-1) types = ['torch.DoubleTensor', 'torch.FloatTensor', 'torch.LongTensor', 'torch.IntTensor'] for t in types: data = original.type(t) switch = switch.type(t) res = torch.mul(data, switch) self.assertEqual(res.abs(), data, 1e-16) # Checking that the right abs function is called for LongTensor bignumber = 2^31 + 1 res = torch.LongTensor((-bignumber,)) self.assertGreater(res.abs()[0], 0)
def convertSize(size): if (size == 0): return '0 Bytes' size_name = ("Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB") i = int(math.floor(math.log(size,1024))) p = math.pow(1024,i) s = round(size/p,2) return '{} {}'.format(s,size_name[i]) #http://stackoverflow.com/questions/1392413/calculating-a-directory-size-using-python
def convertSize(size): if (size == 0): return '0 Bytes' size_name = ("Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB") i = int(math.floor(math.log(size,1024))) p = math.pow(1024,i) s = round(size/p,2) return '{} {}'.format(s,size_name[i])
def plotFields(layer,fieldShape=None,channel=None,figOffset=1,cmap=None,padding=0.01): # Receptive Fields Summary try: W = layer.W except: W = layer wp = W.eval().transpose(); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape fields = np.reshape(wp,list(wp.shape[0:-1])+fieldShape) else: # Convolutional layer already has shape features, channels, iy, ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) perRow = int(math.floor(math.sqrt(fields.shape[0]))) perColumn = int(math.ceil(fields.shape[0]/float(perRow))) fig = mpl.figure(figOffset); mpl.clf() # Using image grid from mpl_toolkits.axes_grid1 import ImageGrid grid = ImageGrid(fig,111,nrows_ncols=(perRow,perColumn),axes_pad=padding,cbar_mode='single') for i in range(0,np.shape(fields)[0]): im = grid[i].imshow(fields[i],cmap=cmap); grid.cbar_axes[0].colorbar(im) mpl.title('%s Receptive Fields' % layer.name) # old way # fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) # tiled = [] # for i in range(0,perColumn*perRow,perColumn): # tiled.append(np.hstack(fields2[i:i+perColumn])) # # tiled = np.vstack(tiled) # mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Receptive Fields' % layer.name); mpl.colorbar(); mpl.figure(figOffset+1); mpl.clf(); mpl.imshow(np.sum(np.abs(fields),0),cmap=cmap); mpl.title('%s Total Absolute Input Dependency' % layer.name); mpl.colorbar()
def plotOutput(layer,feed_dict,fieldShape=None,channel=None,figOffset=1,cmap=None): # Output summary try: W = layer.output except: W = layer wp = W.eval(feed_dict=feed_dict); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape temp = np.zeros(np.product(fieldShape)); temp[0:np.shape(wp.ravel())[0]] = wp.ravel() fields = np.reshape(temp,[1]+fieldShape) else: # Convolutional layer already has shape wp = np.rollaxis(wp,3,0) features, channels, iy,ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) perRow = int(math.floor(math.sqrt(fields.shape[0]))) perColumn = int(math.ceil(fields.shape[0]/float(perRow))) fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) tiled = [] for i in range(0,perColumn*perRow,perColumn): tiled.append(np.hstack(fields2[i:i+perColumn])) tiled = np.vstack(tiled) if figOffset is not None: mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Output' % layer.name); mpl.colorbar();
def plotFields(layer,fieldShape=None,channel=None,maxFields=25,figName='ReceptiveFields',cmap=None,padding=0.01): # Receptive Fields Summary W = layer.W wp = W.eval().transpose(); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape fields = np.reshape(wp,list(wp.shape[0:-1])+fieldShape) else: # Convolutional layer already has shape features, channels, iy, ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) fieldsN = min(fields.shape[0],maxFields) perRow = int(math.floor(math.sqrt(fieldsN))) perColumn = int(math.ceil(fieldsN/float(perRow))) fig = mpl.figure(figName); mpl.clf() # Using image grid from mpl_toolkits.axes_grid1 import ImageGrid grid = ImageGrid(fig,111,nrows_ncols=(perRow,perColumn),axes_pad=padding,cbar_mode='single') for i in range(0,fieldsN): im = grid[i].imshow(fields[i],cmap=cmap); grid.cbar_axes[0].colorbar(im) mpl.title('%s Receptive Fields' % layer.name) # old way # fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) # tiled = [] # for i in range(0,perColumn*perRow,perColumn): # tiled.append(np.hstack(fields2[i:i+perColumn])) # # tiled = np.vstack(tiled) # mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Receptive Fields' % layer.name); mpl.colorbar(); mpl.figure(figName+' Total'); mpl.clf(); mpl.imshow(np.sum(np.abs(fields),0),cmap=cmap); mpl.title('%s Total Absolute Input Dependency' % layer.name); mpl.colorbar()
def plotOutput(layer,feed_dict,fieldShape=None,channel=None,figOffset=1,cmap=None): # Output summary W = layer.output wp = W.eval(feed_dict=feed_dict); if len(np.shape(wp)) < 4: # Fully connected layer, has no shape temp = np.zeros(np.product(fieldShape)); temp[0:np.shape(wp.ravel())[0]] = wp.ravel() fields = np.reshape(temp,[1]+fieldShape) else: # Convolutional layer already has shape wp = np.rollaxis(wp,3,0) features, channels, iy,ix = np.shape(wp) if channel is not None: fields = wp[:,channel,:,:] else: fields = np.reshape(wp,[features*channels,iy,ix]) perRow = int(math.floor(math.sqrt(fields.shape[0]))) perColumn = int(math.ceil(fields.shape[0]/float(perRow))) fields2 = np.vstack([fields,np.zeros([perRow*perColumn-fields.shape[0]] + list(fields.shape[1:]))]) tiled = [] for i in range(0,perColumn*perRow,perColumn): tiled.append(np.hstack(fields2[i:i+perColumn])) tiled = np.vstack(tiled) if figOffset is not None: mpl.figure(figOffset); mpl.clf(); mpl.imshow(tiled,cmap=cmap); mpl.title('%s Output' % layer.name); mpl.colorbar();
def cover_region_simple(self, location1, location2): # lat values must be between -90 and +90, lng values must be between -180 and 180 l_lat1 = location1[0] l_lat2 = location2[0] l_lng1 = location1[1] l_lng2 = location2[1] ind_lat_f = 0 while l_lat1 > self.grid[ind_lat_f][0]: ind_lat_f += 1 ind_lat_t = ind_lat_f + 1 while ind_lat_t < len(self.grid) and l_lat2 >= self.grid[ind_lat_t][0]: ind_lat_t += 1 points = [] for ind_lat in range(ind_lat_f, ind_lat_t): d_lng = 360.0 / self.grid[ind_lat][1] if self.grid[ind_lat][2]: c_lng = 0.0 else: c_lng = 0.5 ind_lng_f = int(ceil(l_lng1 / d_lng - c_lng)) ind_lng_t = int(floor(l_lng2 / d_lng - c_lng)) for ind_lng in range(ind_lng_f, ind_lng_t + 1): points.append([self.grid[ind_lat][0], d_lng * (ind_lng + c_lng)]) return points
def timeSince(since): now = time.time() s = now - since m = math.floor(s / 60) s -= m * 60 return '%dm %ds' % (m, s) # In[14]:
def timeSince(since): now = time.time() s = now - since m = math.floor(s / 60) s -= m * 60 return '%dm %ds' % (m, s)
def find_cut_and_handles_closest_to_mouse(mouse_x, mouse_y): """ takes the mouse's coordinates in the sequencer area and returns the two strips who share the cut closest to the mouse, or the strip with the closest handle. Use it to find the handle(s) to select with the grab on the fly operator """ view2d = bpy.context.region.view2d closest_cut = (None, None) distance_to_closest_cut = 1000000.0 for s in bpy.context.sequences: channel_offset = s.channel + 0.5 start_x, start_y = view2d.view_to_region(s.frame_final_start, channel_offset) end_x, end_y = view2d.view_to_region(s.frame_final_start, channel_offset) distance_to_start = calculate_distance(start_x, start_y, mouse_x, mouse_y) distance_to_end = calculate_distance(end_x, end_y, mouse_x, mouse_y) if distance_to_start < distance_to_closest_cut: closest_cut = (start_x, start_y) distance_to_closest_cut = distance_to_start if distance_to_end < distance_to_closest_cut: closest_cut = (end_x, end_y) distance_to_closest_cut = distance_to_end closest_cut_local_coords = view2d.region_to_view(closest_cut[0], closest_cut[1]) frame, channel = round(closest_cut_local_coords[0]), floor(closest_cut_local_coords[1]) return frame, channel
def isPrime(self,n): if (n & 1) == 0 or (n > 5 and n % 5 == 0): return False maxCheck = math.sqrt(n) if maxCheck == math.floor(maxCheck): return False p = self.firstPrime while p != None: if p.n > maxCheck: return True if n % p.n == 0: return False p = p.nextPrime divisor = self.lastPrime.n + 2 while divisor <= maxCheck: if not self.isPrime(divisor): divisor += 2 continue self.lastPrime = self.lastPrime.setNext(divisor) if divisor > maxCheck: return True if n % divisor == 0: return False divisor += 2 return True
def getShiftedTriangularArrangement(n): t = math.sqrt(8 * n + 1); if t != math.floor(t): return [] arrangement = [] i = 1 while n>0: arrangement.append(i) n-=i i+=1 return [{'hex':True,'rows':arrangement,'type':'triangular'}]
def getTriangularArrangement(n): t = math.sqrt(n); if t != math.floor(t): return [] arrangement = [] i = 1 while n>0: arrangement.append(i) n-=i i+=2 return [{'hex':False,'rows':arrangement,'type':'triangular'}]
