def plotGrid(self): from matplotlib import pyplot as plt from numpy import empty as npempty pts = len(self.indices) xpts = npempty(pts) if self.dim==1: for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i] = self.gP[pt].pointPosition(pt)[0] ax = plt.gca() ax.yaxis.set_visible(False) plt.plot(xpts,xpts/xpts,'*') elif self.dim==2: ypts = npempty(pts) for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i], ypts[i] = self.gP[pt].pointPosition(pt) plt.plot(xpts,ypts,'*') else: if self.dim > 3: print "Showing first three dimensions only" from mpl_toolkits.mplot3d import Axes3D Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ypts = npempty(pts) zpts = npempty(pts) for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i], ypts[i], zpts[i] = self.gP[pt].pointPosition(pt)[:3] ax.scatter(xpts, ypts, zpts) plt.show()
def plotGrid(self): from matplotlib import pyplot as plt from numpy import empty as npempty pts = len(self.indices) xpts = npempty(pts) if self.dim == 1: for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i] = self.gP[pt].pointPosition(pt)[0] ax = plt.gca() ax.yaxis.set_visible(False) plt.plot(xpts, xpts / xpts, '*') elif self.dim == 2: ypts = npempty(pts) for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i], ypts[i] = self.gP[pt].pointPosition(pt) plt.plot(xpts, ypts, '*') else: if self.dim > 3: print "Showing first three dimensions only" from mpl_toolkits.mplot3d import Axes3D Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ypts = npempty(pts) zpts = npempty(pts) for i in xrange(pts): pt = tuple(self.indices[i]) xpts[i], ypts[i], zpts[i] = self.gP[pt].pointPosition(pt)[:3] ax.scatter(xpts, ypts, zpts) plt.show()
def main(argv): """ Main part of program. :param argv: :return: """ window = Tk() canvas = Canvas(window, width=WIDTH, height=HEIGHT, bg=WHITE) canvas.pack() img = PhotoImage(width=WIDTH, height=HEIGHT) canvas.create_image((WIDTH / 2, HEIGHT / 2), image=img, state="normal") with JPTimer() as t: # compute x*x values and store them in a numpy array x_squareds = npempty((WIDTH, 1), dtype=float) for i in range(WIDTH): x = CORNA + (SIDE * i / 100.0) x_squareds[i, 0] = x * x # compute y*y values and store them in a numpy array y_squareds = npempty((HEIGHT, 1), dtype=float) for j in range(HEIGHT): y = CORNA + (SIDE * j / 100.0) y_squareds[j, 0] = y * y # compute the bits and store them in a character array lines = [] for j in range(HEIGHT): horizontal_line = '{' for i in range(WIDTH): colorbit = color(x_squareds[i, 0], y_squareds[j, 0]) horizontal_line += (' ' + colorbit) horizontal_line += '}' lines.append(horizontal_line) img.put(' '.join(lines)) print('Time required for this version was {:06,.2f} ' 'seconds'.format(t.interval)) mainloop()
def __init__(self, size: int): """ Constructor Parameters ---------- size Size of each array in this class """ self.cs_indexes: ndarray = npfull(size, -1, int32) self.median_indexes: ndarray = npfull(size, -1, int32) self.taken_previous: ndarray = npempty(size, int32) self.taken_next: ndarray = npempty(size, int32) self.empty_next: ndarray = nparray([i + 1 for i in arange(size)], int32) self.empty_next[size - 1] = -1 # last entry set to -1 self.empty_start: int = 0 self.empty_end: int = size - 1 self.taken_start: int = -1 self.taken_end: int = -1
def dworetsky_period_find(time, mag, err, init_p, end_p, f_step, verbose=False): ''' This is the super-slow naive version taken from my thesis work. Uses the string length method in Dworetsky 1983 to calculate the period of a time-series of magnitude measurements and associated magnitude errors. Searches in linear frequency space (which obviously doesn't correspond to a linear period space). PARAMETERS: time: series of times at which mags were measured (usually some form of JD) mag: timeseries of magnitudes (np.array) err: associated errs per magnitude measurement (np.array) init_p, end_p: interval to search for periods between (both ends inclusive) f_step: step in frequency [days^-1] to use RETURNS: tuple of the following form: (periods (np.array), string_lengths (np.array), good_period_mask (boolean array)) ''' mod_mag = (mag - npmin(mag)) / (2.0 * (npmax(mag) - npmin(mag))) - 0.25 fold_time = npmin(time) # fold at the first time element init_f = 1.0 / end_p end_f = 1.0 / init_p n_freqs = npceil((end_f - init_f) / f_step) if verbose: print('searching %s frequencies between %s and %s days^-1...' % (n_freqs, init_f, end_f)) out_periods = npempty(n_freqs, dtype=np.float64) out_strlens = npempty(n_freqs, dtype=np.float64) p_goodflags = npempty(n_freqs, dtype=bool) j_range = len(mag) - 1 for i in range(int(n_freqs)): period = 1.0 / init_f # print('P: %s, f: %s, i: %s, n_freqs: %s, maxf: %s' % # (period, init_f, i, n_freqs, end_f)) phase = (time - fold_time) / period - npfloor( (time - fold_time) / period) phase_sort_ind = npargsort(phase) phase_sorted = phase[phase_sort_ind] mod_mag_sorted = mod_mag[phase_sort_ind] strlen = 0.0 epsilon = 2.0 * npmean(err) delta_l = 0.34 * (epsilon - 0.5 * (epsilon**2)) * (len(time) - npsqrt(10.0 / epsilon)) keep_threshold_1 = 1.6 + 1.2 * delta_l l = 0.212 * len(time) sig_l = len(time) / 37.5 keep_threshold_2 = l + 4.0 * sig_l # now calculate the string length for j in range(j_range): strlen += npsqrt((mod_mag_sorted[j + 1] - mod_mag_sorted[j])**2 + (phase_sorted[j + 1] - phase_sorted[j])**2) strlen += npsqrt((mod_mag_sorted[0] - mod_mag_sorted[-1])**2 + (phase_sorted[0] - phase_sorted[-1] + 1)**2) if ((strlen < keep_threshold_1) or (strlen < keep_threshold_2)): p_goodflags[i] = True out_periods[i] = period out_strlens[i] = strlen init_f += f_step return (out_periods, out_strlens, p_goodflags)
def empty(shape, dtype=float, order='C'): return tensor(npempty(shape, dtype=dtype, order=order))