def test_legvander2d(self) : # also tests polyval2d for non-square coefficient array x1, x2, x3 = self.x c = np.random.random((2, 3)) van = leg.legvander2d(x1, x2, [1, 2]) tgt = leg.legval2d(x1, x2, c) res = np.dot(van, c.flat) assert_almost_equal(res, tgt) # check shape van = leg.legvander2d([x1], [x2], [1, 2]) assert_(van.shape == (1, 5, 6))
def test_legvander2d(self) : # also tests polyval2d for non-square coefficient array x1, x2, x3 = self.x c = np.random.random((2, 3)) van = leg.legvander2d(x1, x2, [1, 2]) tgt = leg.legval2d(x1, x2, c) res = np.dot(van, c.flat) assert_almost_equal(res, tgt) # check shape van = leg.legvander2d([x1], [x2], [1, 2]) assert_(van.shape == (1, 5, 6))
def __move(self, event: Event) -> bool: if event.id in self.__phi_ijn.columns: location = self.__map.in_from(event.location) phi_ijn = legvander2d(*location, self.__degree)[0]/self.__scale.vec self.__phi_ijn.loc[:, event.id] = phi_ijn return True return False
def leg2dfit(array, deg, rcond=None, full=False, w=None): ''' 2D Legendre Fitting. This routine has an issue with mapping back off of the [-1,1] interval. The issue lies in the normalization. ''' order = int(deg) + 1 flat_array = array.ravel() # find positions of nans goodpts = np.where(np.isnan(flat_array)) if w is not None: if w.ndim != 2: raise TypeError("expected 2D array for w") if array.shape != w.shape: raise TypeError("expected array and w to have same shape") goodpts = np.where(~np.isnan(flat_array + w.ravel())) w = w.ravel()[goodpts] x, y = np.meshgrid(np.linspace(-1, 1, array.shape[0]), np.linspace(-1, 1, array.shape[1])) x, y = x.ravel()[goodpts], y.ravel()[goodpts] # check arguments. if deg < 0: raise ValueError("expected deg >= 0") # set up the least squares matrices in transposed form lhs = legvander2d(x, y, [deg, deg]).T rhs = flat_array[goodpts].T if w is not None: lhs = lhs * w rhs = rhs * w # set rcond if rcond is None: rcond = len(x) * np.finfo(x.dtype).eps # scale the design matrix and solve the least squares equation if issubclass(lhs.dtype.type, np.complexfloating): scl = np.sqrt((np.square(lhs.real) + np.square(lhs.imag)).sum(1)) else: scl = np.sqrt(np.square(lhs).sum(1)) print scl c, resids, rank, s = lstsq(lhs.T / scl, rhs.T, rcond) c = (c.T / scl).T # warn on rank reduction if rank != order**2. and not full: msg = "The fit may be poorly conditioned" warnings.warn(msg) if full: return c, [resids, rank, s, rcond] else: return c
def leg2dfit(array, deg, rcond=None, full=False, w=None): ''' 2D Legendre Fitting. This routine has an issue with mapping back off of the [-1,1] interval. The issue lies in the normalization. ''' order = int(deg) + 1 flat_array = array.ravel() # find positions of nans goodpts = np.where(np.isnan(flat_array)) if w is not None: if w.ndim != 2: raise TypeError("expected 2D array for w") if array.shape != w.shape: raise TypeError("expected array and w to have same shape") goodpts = np.where(~np.isnan(flat_array+w.ravel())) w = w.ravel()[goodpts] x, y = np.meshgrid(np.linspace(-1,1,array.shape[0]), np.linspace(-1,1,array.shape[1])) x, y = x.ravel()[goodpts], y.ravel()[goodpts] # check arguments. if deg < 0 : raise ValueError("expected deg >= 0") # set up the least squares matrices in transposed form lhs = legvander2d(x, y, [deg,deg]).T rhs = flat_array[goodpts].T if w is not None: lhs = lhs * w rhs = rhs * w # set rcond if rcond is None : rcond = len(x)*np.finfo(x.dtype).eps # scale the design matrix and solve the least squares equation if issubclass(lhs.dtype.type, np.complexfloating): scl = np.sqrt((np.square(lhs.real) + np.square(lhs.imag)).sum(1)) else: scl = np.sqrt(np.square(lhs).sum(1)) print scl c, resids, rank, s = lstsq(lhs.T/scl, rhs.T, rcond) c = (c.T/scl).T # warn on rank reduction if rank != order**2. and not full: msg = "The fit may be poorly conditioned" warnings.warn(msg) if full : return c, [resids, rank, s, rcond] else : return c
def norder2dlegendre(nx, ny): ''' Purpose ------- Create the 2D nx th and ny th order Legendre polynomial using numpy.polynomial.legendre.legvander2d(x, y, [nx, ny]) ''' x = Symbol('x') y = Symbol('y') funcarr = leg.legvander2d(x,y,[nx,ny]) funcarr = funcarr[0] # Because chebvander2d returns a 2d matrix funclist = funcarr.tolist() # lambdify only takes in lists and not arrays f = lambdify((x, y), funclist) # Note: lambdify looks at 1 as 1 and makes f[0] = 1 and not an array return funclist, f
def legForwardTransform(orders, locations, functionVals): if len(locations.shape)==1: return np.array(leg.legfit(locations, functionVals, orders[0])) else: if locations.shape[1]==2: V=leg.legvander2d(locations[:,0], locations[:,1], orders) elif locations.shape[1]==3: V=leg.legvander3d(locations[:,0],locations[:,1],locations[:,2], orders) elif locations.shape[1]==4: V=legvander4d(locations,orders) elif locations.shape[1]==5: V=legvander5d(locations,orders) else: raise NotImplementedError # there's a bad startup joke about this being good enough for the paper. ret, _, _, _=npl.lstsq(V, functionVals, rcond=None) return np.reshape(ret, (np.array(orders)+1).flatten())
def run(self) -> None: while True: try: queue_item = self.__params.point_queue.get(timeout=TIMEOUT) points = self.__type_and_shape_checked(queue_item) except OSError: raise OSError('Point queue is already closed. Instantiate a' ' new <Parallel> object to get going again!') except Empty: if self.__flag.stop.is_set(): break else: self.__phi_ijn = legvander2d(*points, self.__params.degree).T/\ self.__scale.vecT self.__minimize() self.__flag.done.set()
def culledLegForwardTransform(orders, locations, functionVals, threshold=None): # inspired by : A Simple Regularization of the Polynomial Interpolation For the Runge Phenomemenon if len(locations.shape)==1: vandermonde=leg.legvander(locations, orders[0]) elif locations.shape[1]==2: vandermonde=leg.legvander2d(locations[:,0], locations[:,1], orders) elif locations.shape[1]==3: vandermonde=leg.legvander3d(locations[:,0],locations[:,1],locations[:,2], orders) elif locations.shape[1]==4: vandermonde=legvander4d(locations,orders) elif locations.shape[1]==5: vandermonde=legvander5d(locations,orders) else: raise NotImplementedError # there's a bad startup joke about this being good enough for the paper. # preconditioner = np.diag((0.94) ** (2* (np.arange(vandermonde.shape[0])))) # vandermonde=np.dot(preconditioner, vandermonde) U,S,Vh=np.linalg.svd(vandermonde) numTake=0 filtS=S if threshold is None: Eps= np.finfo(functionVals.dtype).eps Neps = np.prod(cmn.numpyze(orders)) * Eps * S[0] #truncation due to ill-conditioning Nt = max(np.argmax(Vh, axis=0)) #"Automatic" determination of threshold due to Runge's phenomenon threshold=min(Neps, Nt) while numTake<=0: filter=S>threshold numTake=filter.sum() if numTake>0: filtU=U[:,:numTake]; filtS=S[:numTake]; filtVh=Vh[:numTake, :] else: if threshold>1e-13: threshold=threshold/2 warnings.warn('cutting threshold for eigenvalues to '+str(threshold)) else: warnings('seems all eigenvalues are zero (<1e-13), setting to zero and breaking') filtS=np.zeros_like(S) truncVander=np.dot(filtU,np.dot(np.diag(filtS),filtVh)) ret, _, _, _=npl.lstsq(truncVander, functionVals, rcond=None) return np.reshape(ret, np.array(orders).flatten()+1)
def A(n): return legvander2d(x,th,[n,n])/(0.0573/164.102)
def vandermonde(self, points): """""" vander = legvander2d(points[:, 0], points[:, 1], [self.degree, self.degree]) ulmask = CoeffPolynomial.upper_left_triangular_mask(self.degree) return vander[:, ulmask.ravel()]