def get_projection_transformed_point(src_x_values, src_y_values, dest_width, dest_height, target_point_x, target_point_y): sx1, sy1 = src_x_values[0], src_y_values[0] # tl sx2, sy2 = src_x_values[1], src_y_values[1] # bl sx3, sy3 = src_x_values[2], src_y_values[2] # br sx4, sy4 = src_x_values[3], src_y_values[3] # tr source_points_123 = pl.matrix([[sx1, sx2, sx3], [sy1, sy2, sy3], [1, 1, 1]]) source_point_4 = [[sx4], [sy4], [1]] scale_to_source = pl.solve(source_points_123, source_point_4) l, m, t = [float(x) for x in scale_to_source] unit_to_source = pl.matrix([[l * sx1, m * sx2, t * sx3], [l * sy1, m * sy2, t * sy3], [l, m, t]]) dx1, dy1 = 0, 0 dx2, dy2 = 0, dest_height dx3, dy3 = dest_width, dest_height dx4, dy4 = dest_width, 0 dest_points_123 = pl.matrix([[dx1, dx2, dx3], [dy1, dy2, dy3], [1, 1, 1]]) dest_point_4 = pl.matrix([[dx4], [dy4], [1]]) scale_to_dest = pl.solve(dest_points_123, dest_point_4) l, m, t = [float(x) for x in scale_to_dest] unit_to_dest = pl.matrix([[l * dx1, m * dx2, t * dx3], [l * dy1, m * dy2, t * dy3], [l, m, t]]) source_to_unit = pl.inv(unit_to_source) source_to_dest = unit_to_dest @ source_to_unit x, y, z = [float(w) for w in (source_to_dest @ pl.matrix([ [target_point_x], [target_point_y], [1]]))] x /= z y /= z y = target_point_y * 2 - y return x, y
def calcvrt0(M, Mvv, Mrv, Mvr, Mtv, Mvt, fvn, frn, ftn): lu = splu(Mvv) #Mhatrr and Mhattr b = lu.solve(Mvr) Mhatrr = -Mrv * b _addToDiagonal(Mhatrr, M.lx) Mhattr = -Mtv * b #Mhatrt and Mhattt b = lu.solve(Mvt) Mhatrt = -Mrv * b Mhattt = -Mtv * b _addToDiagonal(Mhattt, M.lx) #fhatrn b = lu.solve(fvn) a = Mrv * b fhatrn = frn - a #fhattn b = lu.solve(fvn) a = Mtv * b fhattn = ftn - a MAT = pl.bmat([[Mhatrr, Mhatrt], [Mhattr, Mhattt]]) RHS = pl.bmat([[fhatrn], [fhattn]]) V = pl.solve(MAT, RHS) r = V[:M.NM, 0] t = V[M.NM:, 0] sol = lu.solve(fvn - Mvr * r - Mvt * t) return sol, r, t
def calcScatteringMatrix(M,P,x): ## FE analysis to acquire scattering matrices (see Dossou2006) instead of solving for one incident ## condition as done in FE(). # #@param M Model object containing geometrical information #@param P Physics object containing physical parameters #@param x The design domain with 0 corresponding to eps1 and 1 corresponding to eps2 # and intermediate values to weighted averages in between. See physics.interpolate #@return Dictionary containing the matrices R,T,R',T' that the scattering matrix consists of. # as well as normal data # #see also FE() A,B = P.interpolate(x) Mvv = assembleMvv(A,B,M,P) Mrv,Mvr,Mtv,Mvt,fvn,frn = assembleMxxfx(M,P) lu = splu(Mvv) #Mhatrr and Mhattr b = lu.solve(Mvr) Mhatrr = -Mrv*b _addToDiagonal(Mhatrr, M.lx) Mhattr = -Mtv*b #Mhatrt and Mhattt b = lu.solve(Mvt) Mhatrt = -Mrv*b Mhattt = -Mtv*b _addToDiagonal(Mhattt, M.lx) #fhatrn b = lu.solve(fvn) a = Mrv*b fhatrn = frn-a #fhattn b = lu.solve(fvn) a = Mtv*b fhattn = -a MAT = pl.bmat([[Mhatrr, Mhatrt], [Mhattr, Mhattt]]) RHS = pl.bmat([[ Mhatrr-2*M.lx*pl.identity(M.NM), Mhatrt], [Mhattr, Mhattt-2*M.lx*pl.identity(M.NM)]]) #Solve Eq (53) in Dossou 2006 RTtilde = pl.solve(MAT,RHS) RIn = RTtilde[:M.NM,:M.NM] TIn = RTtilde[M.NM:,:M.NM] ROut = RTtilde[M.NM:,M.NM:] TOut = RTtilde[:M.NM,M.NM:] results = {} results["RIn"] = RIn results["TIn"] = TIn results["ROut"] = ROut results["TOut"] = TOut results.update(M.getParameters()) results.update(P.getParameters()) return results
def f_Gamma(c): # Once the optimal c is found, find the ellipsoid shape matrix # Variable Gamma_plus (for \Gamma_{i+1}) Gamma_plus = variable(2,2,name='Gamma_plus') # Constraints c0 = belongs(Gamma_plus, semidefinite_cone) c1 = belongs(Gamma - Gamma_plus, semidefinite_cone) c2 = belongs(2*c*Gamma_plus - Gamma_plus*J - J.T*Gamma_plus, semidefinite_cone) # Objective function obj = -exp(-2*c*dT)*det_rootn(Gamma_plus) # Find solution p = program(minimize(obj), [c0, c1, c2]) p.solve(quiet = True) return Gamma_plus.value
def sigmaAt(self, X, noises): numTestLabels = X.shape[1] numTrainlabels = self.trainData.shape[1] sigmas = zeros(numTestLabels) for i in range(numTestLabels): c = self._kernel(X[:, i], X[:, i], self._theta) + noises[i] k = self._k(X[:, i]) sigmas[i] = c - k.dot(solve(self.K, k)) return sqrt(sigmas)
def predictAt(self, X, **kwargs): numTestLabels = X.shape[1] numTrainlabels = self.trainData.shape[1] t = zeros(numTestLabels) bias = kwargs.get('bias', 0) for i in range(numTestLabels): k = self._k(X[:, i]) t[i] = k.dot(solve(self.K, self.trainLabels - bias)) + bias return t
def smooth(y,smoothBeta=smoothBeta): m = len(y) p = pl.diff(pl.eye(m),3).transpose() A = pl.eye(m)+smoothBeta*pl.dot(p.transpose(),p) smoothY = pl.solve(A, y) return smoothY
def predictAt (self, X, **kwargs): numTestLabels = X.shape[1] numTrainlabels = self.trainData.shape[1] t = zeros (numTestLabels) bias = kwargs.get ('bias', 0) for i in range (numTestLabels): k = self._k (X[:,i]) t[i] = k.dot (solve (self.K, self.trainLabels - bias)) + bias return t
def sigmaAt (self, X, noises): numTestLabels = X.shape[1] numTrainlabels = self.trainData.shape[1] sigmas = zeros (numTestLabels) for i in range (numTestLabels): c = self._kernel (X[:,i], X[:,i], self._theta) + noises[i] k = self._k (X[:,i]) sigmas[i] = c - k.dot (solve (self.K, k)) return sqrt (sigmas)
def FE(nelx,nely,x,penal,problem): KE = lk() K = py.zeros((2*(nelx+1)*(nely+1), 2*(nelx+1)*(nely+1))) #K = lil_matrix((2*(nelx+1)*(nely+1), 2*(nelx+1)*(nely+1))) #F = lil_matrix((2*(nely+1)*(nelx+1),1)) F = py.zeros((2*(nely+1)*(nelx+1),1)) U = py.zeros((2*(nely+1)*(nelx+1),1)) #U = lil_matrix((2*(nely+1)*(nelx+1),1)) #print 'K', K, 'F', F, 'U', U for elx in range(nelx): for ely in range(nely): n1 = (nely+1)*elx+ely n2 = (nely+1)* (elx+1)+ely #print 'n', n1, n2 edof = [2*n1,2*n1+1, 2*n2,2*n2+1, 2*n2+2,2*n2+3, 2*n1+2,2*n1+3] #print 'edof', edof E =x[ely,elx]**penal #print E*KE, K+.01 for i in range(8): for j in range(8): #print edof[i],edof[j] K[edof[i],edof[j]]=K[edof[i],edof[j]]+E*KE[i,j] #K[edof,:][:,edof] = K[edof,:][:,edof] + E*KE #print 'KXX',K[edof,:][:,edof] #py.transpose(K) #print 'Final', K ''' DEFINE LOADS AND SUPPORTS Left fixed, right tip load''' if (problem == 1): forcedDof = [2*(nelx+1)*(nely+1)-nely-1] # y force fixeddofs = py.arange(2*(nely+1))# left edge #print forcedDof, fixeddofs elif (problem == 2): forcedDof = 2*(nelx+1)*(nely+1) -1 fixeddofs = py.arange(2*(nely+1)) elif (problem == 3): forcedDof = py.array([2*(nelx+1)*(nely+1)-nely-1, 5*20*2+20-1]) # y force fixeddofs = py.arange(2*(nely+1)) # left edge F[forcedDof,0] = -1.0 alldofs = py.arange(2*(nely+1)*(nelx+1)) freedofs = list(set(alldofs) - set(fixeddofs)) #K = K.todense #print K[freedofs,:][:,freedofs] #print F[freedofs,:] U[freedofs,:] = py.solve(K[freedofs,:][:,freedofs], F[freedofs,:]); U[fixeddofs,:]= 0; #input('abc') #print 'U',py.shape(U), U return U
def sdp(c): # For fixed c solve the semidefinite program for Algorithm 4 # Variable Gamma_plus (for \Gamma_{i+1}) Gamma_plus = variable(2,2,name='Gamma_plus') # Constraints c0 = belongs(Gamma_plus, semidefinite_cone) c1 = belongs(Gamma - Gamma_plus, semidefinite_cone) c2 = belongs(2*c*Gamma_plus - Gamma_plus*J - J.T*Gamma_plus, semidefinite_cone) # Objective function obj = -exp(-2*c*dT)*det_rootn(Gamma_plus) # Find solution p = program(minimize(obj), [c0, c1, c2]) return p.solve(quiet = True)
def sdp(c): # For fixed c solve the semidefinite program for Algorithm 4 # Variable Gamma_plus (for \Gamma_{i+1}) d_plus = variable(2*n, 1, name='d_plus') # Constraints constr = [] for j in range(2*n): ctt = less_equals(d_plus[j,0], 0) constr.append( less_equals(-d_plus[j,0], 0)) constr.append( less_equals( d_plus[j,0], d[j,0])) constr.append( less_equals( J[j,j]*d_plus[j,0] + sum([abs(J[i,j])*d_plus[i,0] for i in range(2*n)]) - abs(J[j,j])*d_plus[j,0], c* d_plus[j,0])) # Objective function obj = geo_mean(d_plus) # Find solution p = program(maximize(obj), constr) return exp(c*dT)/p.solve(quiet = False)
def solve(A, B): return pl.solve(A, B)
def pseudoSpect(A, npts=200, s=2., gridPointSelect=100, verbose=True, lstSqSolve=True): """ original code from http://www.cs.ox.ac.uk/projects/pseudospectra/psa.m % psa.m - Simple code for 2-norm pseudospectra of given matrix A. % Typically about N/4 times faster than the obvious SVD method. % Comes with no guarantees! - L. N. Trefethen, March 1999. parameter: A: the matrix to analyze npts: number of points at the grid s: axis limits (-s ... +s) gridPointSelect: ??? verbose: prints progress messages lstSqSolve: if true, use least squares in algorithm where solve could be used (probably) instead. (replacement for ldivide in MatLab) """ from scipy.linalg import schur, triu from pylab import (meshgrid, norm, dot, zeros, eye, diag, find, linspace, arange, isreal, inf, ones, lstsq, solve, sqrt, randn, eig, all) ldiv = lambda M1,M2 :lstsq(M1,M2)[0] if lstSqSolve else lambda M1,M2: solve(M1,M2) def planerot(x): ''' return (G,y) with a matrix G such that y = G*x with y[1] = 0 ''' G = zeros((2,2)) xn = x / norm(x) G[0,0] = xn[0] G[1,0] = -xn[1] G[0,1] = xn[1] G[1,1] = xn[0] return G, dot(G,x) xmin = -s xmax = s ymin = -s ymax = s; x = linspace(xmin,xmax,npts,endpoint=False) y = linspace(ymin,ymax,npts,endpoint=False) xx,yy = meshgrid(x,y) zz = xx + 1j*yy #% Compute Schur form and plot eigenvalues: T,Z = schur(A,output='complex'); T = triu(T) eigA = diag(T) # Reorder Schur decomposition and compress to interesting subspace: select = find( eigA.real > -250) # % <- ALTER SUBSPACE SELECTION n = len(select) for i in arange(n): for k in arange(select[i]-1,i,-1): #:-1:i G = planerot([T[k,k+1],T[k,k]-T[k+1,k+1]] )[0].T[::-1,::-1] J = slice(k,k+2) T[:,J] = dot(T[:,J],G) T[J,:] = dot(G.T,T[J,:]) T = triu(T[:n,:n]) I = eye(n); # Compute resolvent norms by inverse Lanczos iteration and plot contours: sigmin = inf*ones((len(y),len(x))); #A = eye(5) niter = 0 for i in arange(len(y)): # 1:length(y) if all(isreal(A)) and (ymax == -ymin) and (i > len(y)/2): sigmin[i,:] = sigmin[len(y) - i,:] else: for jj in arange(len(x)): z = zz[i,jj] T1 = z * I - T T2 = T1.conj().T if z.real < gridPointSelect: # <- ALTER GRID POINT SELECTION sigold = 0 qold = zeros((n,1)) beta = 0 H = zeros((100,100)) q = randn(n,1) + 1j*randn(n,1) while norm(q) < 1e-8: q = randn(n,1) + 1j*randn(n,1) q = q/norm(q) for k in arange(99): v = ldiv(T1,(ldiv(T2,q))) - dot(beta,qold) #stop alpha = dot(q.conj().T, v).real v = v - alpha*q beta = norm(v) qold = q q = v/beta H[k+1,k] = beta H[k,k+1] = beta H[k,k] = alpha if (alpha > 1e100): sig = alpha else: sig = max(abs(eig(H[:k+1,:k+1])[0])) if (abs(sigold/sig-1) < .001) or (sig < 3 and k > 2): break sigold = sig niter += 1 #print 'niter = ', niter #%text(x(jj),y(i),num2str(k)) % <- SHOW ITERATION COUNTS sigmin[i,jj] = 1./sqrt(sig); #end # end if verbose: print 'finished line ', str(i), ' out of ', str(len(y)) return x,y,sigmin
def single_shooting(model, initial_u=0.4, plot=True): """Run single shooting of model model with a constant u. The function returns the optimal u. Notes: * Currently written specifically for VDP. * Currently only supports one input/control signal. Parameters: model -- the model which is to be simulated. Only models with one control signal is supported. Keyword parameters: initial_u -- the initial input U_0 used to initialize the optimization with. """ assert len(model.u) == 1, "More than one control signal is " \ "not supported as of today." start_time = model.opt_interval_get_start_time() end_time = model.opt_interval_get_final_time() u = model.u u0 = N.array([initial_u]) print "Initial u:", u gradient = None gradient_u = None def f(cur_u): """The cost evaluation function.""" model.reset() u[:] = cur_u print "u is", u big_gradient, last_y, gradparams, sens = _shoot( model, start_time, end_time) model.set_x_p(last_y, 0) model.set_dx_p(model.dx, 0) model.set_u_p(model.u, 0) cost = model.opt_eval_J() gradient_u = cur_u.copy() gradient = big_gradient[gradparams['u_start']:gradparams['u_end']] print "Cost:", cost print "Grad:", gradient return cost def df(cur_u): """The gradient of the cost function. NOT USED right now. """ model.reset() u[:] = cur_u print "u is", u big_gradient, last_y, gradparams, sens = _shoot( model, start_time, end_time) model.set_x_p(last_y, 0) model.set_dx_p(model.dx, 0) model.set_u_p(model.u, 0) cost = model.opt_eval_J() gradient_u = cur_u.copy() gradient = big_gradient[gradparams['u_start']:gradparams['u_end']] print "Cost:", cost print "Grad:", gradient return gradient p = NLP(f, u0, maxIter=1e3, maxFunEvals=1e2) p.df = df if plot: p.plot = 1 else: p.plot = 0 p.iprint = 1 u_opt = p.solve('scipy_slsqp') return u_opt
def run_optimization(self, plot=True, _only_check_gradients=False): """Start/run optimization procedure and the optimum unless. Set the keyword parameter 'plot' to False (default=True) if plotting should not be conducted. """ grid = self.get_grid() model = self.get_model() # Initial try p0 = self.get_p0() # Less than (-0.5 < u < 1) # TODO: These are currently hard coded. They shouldn't be. #NLT = len(grid) * len(model.u) #Alt = N.zeros( (NLT, len(p0)) ) #Alt[:, (len(grid) - 1) * len(model.x):] = -N.eye(len(grid) * # len(model.u)) #blt = -0.5*N.ones(NLT) # TODO: These are currently hard coded. They shouldn't be. #N_xvars = (len(grid) - 1) * len(model.x) #N_uvars = len(grid) * len(model.u) #N_vars = N_xvars + N_uvars #Alt = -N.eye(N_vars) #blt = N.zeros(N_vars) #blt[0:N_xvars] = -N.ones(N_xvars)*0.001 #blt[N_xvars:] = -N.ones(N_uvars)*1; # Get OpenOPT handler p = NLP( self.f, p0, maxIter=1e3, maxFunEvals=1e3, #A=Alt, # See TODO above #b=blt, # See TODO above df=self.df, ftol=1e-4, xtol=1e-4, contol=1e-4) if len(grid) > 1: p.h = self.h p.dh = self.dh if plot: p.plot = 1 p.iprint = 1 if _only_check_gradients: # Check gradients against finite difference quotients p.checkdf(maxViolation=0.05) p.checkdh() return None #opt = p.solve('ralg') # does not work - serious convergence issues opt = p.solve('scipy_slsqp') if plot: plot_control_solutions(model, grid, opt.xf) return opt
print ('Informe y[%i]: '%i) y0.append(float(input())) for i in range(n): aux=[] for j in range(n): if j==0: aux.append(x0[i]) if j==1: aux.append(1) A.append(aux) print(A) for i in range(n): aux=[] aux.append(y0[i]) B.append(aux) A = py.array(A) b = py.array(B) z = py.solve(A, b) print(z) x1= float(input('Informe um valor para interpolar: ')) for i in z: y=x1*z[0]+z[1] print(y)
def pseudoSpect(A, npts=200, s=2., gridPointSelect=100, verbose=True, lstSqSolve=True): """ original code from http://www.cs.ox.ac.uk/projects/pseudospectra/psa.m % psa.m - Simple code for 2-norm pseudospectra of given matrix A. % Typically about N/4 times faster than the obvious SVD method. % Comes with no guarantees! - L. N. Trefethen, March 1999. parameter: A: the matrix to analyze npts: number of points at the grid s: axis limits (-s ... +s) gridPointSelect: ??? verbose: prints progress messages lstSqSolve: if true, use least squares in algorithm where solve could be used (probably) instead. (replacement for ldivide in MatLab) """ from scipy.linalg import schur, triu from pylab import (meshgrid, norm, dot, zeros, eye, diag, find, linspace, arange, isreal, inf, ones, lstsq, solve, sqrt, randn, eig, all) ldiv = lambda M1, M2: lstsq(M1, M2)[ 0] if lstSqSolve else lambda M1, M2: solve(M1, M2) def planerot(x): ''' return (G,y) with a matrix G such that y = G*x with y[1] = 0 ''' G = zeros((2, 2)) xn = x / norm(x) G[0, 0] = xn[0] G[1, 0] = -xn[1] G[0, 1] = xn[1] G[1, 1] = xn[0] return G, dot(G, x) xmin = -s xmax = s ymin = -s ymax = s x = linspace(xmin, xmax, npts, endpoint=False) y = linspace(ymin, ymax, npts, endpoint=False) xx, yy = meshgrid(x, y) zz = xx + 1j * yy #% Compute Schur form and plot eigenvalues: T, Z = schur(A, output='complex') T = triu(T) eigA = diag(T) # Reorder Schur decomposition and compress to interesting subspace: select = find(eigA.real > -250) # % <- ALTER SUBSPACE SELECTION n = len(select) for i in arange(n): for k in arange(select[i] - 1, i, -1): #:-1:i G = planerot([T[k, k + 1], T[k, k] - T[k + 1, k + 1]])[0].T[::-1, ::-1] J = slice(k, k + 2) T[:, J] = dot(T[:, J], G) T[J, :] = dot(G.T, T[J, :]) T = triu(T[:n, :n]) I = eye(n) # Compute resolvent norms by inverse Lanczos iteration and plot contours: sigmin = inf * ones((len(y), len(x))) #A = eye(5) niter = 0 for i in arange(len(y)): # 1:length(y) if all(isreal(A)) and (ymax == -ymin) and (i > len(y) / 2): sigmin[i, :] = sigmin[len(y) - i, :] else: for jj in arange(len(x)): z = zz[i, jj] T1 = z * I - T T2 = T1.conj().T if z.real < gridPointSelect: # <- ALTER GRID POINT SELECTION sigold = 0 qold = zeros((n, 1)) beta = 0 H = zeros((100, 100)) q = randn(n, 1) + 1j * randn(n, 1) while norm(q) < 1e-8: q = randn(n, 1) + 1j * randn(n, 1) q = q / norm(q) for k in arange(99): v = ldiv(T1, (ldiv(T2, q))) - dot(beta, qold) #stop alpha = dot(q.conj().T, v).real v = v - alpha * q beta = norm(v) qold = q q = v / beta H[k + 1, k] = beta H[k, k + 1] = beta H[k, k] = alpha if (alpha > 1e100): sig = alpha else: sig = max(abs(eig(H[:k + 1, :k + 1])[0])) if (abs(sigold / sig - 1) < .001) or (sig < 3 and k > 2): break sigold = sig niter += 1 #print 'niter = ', niter #%text(x(jj),y(i),num2str(k)) % <- SHOW ITERATION COUNTS sigmin[i, jj] = 1. / sqrt(sig) #end # end if verbose: print 'finished line ', str(i), ' out of ', str(len(y)) return x, y, sigmin
def FE(M,P,x,printResults=True): ## FE analysis to solve Maxwell's equations in 2D for either H or E polarisation (=Helmholtz's equation) ## using periodic boundary conditions and wave expansions at the boundaries. The approach was originally ## implemented using Fuchi2010 and later modifications from Dossou2006 (original article) were added # #@param M Model object containing geometrical information #@param P Physics object containing physical parameters #@param x The design domain with 0 corresponding to eps1 and 1 corresponding to eps2 # and intermediate values to weighted averages in between. See physics.interpolate #@param printResults print results to stdout after simulation #@return sol is the discretised solution, r are the complex reflection coefficients # and t are the complex transmission coefficients #Calculate A and B, as the would be given in the Helmholtz equation in Eq (1) in Friis2012. # (this notation makes it easy to switch between E and H field due to duality) A,B = P.interpolate(x) Mvv = assembleMvv(A,B,M,P) Mrv,Mvr,Mtv,Mvt,fvn,frn = assembleMxxfx(M,P) frn[M.Nm,0] = -M.lx #mode 0 lu = splu(Mvv) #Mhatrr and Mhattr b = lu.solve(Mvr) Mhatrr = -Mrv*b _addToDiagonal(Mhatrr, M.lx) Mhattr = -Mtv*b #Mhatrt and Mhattt b = lu.solve(Mvt) Mhatrt = -Mrv*b Mhattt = -Mtv*b _addToDiagonal(Mhattt, M.lx) #fhatrn b = lu.solve(fvn) a = Mrv*b fhatrn = frn-a #fhattn b = lu.solve(fvn) a = Mtv*b fhattn = -a MAT = pl.bmat([[Mhatrr, Mhatrt], [Mhattr, Mhattt]]) RHS = pl.bmat([ [fhatrn],[fhattn]]) V = pl.solve(MAT,RHS) r = V[:M.NM,0] t = V[M.NM:,0] #Solve the system using LU factorisation (as recommended in Dossou2006, p 130, bottom) sol = lu.solve(fvn-Mvr*r-Mvt*t) print(pl.shape(r)) print(pl.shape(t)) print(pl.shape(sol)) r = r.view(pl.ndarray).ravel() t = t.view(pl.ndarray).ravel() #Cast solution into a form that matches the input model sol = sol.reshape(M.nelx+1,M.nelz+1,order='F') #Print simulation results if printResults: _printResultsToScreen(M,P,r,t) print("r") print(r) print(t) print(sol) results = {} results["solution"] = sol results["x"] = x results["r"] = r results["t"] = t results.update(M.getParameters()) results.update(P.getParameters()) return results