def learn(self, n_epoch=10000, sigma=(0.25, 0.01), lrate=(0.5, 0.01)): t = np.linspace(0, 1, n_epoch) lrate = lrate[0] * (lrate[1] / lrate[0])**t sigma = sigma[0] * (sigma[1] / sigma[0])**t I = np.random.randint(0, len(self.samples), n_epoch) self.samples = self.samples[I] pts = Points(self.samples, r=2) doc = Text(__doc__) pb = ProgressBar(0, n_epoch) for i in pb.range(): pb.print("epochs") # Get random sample data = self.samples[i] # Get index of nearest node (minimum distance) winner = np.argmin(((self.codebook - data)**2).sum(axis=-1)) # Gaussian centered on winner G = np.exp(-self.distance[winner]**2 / sigma[i]**2) # Move nodes towards sample according to Gaussian self.codebook -= lrate[i] * G[..., np.newaxis] * (self.codebook - data) # Draw network if i > 500 and not i % 20 or i == n_epoch - 1: x, y, z = [self.codebook[:, i].reshape(n, n) for i in range(3)] grd = Grid(resx=n - 1, resy=n - 1).wire(False).lw(0.5).bc('lightblue') for i in range(n): for j in range(n): grd.setPoint(i * n + j, (x[i, j], y[i, j], z[i, j])) show(doc, pts, grd, axes=6, bg='w', azimuth=2, interactive=False) return [self.codebook[:, i].reshape(n, n) for i in range(3)]
def demo3d_hanoi(**kwargs): nr_disks = kwargs.get("nr_disks", 5) interactive = kwargs.get("interactive", 1) hanoi = Hanoi(nr_disks) tower_states = list([hanoi.towers]) for _ in hanoi.moves(): tower_states.append(hanoi.towers) vp = Plotter(axes=0, interactive=0, bg="w", size=(800, 600)) vp.camera.SetPosition([18.5, -20.7, 7.93]) vp.camera.SetFocalPoint([3.0, 0.0, 2.5]) vp.camera.SetViewUp([-0.1, +0.17, 0.977]) cols = makePalette("red", "blue", hanoi.nr_disks + 1, hsv=True) disks = { hanoi.nr_disks - i: Cylinder(pos=[0, 0, 0], r=0.2 * (hanoi.nr_disks - i + 1), c=cols[i]) for i in range(hanoi.nr_disks) } for k in disks: vp += disks[k] vp += Box(pos=(3.0, 0, -.5), length=12.0, width=4.0, height=0.1) vp.show(zoom=1.2) printc("\n Press q to continue, Esc to exit. ", c="y", invert=1) pb = ProgressBar(0, len(tower_states), 1, c="b", ETA=False) for t in pb.range(): pb.print() state = tower_states[t] for tower_nr in range(3): for i, disk in enumerate(state[tower_nr]): disks[disk].pos([3 * tower_nr, 0, i + 0.5]) vp.show(resetcam=0, interactive=interactive, rate=10) vp.show(resetcam=0, interactive=1)
pcmj = p[j]-ptot*mj/mtot rrel = norm(pos[j]-pos[i]) pcmi = pcmi-2*np.dot(pcmi,rrel)*rrel # bounce in cm frame pcmj = pcmj-2*np.dot(pcmj,rrel)*rrel p[i] = pcmi+ptot*mi/mtot # transform momenta back to lab frame p[j] = pcmj+ptot*mj/mtot pos[i] = pos[i]+(p[i]/mi)*deltat # move forward deltat in time pos[j] = pos[j]+(p[j]/mj)*deltat # Bounce off the boundary of the torus for j in range(Natoms): poscircle[j] = norm(pos[j])*RingRadius*[1,1,0] outside = np.greater_equal(mag(poscircle-pos),RingThickness-2*Ratom) for k in range(len(outside)): if outside[k]==1 and np.dot(p[k], pos[k]-poscircle[k])>0: p[k] = reflection(p[k],pos[k]-poscircle[k]) # then update positions of display objects for i in range(Natoms): Atoms[i].pos(pos[i]) ### <-- outside = np.greater_equal(mag(pos), RingRadius+RingThickness) vp.render(resetcam=1) ### <-- vp.camera.Azimuth(.5) vp.camera.Elevation(.1) pb.print() vp.show()
#initial conditions v = vector(0, 0, 0.2) x = vector(x0, 0, 0) xr = vector(l_rest, 0, 0) sx0 = vector(-0.8, 0, 0) offx = vector(0, 0.3, 0) vp.box(pos=(0, -0.1, 0), length=2.0, width=0.02, height=0.5) #surface vp.box(pos=(-.82, .15, 0), length=.04, width=0.50, height=0.3) #wall block = vp.cube(pos=x, length=0.2, c='t') spring = vp.helix(sx0, x, r=.06, thickness=.01, texture='metal1') pb = ProgressBar(0, 500, c='r') for i in pb.range(): F = -k * (x - xr) - b * v # Force and friction a = F / m # acceleration v = v + a * dt # velocity x = x + v * dt + 1 / 2 * a * dt**2 # position block.pos(x) # update block position spring.stretch(sx0, x) # stretch helix accordingly trace = vp.point(x + offx, c='r/0.5', r=3) # leave a red trace vp.camera.Azimuth(.1) vp.camera.Elevation(.1) vp.render(trace) # add trace to the list of actors and render pb.print('Fx=' + str(F[0])) vp.show(interactive=1)
ynew = y + vnew * dt + 1 / 2 * accel(y, vnew, t) * dt**2 return ynew, vnew positions_eu, positions_rk = [], [] y_eu, y_rk = np.array(y), np.array(y) v_eu, v_rk = np.array(v), np.array(v) t = 0 pb = ProgressBar(0, Nsteps, c="blue", ETA=0) for i in pb.range(): y_eu, v_eu = euler(y_eu, v_eu, t, dt) y_rk, v_rk = rk4(y_rk, v_rk, t, dt) t += dt positions_eu.append(y_eu) # store result of integration positions_rk.append(y_rk) pb.print("Integrate: RK-4 and Euler") #################################################### # Visualize the result #################################################### vp = Plotter(interactive=0, axes=2) # choose axes type nr.2 vp.ytitle = "u(x,t)" vp.ztitle = "" # will not draw z axis for i in x: vp += Point([i, 0, 0], c="green", r=6) pts_actors_eu = vp.actors # save a copy of the actors list pts_actors_eu[0].legend = "Euler method" vp.actors = [] # clean up the list
R12 = Pos[s2]-Pos[s1] nR12 = np.linalg.norm(R12) d12 = Radius[s1]+Radius[s2] - nR12 tau = R12/nR12 DR0 = d12*tau x1 = Mass[s1]/(Mass[s1]+Mass[s2]) x2 = 1-x1 # x2 = Mass[s2]/(Mass[s1]+Mass[s2]) Pos[s1] -= x2*DR0 Pos[s2] += x1*DR0 DV0 = 2*dot(Vel[s2]-Vel[s1], tau)*tau Vel[s1] += x2*DV0 Vel[s2] -= x1*DV0 # Update the location of the spheres for s in range(Nsp): Spheres[s].pos([Pos[s][0],Pos[s][1],0]) if not int(i)%10: # every ten steps: rsp = [Pos[0][0],Pos[0][1],0] rsv = [Vel[0][0],Vel[0][1],0] vp.add(Point(rsp, c='r', r=5, alpha=0.1)) # leave a point trace vp.show() # render scene pb.print('#actors='+str(len(vp.actors))) vp.show(interactive=1)
for colony in colonies: newcells = [] for cell in colony.cells: if cell.dieAt(t): continue if cell.divideAt(t): newc = cell.split() # make daughter cell vp += Line(cell.pos, newc.pos, c="k", lw=3, alpha=0.5) newcells.append(newc) newcells.append(cell) colony.cells = newcells pts = [c.pos for c in newcells] # draw all points at once vp += Points(pts, c=colony.color, r=5, alpha=0.80) # nucleus vp += Points(pts, c=colony.color, r=15, alpha=0.05) # halo msg += str(len(colony.cells)) + "," pb.print(msg + str(int(t))) vp.show(resetcam=0) # draw the oriented ellipsoid that contains 50% of the cells for colony in colonies: pts = [c.pos for c in colony.cells] a = pcaEllipsoid(pts, pvalue=0.5, pcaAxes=0) a.color(colony.color).alpha(0.3) a.legend("1/rate=" + str(colony.cells[0].tdiv) + "h") vp += a vp.show(resetcam=0, interactive=1)
x = vector(x0, 0, 0) xr = vector(L, 0, 0) sx0 = vector(-0.8, 0, 0) offx= vector(0, 0.3, 0) vp.add(box(pos=(0, -0.1, 0), length=2.0, width=0.02, height=0.5)) #surface vp.add(box(pos=(-.82,.15,0), length=.04, width=0.50, height=0.3)) #wall block = cube(pos=x, length=0.2, c='tomato') block.addTrail(offset=[0,0.2,0], alpha=0.6, lw=2, n=500) spring = helix(sx0, x, r=.06, thickness=.01, texture='metal1') vp.add([block, spring]) pb = ProgressBar(0,300, c='r') for i in pb.range(): F = -k*(x-xr) - b*v # Force and friction a = F/m # acceleration v = v + a * dt # velocity x = x + v*dt + 1/2 * a * dt**2 # position block.pos(x) # update block position and trail spring.stretch(sx0, x) # stretch helix accordingly vp.camera.Azimuth(0.1) vp.camera.Elevation(0.1) vp.render() pb.print('Fx='+str(round(F[0], 1))) # print Fx component vp.show(interactive=1)
ynew = y + vnew * dt + 1 / 2 * accel(y, vnew, t) * dt**2 return ynew, vnew positions_eu, positions_rk = [], [] y_eu, y_rk = np.array(y), np.array(y) v_eu, v_rk = np.array(v), np.array(v) t = 0 pb = ProgressBar(0, Nsteps, c='blue', ETA=0) for i in pb.range(): y_eu, v_eu = euler(y_eu, v_eu, t, dt) y_rk, v_rk = rk4(y_rk, v_rk, t, dt) t += dt positions_eu.append(y_eu) # store result of integration positions_rk.append(y_rk) pb.print('Integrate: RK-4 and Euler') #################################################### # Visualize the result #################################################### vp = Plotter(verbose=0, axes=2) # choose axes type nr.2 vp.ytitle = 'u(x,t)' vp.ztitle = '' # will not draw z axis for i in x: vp.point([i, 0, 0], c='green', r=6) pts_actors_eu = vp.actors # save a copy of the actors list pts_actors_eu[0].legend = 'Euler method' vp.actors = [] # clean up the list
# Check to see if the spheres are colliding for ij in hitlist: s1, s2 = divmod(ij, Nsp) # decode the spheres pair (s1,s2) colliding hitlist.remove(s2 * Nsp + s1) # remove symmetric (s2,s1) pair from list R12 = Pos[s2] - Pos[s1] nR12 = np.linalg.norm(R12) d12 = Radius[s1] + Radius[s2] - nR12 tau = R12 / nR12 DR0 = d12 * tau x1 = Mass[s1] / (Mass[s1] + Mass[s2]) x2 = 1 - x1 # x2 = Mass[s2]/(Mass[s1]+Mass[s2]) Pos[s1] -= x2 * DR0 Pos[s2] += x1 * DR0 DV0 = 2 * dot(Vel[s2] - Vel[s1], tau) * tau Vel[s1] += x2 * DV0 Vel[s2] -= x1 * DV0 # Update the location of the spheres for s in range(Nsp): Spheres[s].pos([Pos[s][0], Pos[s][1], 0]) if not int(i) % 10: # every ten steps: rsp = [Pos[0][0], Pos[0][1], 0] rsv = [Vel[0][0], Vel[0][1], 0] vp += Point(rsp, c="r", r=5, alpha=0.1) # leave a point trace vp.show() # render scene pb.print("#actors=" + str(len(vp.actors))) vp.show(interactive=1)