Пример #1
0
 def computeError(self):        
     """Computes absolute error using an L2 norm for the solution.
     This requires that self.u and self.old_u must be appropriately
     setup."""        
     # use flat
     v = (self.u - self.old_u).flat
     return numpy.sqrt(numpy.dot(v,v))
Пример #2
0
 def computeError(self):
     """Computes absolute error using an L2 norm for the solution.
     This requires that self.u and self.old_u must be appropriately
     setup."""
     # use flat
     v = (self.u - self.old_u).flat
     return numpy.sqrt(numpy.dot(v, v))
Пример #3
0
    def slowTimeStep(self, dt=0.0):
        """Takes a time step using straight forward Python loops."""
        g = self.grid
        nx, ny = g.u.shape        
        dx2, dy2 = g.dx**2, g.dy**2
        dnr_inv = 0.5/(dx2 + dy2)
        # small change here so we can see gain vs numpy slow
        #u = g.u
        u = g.u.get()

        err = 0.0
        for i in range(1, nx-1):
            for j in range(1, ny-1):
                tmp = u[i,j]
                u[i,j] = ((u[i-1, j] + u[i+1, j])*dy2 +
                          (u[i, j-1] + u[i, j+1])*dx2)*dnr_inv
                diff = u[i,j] - tmp
                err += diff*diff

        return numpy.sqrt(err)
Пример #4
0
    def slowTimeStep(self, dt=0.0):
        """Takes a time step using straight forward Python loops."""
        g = self.grid
        nx, ny = g.u.shape
        dx2, dy2 = g.dx**2, g.dy**2
        dnr_inv = 0.5 / (dx2 + dy2)
        # small change here so we can see gain vs numpy slow
        #u = g.u
        u = g.u.get()

        err = 0.0
        for i in range(1, nx - 1):
            for j in range(1, ny - 1):
                tmp = u[i, j]
                u[i, j] = ((u[i - 1, j] + u[i + 1, j]) * dy2 +
                           (u[i, j - 1] + u[i, j + 1]) * dx2) * dnr_inv
                diff = u[i, j] - tmp
                err += diff * diff

        return numpy.sqrt(err)
Пример #5
0
#Identity= array(diag([1]*n), dtype=double)

#np.timer_reset()
#np.evalflush()
stime = time.time()
for i in xrange(k):
    #distance between all pairs of objects
    Fx = np.dot(OnesCol, PxT) - np.dot(Px, OnesRow)
    Fy = np.dot(OnesCol, PyT) - np.dot(Py, OnesRow)
    Fz = np.dot(OnesCol, PzT) - np.dot(Pz, OnesRow)

    Dsq = Fx * Fx
    Dsq += Fy * Fy
    Dsq += Fz * Fz
    #Dsq += Identity
    D = np.sqrt(Dsq)

    #mutual forces between all pairs of objects
    F = np.dot(M, MT)
    F *= G
    F /= Dsq
    del Dsq
    #F = F - diag(diag(F))#set 'self attraction' to 0
    Fx /= D
    Fx *= F
    Fy /= D
    Fy *= F
    Fz /= D
    Fz *= F
    del D
    del F