def main(): """ A simple example. Note that the Tkinter lines are there only because this code will be run standalone. On the interpreter, simply invoking surf and view would do the job.""" import Tkinter r = Tkinter.Tk() r.withdraw() def f(x, y): return Numeric.sin(x*y)/(x*y) x = Numeric.arange(-7., 7.05, 0.1) y = Numeric.arange(-5., 5.05, 0.05) v = surf(x, y, f) import RandomArray z = RandomArray.random((50, 25)) v1 = view(z) v2 = view(z, warp=1) z_large = RandomArray.random((1024, 512)) v3 = viewi(z_large) # A hack for stopping Python when all windows are closed. v.master = r v1.master = r v2.master = r #v3.master = r r.mainloop()
def setUp(self): self.number = 50 X = RandomArray.random(self.number) Y = RandomArray.random(self.number) Z = RandomArray.random(self.number) co = Numeric.array([X, Y, Z]) self.points = [] for i in range(len(co[0])): self.points.append(tuple(co[:, i].tolist()))
def setUp(self): self.number = 50 X = RandomArray.random(self.number) Y = RandomArray.random(self.number) Z = RandomArray.random(self.number) co = Numeric.array([X, Y, Z]) self.points = [] for i in range(len(co[0])): self.points.append(tuple(co[:,i].tolist()))
def _synth(self, freq, msdur, vol, risefall): t = arange(0, msdur / 1000.0, 1.0 / _Beeper._dafreq) s = zeros((t.shape[0], 2)) # use trapezoidal envelope with risefall (below) time if msdur < 40: risefall = msdur / 2.0 env = -abs((t - (t[-1] / 2)) / (risefall / 1000.0)) env = env - min(env) env = where(less(env, 1.0), env, 1.0) bits = _Beeper._bits if bits < 0: bits = -bits signed = 1 else: signed = 0 fullrange = power(2, bits - 1) if freq is None: y = (env * vol * fullrange * \ RandomArray.random(t.shape)).astype(Int16) else: y = (env * vol * fullrange * \ sin(2.0 * pi * t * freq)).astype(Int16) if _Beeper._chans == 2: y = transpose(array([y, y])) s = pygame.sndarray.make_sound(y) return s
def randomArray(shape, seed=None, range=(0, 1), type=Float): """Utility to generate a Numeric array full of pseudorandom numbers in the given range. This will attempt to use the RandomArray module, but fall back on using the standard random module in a loop. """ global globalSeed if not seed: if not globalSeed: globalSeed = int(time.time()) seed = globalSeed # Keep our global seed mixed up enough that many requests for # random arrays consecutively still gives random-looking output. globalSeed = (globalSeed + random.randint(1, 0xFFFFF)) & 0x7FFFFFF try: import RandomArray RandomArray.seed(seed + 1, seed + 1) return (RandomArray.random(shape) * (range[1] - range[0]) + range[0]).astype(type) except ImportError: random.seed(seed) a = zeros(multiply.reduce(shape), Float) for i in xrange(a.shape[0]): a[i] = random.random() * (range[1] - range[0]) + range[0] return reshape(a, shape).astype(type)
def _synth(self, freq, msdur, vol, risefall): t = arange(0, msdur / 1000.0, 1.0 / _Beeper._dafreq) s = zeros((t.shape[0], 2)) # use trapezoidal envelope with risefall (below) time if msdur < 40: risefall = msdur / 2.0 env = -abs((t - (t[-1] / 2)) / (risefall/1000.0)) env = env - min(env) env = where(less(env, 1.0), env, 1.0) bits = _Beeper._bits if bits < 0: bits = -bits signed = 1 else: signed = 0 fullrange = power(2, bits-1) if freq is None: y = (env * vol * fullrange * \ RandomArray.random(t.shape)).astype(Int16) else: y = (env * vol * fullrange * \ sin(2.0 * pi * t * freq)).astype(Int16) if _Beeper._chans == 2: y = transpose(array([y,y])) s = pygame.sndarray.make_sound(y) return s
def __init__(self, rows, cols, size): self.rows = rows self.cols = cols self.vectorLen = size self.weight = RandomArray.random((rows, cols, size)) self.input = [] self.loadOrder = [] self.step = 0 self.maxStep = 1000.0
def init_velocities(T, ma, ndf=None): # Simple equipartition, no Maxwell-Boltzmann # For Maxwell-Boltzmann, use RandomArray.standard_normal() import RandomArray v = RandomArray.random((len(ma), 3)) - 0.5 # Make the C.M. static vcm = v_cm(v, ma) for xyz in range(3): v[:, xyz] = v[:, xyz] - vcm[xyz] # Re-scale for correct kinetic energy kin = ekin(v, ma) # This will take into account the reduced no of degrees of freedom if ndf is None: ndf = 3 * len(ma) - 3 temp = temp_from_ekin(kin, ndf) v = v * math.sqrt(T / temp) return v
def PlotFit(traj=SandPConstantDollar, times=SandPTime, nRandomTrajs=0, a=0.04, output=False): plotEm = [] eta, trajFlattened = RemoveMeanGrowth(traj, times) plotEm.append(times) plotEm.append(trajFlattened) randomTimes = scipy.arange(times[0], times[-1] + 1.e-10, (times[-1] - times[0]) / (len(times) - 1)) randomTrajs = [] for i in range(nRandomTrajs): randomTrajs.append( scipy.exp(scipy.cumsum(a * (RandomArray.random(len(times)) - 0.5)))) randomTrajsFlattened = randomTrajs[:] for rF in randomTrajsFlattened: eta, rF = RemoveMeanGrowth(rF, randomTimes) plotEm.append(randomTimes) plotEm.append(rF) pylab.plot(*plotEm) pylab.show() if output: outputSandP = file("SandPFlattened.dat", "w") for t, data in zip(times, trajFlattened): outputSandP.write("%s %s\n" % (t, data)) outputSandP.close() outputRandom = file("OneDRandomFlattened.dat", "w") for rF in randomTrajs: eta, rF = RemoveMeanGrowth(rF, randomTimes) for t, data in zip(randomTimes, rF): outputRandom.write("%s %s\n" % (t, data)) outputRandom.write("\n") outputRandom.close()
def randn(*args): """u = randn(d0,d1,...,dn) returns zero-mean, unit-variance Gaussian random numbers in an array of size (d0,d1,...,dn).""" x1 = RandomArray.random(args) x2 = RandomArray.random(args) return sqrt(-2*log(x1))*cos(2*pi*x2)
def rand(*args): """rand(d1,...,dn) returns a matrix of the given dimensions which is initialized to random numbers from a uniform distribution in the range [0,1). """ return RandomArray.random(args)
def OnTimerFraction( self, event ): """Perform the particle-system simulation calculations""" points = self.points.coord.point colors = self.points.color.color '''Our calculations are going to need to know how much time has passed since our last event. This is complicated by the fact that a "fraction" event is cyclic, returning to 0.0 after 1.0.''' f = event.fraction() if f < self.lastFraction: f += 1.0 deltaFraction = (f-self.lastFraction) self.lastFraction = event.fraction() '''If we have received an event which is so soon after a previous event as to have a 0.0s delta (this does happen on some platforms), then we need to ignore this simulation tick.''' if not deltaFraction: return '''Each droplet has been moving at their current velocity for deltaFraction seconds, update their position with the results of this speed * time. You'll note that this is not precisely accurate for a body under acceleration, but it makes for easy calculations. Two machines running the same simulation will get *different* results here, as a faster machine will apply acceleration more frequently, resulting in a faster total velocity.''' points = points + (self.velocities*deltaFraction) '''We also cycle the droplet's colour value, though with the applied texture it's somewhat hard to see.''' colors = colors + (self.colorVelocities*deltaFraction) '''Now, apply acceleration to the current velocities such that the droplets have a new velocity for the next simulation tick.''' self.velocities[:,1] = self.velocities[:,1] + (gravity * deltaFraction) '''Find all droplets which have "retired" by falling below the y==0.0 plane.''' below = less_equal( points[:,1], 0.0) dead = nonzero(below) if isinstance( dead, tuple ): # weird numpy change here... dead = dead[0] if len(dead): '''Move all dead droplets back to the emitter.''' def put( a, ind, b ): for i in ind: a[i] = b put( points, dead, emitter) '''Re-spawn up to half of the droplets...''' dead = dead[:(len(dead)//2)+1] if len(dead): '''Reset color to initialColor, as we are sending out these droplets right now.''' put( colors, dead, initialColor) '''Assign slightly randomized versions of our initial velocity for each of the re-spawned droplets. Replace the current velocities with the new velocities.''' if RandomArray: velocities = (RandomArray.random( (len(dead),3) ) + [-.5, 0.0, -.5 ]) * initialVelocityVector else: velocities = [ array( (random.random()-.5, random.random(), random.random()-.5), 'f')* initialVelocityVector for x in xrange(len(dead)) ] def copy( a, ind, b ): for x in xrange(len(ind)): i = ind[x] a[i] = b[x] copy( self.velocities, dead, velocities) '''Now re-set the point/color fields so that the nodes notice the array has changed and they update the GL with the changed values.''' self.points.coord.point = points self.points.color.color = colors
LAST = p return p def psprint(dest="-"): if TABLE: TABLE.write_eps(dest) if __name__ == '__main__': import sys, Numeric, RandomArray x = Numeric.arrayrange(-10, 10) y = x**2 e = y / 4 a = RandomArray.random([20, 20, 3]) imagesc(a, x=range(-10, 10), y=range(-10, 10)) drawnow() sys.stdin.readline() a = Numeric.array([[[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]]) imagesc(a) drawnow() sys.stdin.readline() #plot(list(x), list(y), 'ko-') errorbar2(list(x), list(y), e, e, 'ko-')
assert allclose(computeResiduals(As, None, lmbd, Q), zeros(kconv), 0.0, tol) assert allclose(lmbd, lmbd_exact, tol*tol, 0.0) print 'OK' #------------------------------------------------------------------------------- # Test 2: K = None print 'Test 2', lmbd_exact = zeros(ncv, 'd') for k in xrange(ncv): lmbd_exact[k] = A[k,k]/M[k,k] X0 = RandomArray.random((n,ncv)) kconv, lmbd, Q, it, it_inner = jdsym.jdsym(As, Ms, None, ncv, 0.0, tol, 150, itsolvers.qmrs, jmin=5, jmax=10, eps_tr=1e-4, clvl=1) assert ncv == kconv assert allclose(computeResiduals(As, Ms, lmbd, Q), zeros(kconv), 0.0, normM*tol) assert allclose(lmbd, lmbd_exact, normM*tol*tol, 0.0) print 'OK' #------------------------------------------------------------------------------- # Test 3: general case print 'Test 3',
if show: p.show() LAST = p return p def psprint(dest="-"): if TABLE: TABLE.write_eps(dest) if __name__=='__main__' : import sys, Numeric, RandomArray x = Numeric.arrayrange(-10,10); y = x**2; e = y/4 a = RandomArray.random([20,20,3]) imagesc(a, x=range(-10,10), y=range(-10,10)) drawnow() sys.stdin.readline() a = Numeric.array([[[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0],
print "Error =", error def trainPattern(self, pattern): # will depend on self.step x, y, d = self.winner(pattern) error += self.updateMap(pattern, x, y) print "Winner is weight at (", x, y, ") (diff was", d, ") error = ", \ error def test(self): import numpy.oldnumeric as Numeric self.loadOrder = range(len(self.input)) histogram = Numeric.zeros((self.cols, self.rows), 'i') for p in self.loadOrder: x, y, d = self.winner(self.input[p]) # print "Input[%d] =" % p, self.input[p],"(%d, %d)" % (x, y) histogram[x][y] += 1 for r in range(self.rows): for c in range(self.cols): print "%5d" % histogram[c][r], print "" print "" if __name__ == '__main__': import numpy.oldnumeric as Numeric s = SOM(5, 7, 5) # rows, cols; length of high-dimensional input s.setInputs( RandomArray.random((100, 5))) s.maxStep = 100 s.train() s.test()
import RandomArray, time, sys from tables import Filters import tables.netcdf3 as NetCDF import Scientific.IO.NetCDF # create an n1dim by n2dim random array. n1dim = 1000 n2dim = 10000 print 'reading and writing a %s by %s random array ..'%(n1dim,n2dim) array = RandomArray.random((n1dim,n2dim)) filters = Filters(complevel=0,complib='zlib',shuffle=0) # create a file, put a random array in it. # no compression is used. # first, use Scientific.IO.NetCDF t1 = time.time() file = Scientific.IO.NetCDF.NetCDFFile('test.nc','w') file.createDimension('n1', None) file.createDimension('n2', n2dim) foo = file.createVariable('data', 'd', ('n1','n2',)) for n in range(n1dim): foo[n] = array[n] file.close() print 'Scientific.IO.NetCDF took',time.time()-t1,'seconds' # now use pytables NetCDF emulation layer. t1 = time.time() file = NetCDF.NetCDFFile('test.h5','w') file.createDimension('n1', None) file.createDimension('n2', n2dim) # no compression (override default filters instance). foo = file.createVariable('data', 'd', ('n1','n2',),filters=filters) # this is faster foo.append(array)
def _random_norm(shape): matrix = asarray(RandomArray.random(shape), MATCODE) return _normalize(matrix)
def testRandom(nx, ny): return RandomArray.random((nx, ny))
def OnTimerFraction(self, event): """Perform the particle-system simulation calculations""" points = self.points.coord.point colors = self.points.color.color '''Our calculations are going to need to know how much time has passed since our last event. This is complicated by the fact that a "fraction" event is cyclic, returning to 0.0 after 1.0.''' f = event.fraction() if f < self.lastFraction: f += 1.0 deltaFraction = (f - self.lastFraction) self.lastFraction = event.fraction() '''If we have received an event which is so soon after a previous event as to have a 0.0s delta (this does happen on some platforms), then we need to ignore this simulation tick.''' if not deltaFraction: return '''Each droplet has been moving at their current velocity for deltaFraction seconds, update their position with the results of this speed * time. You'll note that this is not precisely accurate for a body under acceleration, but it makes for easy calculations. Two machines running the same simulation will get *different* results here, as a faster machine will apply acceleration more frequently, resulting in a faster total velocity.''' points = points + (self.velocities * deltaFraction) '''We also cycle the droplet's colour value, though with the applied texture it's somewhat hard to see.''' colors = colors + (self.colorVelocities * deltaFraction) '''Now, apply acceleration to the current velocities such that the droplets have a new velocity for the next simulation tick.''' self.velocities[:, 1] = self.velocities[:, 1] + (gravity * deltaFraction) '''Find all droplets which have "retired" by falling below the y==0.0 plane.''' below = less_equal(points[:, 1], 0.0) dead = nonzero(below) if isinstance(dead, tuple): # weird numpy change here... dead = dead[0] if len(dead): '''Move all dead droplets back to the emitter.''' def put(a, ind, b): for i in ind: a[i] = b put(points, dead, emitter) '''Re-spawn up to half of the droplets...''' dead = dead[:(len(dead) // 2) + 1] if len(dead): '''Reset color to initialColor, as we are sending out these droplets right now.''' put(colors, dead, initialColor) '''Assign slightly randomized versions of our initial velocity for each of the re-spawned droplets. Replace the current velocities with the new velocities.''' if RandomArray: velocities = (RandomArray.random((len(dead), 3)) + [-.5, 0.0, -.5]) * initialVelocityVector else: velocities = [ array((random.random() - .5, random.random(), random.random() - .5), 'f') * initialVelocityVector for x in xrange(len(dead)) ] def copy(a, ind, b): for x in xrange(len(ind)): i = ind[x] a[i] = b[x] copy(self.velocities, dead, velocities) '''Now re-set the point/color fields so that the nodes notice the array has changed and they update the GL with the changed values.''' self.points.coord.point = points self.points.color.color = colors
import RandomArray, time, sys from tables import Filters import tables.netcdf3 as NetCDF import Scientific.IO.NetCDF # create an n1dim by n2dim random array. n1dim = 1000 n2dim = 10000 print 'reading and writing a %s by %s random array ..' % (n1dim, n2dim) array = RandomArray.random((n1dim, n2dim)) filters = Filters(complevel=0, complib='zlib', shuffle=0) # create a file, put a random array in it. # no compression is used. # first, use Scientific.IO.NetCDF t1 = time.time() file = Scientific.IO.NetCDF.NetCDFFile('test.nc', 'w') file.createDimension('n1', None) file.createDimension('n2', n2dim) foo = file.createVariable('data', 'd', ( 'n1', 'n2', )) for n in range(n1dim): foo[n] = array[n] file.close() print 'Scientific.IO.NetCDF took', time.time() - t1, 'seconds' # now use pytables NetCDF emulation layer. t1 = time.time() file = NetCDF.NetCDFFile('test.h5', 'w') file.createDimension('n1', None) file.createDimension('n2', n2dim) # no compression (override default filters instance).
"""Matlab(tm) compatibility functions.