def __init__(self, model, **kwargs):
AmplModel.__init__(self, model, **kwargs)
# 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
def obj(self, x):
"""
Return the value of the objective function at `x`. This function is
specialized since the original objective function only depends on a
subvector of `x`.
"""
return AmplModel.obj(self, x[:self.original_n])
def obj(self, x):
"""
Return the value of the objective function at `x`. This function is
specialized since the original objective function only depends on a
subvector of `x`.
"""
return AmplModel.obj(self, x[:self.original_n])
def __init__(self, model, **kwargs):
AmplModel.__init__(self, model, **kwargs)
# 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
try:
options, fname = getopt.getopt(arglist, '')
except getopt.error, e:
commandline_err("%s" % str(e))
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a NLPy AmplModel
print 'Problem', ProblemName
nlp = AmplModel(ProblemName) #amplpy.AmplModel( ProblemName )
# Translate this NLPy - Ampl problem in a pyOpt problem
nlp.Uvar = numpy.inf * numpy.ones(9)
opt_prob = PyOpt_From_NLPModel(nlp)
print opt_prob
# Call the imported solver SNOPT
snopt = SNOPT()
# Choose sensitivity type for computing gradients with :
# 'FD' : finite difference
# opt_prob.grad_func : NLPy
#
try:
options, fname = getopt.getopt(arglist, '')
except getopt.error, e:
commandline_err("%s" % str(e))
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a model
print 'Problem', ProblemName
nlp = AmplModel(ProblemName) #amplpy.AmplModel( ProblemName )
# Query the model
x0 = nlp.x0
pi0 = nlp.pi0
n = nlp.n
m = nlp.m
print 'There are %d variables and %d constraints' % (n, m)
max_n = min(n, 5)
max_m = min(m, 5)
print
print ' Printing at most 5 first components of vectors'
print
if __name__ == '__main__':
from nlpy.model import AmplModel
from nlpy.krylov.linop import PysparseLinearOperator
from nlpy.optimize.tr.trustregion import TrustRegionFramework, TrustRegionCG
from nlpy.tools.dercheck import DerivativeChecker
# Set printing standards for arrays.
np.set_printoptions(precision=3, linewidth=80, threshold=10, edgeitems=3)
prob = sys.argv[1]
# Initialize problem.
nlp = AmplModel(prob)
pdmerit = _meritfunction(nlp)
(nx, nz) = (pdmerit.nlp.n, pdmerit.nz)
# Initialize trust region framework.
TR = TrustRegionFramework(Delta=1.0,
eta1=0.0001,
eta2=0.95,
gamma1=1.0 / 3,
gamma2=2.5)
# Set up interior-point framework.
TRIP = PrimalDualInteriorPointFramework(
pdmerit,
TR,
TrustRegionCG,
error = False
if multiple_problems:
# Define formats for output table.
hdrfmt = '%-10s %5s %5s %15s %7s %7s %6s %6s %5s'
hdr = hdrfmt % ('Name','Iter','Feval','Objective','dResid','pResid',
'Setup','Solve','Opt')
lhdr = len(hdr)
fmt = '%-10s %5d %5d %15.8e %7.1e %7.1e %6.2f %6.2f %5s'
log.info(hdr)
log.info('-' * lhdr)
# Solve each problem in turn.
for ProblemName in args:
nlp = AmplModel(ProblemName)
# Check for equality-constrained problem.
n_ineq = nlp.nlowerC + nlp.nupperC + nlp.nrangeC
if nlp.nbounds > 0 or n_ineq > 0:
msg = '%s has %d bounds and %d inequality constraints\n'
log.error(msg % (nlp.name, nlp.nbounds, n_ineq))
error = True
else:
ProblemName = os.path.basename(ProblemName)
if ProblemName[-3:] == '.nl':
ProblemName = ProblemName[:-3]
t_setup, funn = pass_to_funnel(nlp, **opts)
if multiple_problems:
log.info(fmt % (ProblemName, funn.niter, funn.nlp.feval, funn.f,
funn.dResid, funn.pResid,
if __name__ == '__main__':
from nlpy.model import AmplModel
from nlpy.krylov.linop import PysparseLinearOperator
from nlpy.optimize.tr.trustregion import TrustRegionFramework, TrustRegionCG
from nlpy.tools.dercheck import DerivativeChecker
# Set printing standards for arrays.
np.set_printoptions(precision=3, linewidth=80, threshold=10, edgeitems=3)
prob = sys.argv[1]
# Initialize problem.
nlp = AmplModel(prob)
pdmerit = _meritfunction(nlp)
(nx, nz) = (pdmerit.nlp.n, pdmerit.nz)
# Initialize trust region framework.
TR = TrustRegionFramework(Delta = 1.0,
eta1 = 0.0001,
eta2 = 0.95,
gamma1 = 1.0/3,
gamma2 = 2.5)
# Set up interior-point framework.
TRIP = PrimalDualInteriorPointFramework(
pdmerit,
TR,
TrustRegionCG,
# 4. Update x using projected linesearch with initial step=1.
(x, qval) = self.projected_linesearch(x, g, d, qval)
g = qp.grad(x)
pg = self.pgrad(x, g=g, active_set=(lower, upper))
pgNorm = np.linalg.norm(pg)
self.exitOptimal = exitOptimal
self.exitIter = exitIter
self.niter = iter
self.x = x
self.qval = qval
self.lower = lower
self.upper = upper
return
if __name__ == '__main__':
import sys
from nlpy.model import AmplModel
qp = AmplModel(sys.argv[1])
bqp = BQP(qp)
bqp.solve(maxiter=50, stoptol=1.0e-8)
print 'optimal = ', repr(bqp.exitOptimal)
print 'niter = ', bqp.niter
print 'solution: ', bqp.x
print 'objective value: ', bqp.qval
print 'vars on lower bnd: ', bqp.lower
print 'vars on upper bnd: ', bqp.upper
commandline_err( 'Specify file name (look in data directory)' )
return None
try: options, fname = getopt.getopt( arglist, '' )
except getopt.error, e:
commandline_err( "%s" % str( e ) )
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a model
print 'Problem', ProblemName
nlp = AmplModel( ProblemName ) #amplpy.AmplModel( ProblemName )
# Query the model
x0 = nlp.x0
pi0 = nlp.pi0
n = nlp.n
m = nlp.m
print 'There are %d variables and %d constraints' % ( n, m )
max_n = min( n, 5 )
max_m = min( m, 5 )
print
print ' Printing at most 5 first components of vectors'
print
return None
try: options, fname = getopt.getopt( arglist, '' )
except getopt.error, e:
commandline_err( "%s" % str( e ) )
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a NLPy AmplModel
print 'Problem', ProblemName
nlp = AmplModel( ProblemName )
# Translate this NLPy - Ampl problem in a pyOpt problem
opt_prob = PyOpt_From_NLPModel(nlp)
print opt_prob
# Call the imported solver IPOPT
ipopt = IPOPT()
# Choose sensitivity type for computing gradients with :
# 'FD' : finite difference
# opt_prob.grad_func : NLPy
#
# As AMPL isn't handling complex values, we cannot use the complex step method
# to estimate the gradients
commandline_err( 'Specify file name (look in data directory)' )
return None
try: options, fname = getopt.getopt( arglist, '' )
except getopt.error, e:
commandline_err( "%s" % str( e ) )
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a model
print 'Problem', ProblemName
nlp = AmplModel( ProblemName ) #amplpy.AmplModel( ProblemName )
# Query the model
x0 = nlp.x0
pi0 = nlp.pi0
n = nlp.n
m = nlp.m
print 'There are %d variables and %d constraints' % ( n, m )
max_n = min( n, 5 )
max_m = min( m, 5 )
print
print ' Printing at most 5 first components of vectors'
print
def _jac(self, x, lp=False):
"""
Helper method to assemble the Jacobian matrix of the constraints of the
transformed problems. See the documentation of :meth:`jac` for more
information.
The positional argument `lp` should be set to `True` only if the problem
is known to be a linear program. In this case, the evaluation of the
constraint matrix is cheaper and the argument `x` is ignored.
"""
n = self.original_n
m = self.original_m
# List() simply allows operations such as 1 + [2,3] -> [3,4]
lowerC = List(self.lowerC) ; nlowerC = self.nlowerC
upperC = List(self.upperC) ; nupperC = self.nupperC
rangeC = List(self.rangeC) ; nrangeC = self.nrangeC
lowerB = List(self.lowerB) ; nlowerB = self.nlowerB
upperB = List(self.upperB) ; nupperB = self.nupperB
rangeB = List(self.rangeB) ; nrangeB = self.nrangeB
nbnds = nlowerB + nupperB + 2*nrangeB
nSlacks = nlowerC + nupperC + 2*nrangeC
# Initialize sparse Jacobian
nnzJ = 2 * self.nnzj + m + nrangeC + nbnds + nrangeB # Overestimate
J = sp(nrow=self.m, ncol=self.n, sizeHint=nnzJ)
# Insert contribution of general constraints
if lp:
J[:m,:n] = AmplModel.A(self)
else:
J[:m,:n] = AmplModel.jac(self,x[:n])
J[upperC,:n] *= -1.0 # Flip sign of 'upper' gradients
J[m:m+nrangeC,:n] = J[rangeC,:n] # Append 'upper' side of range const.
J[m:m+nrangeC,:n] *= -1.0 # Flip sign of 'upper' range gradients.
# Create a few index lists
rlowerC = List(range(nlowerC)) ; rlowerB = List(range(nlowerB))
rupperC = List(range(nupperC)) ; rupperB = List(range(nupperB))
rrangeC = List(range(nrangeC)) ; rrangeB = List(range(nrangeB))
# Insert contribution of slacks on general constraints
J.put(-1.0, lowerC, n + rlowerC)
J.put(-1.0, upperC, n + nlowerC + rupperC)
J.put(-1.0, rangeC, n + nlowerC + nupperC + rrangeC)
J.put(-1.0, m + rrangeC, n + nlowerC + nupperC + nrangeC + rrangeC)
# Insert contribution of bound constraints on the original problem
bot = m+nrangeC ; J.put( 1.0, bot + rlowerB, lowerB)
bot += nlowerB ; J.put( 1.0, bot + rrangeB, rangeB)
bot += nrangeB ; J.put(-1.0, bot + rupperB, upperB)
bot += nupperB ; J.put(-1.0, bot + rrangeB, rangeB)
# Insert contribution of slacks on the bound constraints
bot = m+nrangeC
J.put(-1.0, bot + rlowerB, n + nSlacks + rlowerB)
bot += nlowerB
J.put(-1.0, bot + rrangeB, n + nSlacks + nlowerB + rrangeB)
bot += nrangeB
J.put(-1.0, bot + rupperB, n + nSlacks + nlowerB + nrangeB + rupperB)
bot += nupperB
J.put(-1.0, bot + rrangeB, n+nSlacks+nlowerB+nrangeB+nupperB+rrangeB)
return J
def cons(self, x):
"""
Evaluate the vector of general constraints for the modified problem.
Constraints are stored in the order in which they appear in the
original problem. If constraint i is a range constraint, c[i] will
be the constraint that has the slack on the lower bound on c[i].
The constraint with the slack on the upper bound on c[i] will be stored
in position m + k, where k is the position of index i in
rangeC, i.e., k=0 iff constraint i is the range constraint that
appears first, k=1 iff it appears second, etc.
Constraints appear in the following order:
1. [ c ] general constraints in origninal order
2. [ cR ] 'upper' side of range constraints
3. [ b ] linear constraints corresponding to bounds on original problem
4. [ bR ] linear constraints corresponding to 'upper' side of two-sided
bounds
"""
n = self.n ; on = self.original_n
m = self.m ; om = self.original_m
equalC = self.equalC
lowerC = self.lowerC ; nlowerC = self.nlowerC
upperC = self.upperC ; nupperC = self.nupperC
rangeC = self.rangeC ; nrangeC = self.nrangeC
mslow = on + self.n_con_low
msup = mslow + self.n_con_up
s_low = x[on:mslow] # len(s_low) = n_con_low
s_up = x[mslow:msup] # len(s_up) = n_con_up
c = numpy.empty(m)
c[:om] = AmplModel.cons(self, x[:on])
c[om:om+nrangeC] = c[rangeC]
c[equalC] -= self.Lcon[equalC]
c[lowerC] -= self.Lcon[lowerC] ; c[lowerC] -= s_low[:nlowerC]
c[upperC] -= self.Ucon[upperC] ; c[upperC] *= -1
c[upperC] -= s_up[:nupperC]
c[rangeC] -= self.Lcon[rangeC] ; c[rangeC] -= s_low[nlowerC:]
c[om:om+nrangeC] -= self.Ucon[rangeC]
c[om:om+nrangeC] *= -1
c[om:om+nrangeC] -= s_up[nupperC:]
# Add linear constraints corresponding to bounds on original problem
lowerB = self.lowerB ; nlowerB = self.nlowerB ; Lvar = self.Lvar
upperB = self.upperB ; nupperB = self.nupperB ; Uvar = self.Uvar
rangeB = self.rangeB ; nrangeB = self.nrangeB
nt = on + self.n_con_low + self.n_con_up
ntlow = nt + self.n_var_low
t_low = x[nt:ntlow]
t_up = x[ntlow:]
b = c[om+nrangeC:]
b[:nlowerB] = x[lowerB] - Lvar[lowerB] - t_low[:nlowerB]
b[nlowerB:nlowerB+nrangeB] = x[rangeB] - Lvar[rangeB] - t_low[nlowerB:]
b[nlowerB+nrangeB:nlowerB+nrangeB+nupperB] = Uvar[upperB] - x[upperB] - t_up[:nupperB]
b[nlowerB+nrangeB+nupperB:] = Uvar[rangeB] - x[rangeB] - t_up[nupperB:]
return c
multiple_problems = len(args) > 1
if multiple_problems:
# Define formats for output table.
hdrfmt = '%-15s %5s %5s %15s %7s %7s %7s %5s %6s %6s %5s'
hdr = hdrfmt % ('Name', 'Iter', 'Feval', 'Objective', 'dResid', 'pResid',
'Comp', 'LogPen', 'Setup', 'Solve', 'Opt')
lhdr = len(hdr)
fmt = '%-15s %5d %5d %15.8e %7.1e %7.1e %7.1e %5.1f %6.2f %6.2f %5s'
log.info(hdr)
log.info('-' * lhdr)
for problemName in args:
nlp = AmplModel(problemName)
problemName = os.path.splitext(os.path.basename(problemName))[0]
# Create solution logger (if requested).
if options.solution_requested:
solution_logger = config_logger('elastic.solution',
filename=problemName + '.sol',
filemode='w',
stream=None)
t_setup, eif = pass_to_elastic(nlp, **opts)
l1 = eif.l1bar.l1
max_penalty = max(l1.get_penalty_parameters())
if not multiple_problems: # Output final statistics
print
return None
try: options, fname = getopt.getopt( arglist, '' )
except getopt.error, e:
commandline_err( "%s" % str( e ) )
return None
return fname[0]
ProblemName = parse_cmdline(sys.argv[1:])
# Create a NLPy AmplModel
print 'Problem', ProblemName
nlp = AmplModel( ProblemName ) #amplpy.AmplModel( ProblemName )
# Translate this NLPy - Ampl problem in a pyOpt problem
nlp.Uvar = numpy.inf * numpy.ones(9)
opt_prob = PyOpt_From_NLPModel(nlp)
print opt_prob
# Call the imported solver SNOPT
snopt = SNOPT()
# Choose sensitivity type for computing gradients with :
# 'FD' : finite difference
"""
Return the square root of a linear operator, if defined. Note that
this is not the elementwise square root. The result is a linear operator
that, when composed with itself, yields the original operator.
"""
return op._sqrt()
if __name__ == '__main__':
from pykrylov.tools import check_symmetric
from pysparse.sparse.pysparseMatrix import PysparseMatrix as sp
from nlpy.model import AmplModel
import sys
np.set_printoptions(precision=3, linewidth=80, threshold=10, edgeitems=3)
nlp = AmplModel(sys.argv[1])
J = sp(matrix=nlp.jac(nlp.x0))
e1 = np.ones(J.shape[0])
e2 = np.ones(J.shape[1])
print 'J.shape = ', J.getShape()
print 'Testing PysparseLinearOperator:'
op = PysparseLinearOperator(J)
print 'op.shape = ', op.shape
print 'op.T.shape = ', op.T.shape
print 'op * e2 = ', op * e2
print "op.T * e1 = ", op.T * e1
print 'op.T.T * e2 = ', op.T.T * e2
print 'op.T.T.T * e1 = ', op.T.T.T * e1
print 'With call:'
print 'op(e2) = ', op(e2)
def cons(self, x):
"""
Evaluate the vector of general constraints for the modified problem.
Constraints are stored in the order in which they appear in the
original problem. If constraint i is a range constraint, c[i] will
be the constraint that has the slack on the lower bound on c[i].
The constraint with the slack on the upper bound on c[i] will be stored
in position m + k, where k is the position of index i in
rangeC, i.e., k=0 iff constraint i is the range constraint that
appears first, k=1 iff it appears second, etc.
Constraints appear in the following order:
1. [ c ] general constraints in origninal order
2. [ cR ] 'upper' side of range constraints
3. [ b ] linear constraints corresponding to bounds on original problem
4. [ bR ] linear constraints corresponding to 'upper' side of two-sided
bounds
"""
n = self.n
on = self.original_n
m = self.m
om = self.original_m
equalC = self.equalC
lowerC = self.lowerC
nlowerC = self.nlowerC
upperC = self.upperC
nupperC = self.nupperC
rangeC = self.rangeC
nrangeC = self.nrangeC
mslow = on + self.n_con_low
msup = mslow + self.n_con_up
s_low = x[on:mslow] # len(s_low) = n_con_low
s_up = x[mslow:msup] # len(s_up) = n_con_up
c = numpy.empty(m)
c[:om] = AmplModel.cons(self, x[:on])
c[om:om + nrangeC] = c[rangeC]
c[equalC] -= self.Lcon[equalC]
c[lowerC] -= self.Lcon[lowerC]
c[lowerC] -= s_low[:nlowerC]
c[upperC] -= self.Ucon[upperC]
c[upperC] *= -1
c[upperC] -= s_up[:nupperC]
c[rangeC] -= self.Lcon[rangeC]
c[rangeC] -= s_low[nlowerC:]
c[om:om + nrangeC] -= self.Ucon[rangeC]
c[om:om + nrangeC] *= -1
c[om:om + nrangeC] -= s_up[nupperC:]
# Add linear constraints corresponding to bounds on original problem
lowerB = self.lowerB
nlowerB = self.nlowerB
Lvar = self.Lvar
upperB = self.upperB
nupperB = self.nupperB
Uvar = self.Uvar
rangeB = self.rangeB
nrangeB = self.nrangeB
nt = on + self.n_con_low + self.n_con_up
ntlow = nt + self.n_var_low
t_low = x[nt:ntlow]
t_up = x[ntlow:]
b = c[om + nrangeC:]
b[:nlowerB] = x[lowerB] - Lvar[lowerB] - t_low[:nlowerB]
b[nlowerB:nlowerB +
nrangeB] = x[rangeB] - Lvar[rangeB] - t_low[nlowerB:]
b[nlowerB + nrangeB:nlowerB + nrangeB +
nupperB] = Uvar[upperB] - x[upperB] - t_up[:nupperB]
b[nlowerB + nrangeB +
nupperB:] = Uvar[rangeB] - x[rangeB] - t_up[nupperB:]
return c
# Check second partial derivatives in turn.
for i in range(n):
xph = self.x.copy()
xph[i] += h
xmh = self.x.copy()
xmh[i] -= h
dgdx = (nlp.igrad(k, xph) - nlp.igrad(k, xmh)) / (2 * h)
for j in range(i + 1):
dgjdxi = dgdx[j]
err = abs(Hk[i, j] - dgjdxi) / (1 + abs(Hk[i, j]))
line = self.d2fmt % (k + 1, i, j, Hk[i, j], dgjdxi, err)
if verbose:
sys.stderr.write(line)
if err > self.tol:
errs.append(line)
return errs
if __name__ == '__main__':
import sys
from nlpy.model import AmplModel
nlp = AmplModel(sys.argv[1])
print 'Checking at x = ', nlp.x0
derchk = DerivativeChecker(nlp, nlp.x0)
derchk.check(verbose=True)
nlp.close()
def _jac(self, x, lp=False):
"""
Helper method to assemble the Jacobian matrix of the constraints of the
transformed problems. See the documentation of :meth:`jac` for more
information.
The positional argument `lp` should be set to `True` only if the problem
is known to be a linear program. In this case, the evaluation of the
constraint matrix is cheaper and the argument `x` is ignored.
"""
n = self.original_n
m = self.original_m
# List() simply allows operations such as 1 + [2,3] -> [3,4]
lowerC = List(self.lowerC)
nlowerC = self.nlowerC
upperC = List(self.upperC)
nupperC = self.nupperC
rangeC = List(self.rangeC)
nrangeC = self.nrangeC
lowerB = List(self.lowerB)
nlowerB = self.nlowerB
upperB = List(self.upperB)
nupperB = self.nupperB
rangeB = List(self.rangeB)
nrangeB = self.nrangeB
nbnds = nlowerB + nupperB + 2 * nrangeB
nSlacks = nlowerC + nupperC + 2 * nrangeC
# Initialize sparse Jacobian
nnzJ = 2 * self.nnzj + m + nrangeC + nbnds + nrangeB # Overestimate
J = sp(nrow=self.m, ncol=self.n, sizeHint=nnzJ)
# Insert contribution of general constraints
if lp:
J[:m, :n] = AmplModel.A(self)
else:
J[:m, :n] = AmplModel.jac(self, x[:n])
J[upperC, :n] *= -1.0 # Flip sign of 'upper' gradients
J[m:m +
nrangeC, :n] = J[rangeC, :n] # Append 'upper' side of range const.
J[m:m + nrangeC, :n] *= -1.0 # Flip sign of 'upper' range gradients.
# Create a few index lists
rlowerC = List(range(nlowerC))
rlowerB = List(range(nlowerB))
rupperC = List(range(nupperC))
rupperB = List(range(nupperB))
rrangeC = List(range(nrangeC))
rrangeB = List(range(nrangeB))
# Insert contribution of slacks on general constraints
J.put(-1.0, lowerC, n + rlowerC)
J.put(-1.0, upperC, n + nlowerC + rupperC)
J.put(-1.0, rangeC, n + nlowerC + nupperC + rrangeC)
J.put(-1.0, m + rrangeC, n + nlowerC + nupperC + nrangeC + rrangeC)
# Insert contribution of bound constraints on the original problem
bot = m + nrangeC
J.put(1.0, bot + rlowerB, lowerB)
bot += nlowerB
J.put(1.0, bot + rrangeB, rangeB)
bot += nrangeB
J.put(-1.0, bot + rupperB, upperB)
bot += nupperB
J.put(-1.0, bot + rrangeB, rangeB)
# Insert contribution of slacks on the bound constraints
bot = m + nrangeC
J.put(-1.0, bot + rlowerB, n + nSlacks + rlowerB)
bot += nlowerB
J.put(-1.0, bot + rrangeB, n + nSlacks + nlowerB + rrangeB)
bot += nrangeB
J.put(-1.0, bot + rupperB, n + nSlacks + nlowerB + nrangeB + rupperB)
bot += nupperB
J.put(-1.0, bot + rrangeB,
n + nSlacks + nlowerB + nrangeB + nupperB + rrangeB)
return J
"Return a linear operator from a Numpy `ndarray`."
return LinearOperator(A.shape[1], A.shape[0],
lambda v: np.dot(A, v),
matvec_transp=lambda u: np.dot(A.T, u),
symmetric=False)
if __name__ == '__main__':
from pykrylov.tools import check_symmetric
from pysparse.sparse.pysparseMatrix import PysparseMatrix as sp
from nlpy.model import AmplModel
import sys
np.set_printoptions(precision=3, linewidth=80, threshold=10, edgeitems=3)
nlp = AmplModel(sys.argv[1])
J = sp(matrix=nlp.jac(nlp.x0))
e1 = np.ones(J.shape[0])
e2 = np.ones(J.shape[1])
print 'J.shape = ', J.getShape()
print 'Testing PysparseLinearOperator:'
op = PysparseLinearOperator(J)
print 'op.shape = ', op.shape
print 'op.T.shape = ', op.T.shape
print 'op * e2 = ', op * e2
print "op.T * e1 = ", op.T * e1
print 'op.T.T * e2 = ', op.T.T * e2
print 'op.T.T.T * e1 = ', op.T.T.T * e1
print 'With call:'
print 'op(e2) = ', op(e2)
try:
from nlpy.model import AmplModel
except:
msg='NLPy is required to run this demo. See http://nlpy.sf.net'
raise RuntimeError, msg
from pyorder.tools import coord2csc
from pyorder.pymc60 import sloan, rcmk
from pyorder.tools.spy import FastSpy
import numpy as np
import matplotlib.pyplot as plt
nlp = AmplModel('truss18bars.nl')
x = np.random.random(nlp.n)
y = np.random.random(nlp.m)
H = nlp.hess(x,y)
(val,irow,jcol) = H.find()
(rowind, colptr, values) = coord2csc(nlp.n, irow, jcol, val) # Convert to CSC
perm1, rinfo1 = rcmk(nlp.n, rowind, colptr) # Reverse Cuthill-McKee
perm2, rinfo2 = sloan(nlp.n, rowind, colptr) # Sloan's method
left = plt.subplot(131)
FastSpy(nlp.n, nlp.n, irow, jcol, sym=True,
ax=left.get_axes(), title='Original')
# Apply permutation 1 and plot reordered matrix
middle = plt.subplot(132)
FastSpy(nlp.n, nlp.n, perm1[irow], perm1[jcol], sym=True,
ax=middle.get_axes(), title='Rev. Cuthill-McKee (semibandwidth=%d)' % rinfo1[2])
