def __init__(self, Q, B, d, c, Lcon, Ucon, Lvar, Uvar, **kwargs): p, n = Q.shape m = B.shape[0] _Lcon = np.concatenate((d, Lcon)) _Ucon = np.concatenate((d, Ucon)) _Lvar = np.empty(n+p) _Lvar[:n] = Lvar _Lvar[n:] = -np.inf _Uvar = np.empty(n+p) _Uvar[:n] = Uvar _Uvar[n:] = np.inf x0 = np.zeros(n+p) NLPModel.__init__(self, n=n+p, m=m+p, Lcon=_Lcon, \ Ucon=_Ucon, Lvar=_Lvar, Uvar=_Uvar, **kwargs) # Initialize the parameters of least squares self.Q = Q self.B = B self.nx = n self.nr = p self.mx = m "Return a contiguous array in memory (C order)." self.d = np.ascontiguousarray(d, dtype=float) self.c = np.ascontiguousarray(c, dtype=float)
def __init__(self, n=0, m=0, name='Generic Matrix-Free', **kwargs): # Standard NLP initialization NLPModel.__init__(self,n=n,m=m,name=name,**kwargs) # Additional elements for this class self.JTprod = 0 # Counter for Jacobian-transpose products
def __init__(self, Q, B, d, c, Lcon, Ucon, Lvar, Uvar, **kwargs): NLPModel.__init__(self, n=Q.shape[1], m=B.shape[0], Lcon=Lcon, \ Ucon=Ucon, Lvar=Lvar, Uvar=Uvar, **kwargs) #Initialize the parameters of least squares self.Q = Q self.B = B "Return a contiguous array in memory (C order)." self.d = np.ascontiguousarray(d, dtype=float) self.c = np.ascontiguousarray(c, dtype=float)
def __init__(self, nlp, **kwargs): self.nlp = nlp # Save number of variables and constraints prior to transformation self.original_n = nlp.n self.original_m = nlp.m # Number of slacks for the constaints nSlacks = nlp.nlowerC + nlp.nupperC + nlp.nrangeC self.nSlacks = nSlacks # Update effective number of variables and constraints n = self.original_n + nSlacks m = self.original_m + nlp.nrangeC Lvar = -np.infty * np.ones(n) Uvar = +np.infty * np.ones(n) # Copy orignal bounds Lvar[:self.original_n] = nlp.Lvar Uvar[:self.original_n] = nlp.Uvar # Add bounds corresponding to lower constraints bot = self.original_n self.sL = range(bot, bot + nlp.nlowerC) Lvar[bot:bot+nlp.nlowerC] = nlp.Lcon[nlp.lowerC] # Add bounds corresponding to upper constraints bot += nlp.nlowerC self.sU = range(bot, bot + nlp.nupperC) Uvar[bot:bot+nlp.nupperC] = nlp.Ucon[nlp.upperC] # Add bounds corresponding to range constraints bot += nlp.nupperC self.sR = range(bot, bot + nlp.nrangeC) Lvar[bot:bot+nlp.nrangeC] = nlp.Lcon[nlp.rangeC] Uvar[bot:bot+nlp.nrangeC] = nlp.Ucon[nlp.rangeC] # No more inequalities. All constraints are now equal to 0 Lcon = Ucon = np.zeros(m) NLPModel.__init__(self, n=n, m=m, name='Slack-'+nlp.name, Lvar=Lvar, \ Uvar=Uvar, Lcon=Lcon, Ucon=Ucon) # Redefine primal and dual initial guesses self.original_x0 = nlp.x0[:] self.x0 = np.zeros(self.n) self.x0[:self.original_n] = self.original_x0[:] self.original_pi0 = nlp.pi0[:] self.pi0 = np.zeros(self.m) self.pi0[:self.original_m] = self.original_pi0[:] return
def __init__(self, model, **kwargs): NLPModel.__init__(self, n=model.n, m=model.m, Lcon=model.Lcon, \ Ucon=model.Ucon, Lvar=model.Lvar, Uvar=model.Uvar, name= model.name, **kwargs) self.model = model # Save number of variables and constraints prior to transformation self.original_n = self.n self.original_m = self.m self.original_nbounds = self.nbounds # Number of slacks for inequality constraints with a lower bound n_con_low = self.nlowerC + self.nrangeC ; self.n_con_low = n_con_low # Number of slacks for inequality constraints with an upper bound n_con_up = self.nupperC + self.nrangeC ; self.n_con_up = n_con_up # Number of slacks for variables with a lower bound n_var_low = self.nlowerB + self.nrangeB ; self.n_var_low = n_var_low # Number of slacks for variables with an upper bound n_var_up = self.nupperB + self.nrangeB ; self.n_var_up = n_var_up # Update effective number of variables and constraints self.n = self.original_n + n_con_low + n_con_up + n_var_low + n_var_up self.m = self.original_m + self.nrangeC + n_var_low + n_var_up # Redefine primal and dual initial guesses self.original_x0 = self.x0[:] self.x0 = numpy.zeros(self.n) self.x0[:self.original_n] = self.original_x0[:] self.original_pi0 = self.pi0[:] self.pi0 = numpy.zeros(self.m) self.pi0[:self.original_m] = self.original_pi0[:] return
# J is square and symmetric for this problem, so ... return jprod(x,w) # end def # ============================================================================= # Main program # ============================================================================= n = 5 x0 = 3*numpy.ones(n,'d') pi0 = numpy.zeros(n,'d') Lvar = 1.e-4*numpy.ones(n,'d') Ucon = numpy.ones(n,'d') testmodel = NLPModel(n=n,m=n,name='Scalable Test 1',x0=x0,Lvar=Lvar,Ucon=Ucon) testmodel.obj = obj testmodel.cons = cons testmodel.grad = grad testmodel.jac = jac testMFmodel = MFModel(n=n,m=n,name='Matrix-Free Scalable Test 1',x0=x0, Lvar=Lvar,Ucon=Ucon) testMFmodel.obj = obj testMFmodel.cons = cons testMFmodel.grad = grad testMFmodel.jprod = jprod testMFmodel.jtprod = jtprod # Test vectors for checking Jacobian vector product vec1 = numpy.ones(n)