def _Prepare(self):
if self._lp_prepared: return
self._lp_prepared = True
MatrixProblem._Prepare(self)
if self.x0 is None: self.x0 = zeros(self.n)
if hasattr(self.f, 'is_oovar'): # hence is oofun or oovar
# freeVars and fixedVars are already rendered to both not-None here (if it's the case)
# but current .D() implementation doesn't allow to use both arguments
# BTW translator ignores fixed vars in derivatives, so passing fixedVars here can be omitted
# but is performed for more safety wrt future changes
_f = self._point2vector(self.f.D(self._x0, fixedVars = self.fixedVars))
self.f, self._f = _f, self.f
self.user.f = (self._f, )
self._init_f_vector = _f # we don't take p.goal into account here
_c = self._f(self._x0) - dot(self.f, self.x0)
self._c = _c
else:
self._init_f_vector = self.f # we don't take p.goal into account here
self._c = 0
self.f = atleast_1d(self.f)
if not hasattr(self, 'n'): self.n = len(self.f)
#print 'lb:', self.lb, 'ub:', self.ub
if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n)
if not hasattr(self, 'ub'): self.ub = inf * ones(self.n)
# if any(isnan(self.lb)):
# if self.lb.size != 1: self.err('NaN in lower bound for a variable from the problem')
# self.lb = -inf * ones(self.n)
# if any(isnan(self.ub)):
# if self.ub.size != 1: self.err('NaN in upper bound for a variable from the problem')
# self.ub = inf * ones(self.n)
if self.goal in ['max', 'maximum']:
self.f = -asfarray(self.f)
def _Prepare(self):
if self._lp_prepared: return
self._lp_prepared = True
MatrixProblem._Prepare(self)
if self.x0 is None: self.x0 = zeros(self.n)
if hasattr(self.f, 'is_oovar'): # hence is oofun or oovar
# freeVars and fixedVars are already rendered to both not-None here (if it's the case)
# but current .D() implementation doesn't allow to use both arguments
# BTW translator ignores fixed vars in derivatives, so passing fixedVars here can be omitted
# but is performed for more safety wrt future changes
_f = self._point2vector(
self.f.D(self._x0, fixedVars=self.fixedVars))
self.f, self._f = _f, self.f
self.user.f = (self._f, )
self._init_f_vector = _f # we don't take p.goal into account here
_c = self._f(self._x0) - dot(self.f, self.x0)
self._c = _c
else:
self._init_f_vector = self.f # we don't take p.goal into account here
self._c = 0
self.f = atleast_1d(self.f)
if not hasattr(self, 'n'): self.n = len(self.f)
#print 'lb:', self.lb, 'ub:', self.ub
if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n)
if not hasattr(self, 'ub'): self.ub = inf * ones(self.n)
# if any(isnan(self.lb)):
# if self.lb.size != 1: self.err('NaN in lower bound for a variable from the problem')
# self.lb = -inf * ones(self.n)
# if any(isnan(self.ub)):
# if self.ub.size != 1: self.err('NaN in upper bound for a variable from the problem')
# self.ub = inf * ones(self.n)
if self.goal in ['max', 'maximum']:
self.f = -asfarray(self.f)
def __init__(self, *args, **kw):
self.goal = 'min'
self.bins = {}
#self.objective = ''
MatrixProblem.__init__(self, *args, **kw)
self.__init_kwargs = kw
self._init = True
def __init__(self, *args, **kwargs):
if len(args) > 2: self.err('incorrect args number for LLAVP constructor, must be 0..2 + (optionaly) some kwargs')
if len(args) > 0: kwargs['C'] = args[0]
if len(args) > 1: kwargs['d'] = args[1]
MatrixProblem.__init__(self)
llavp_init(self, kwargs)
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
self.n = self.C.shape[1]
# if 'damp' not in kwargs.keys(): kwargs['damp'] = None
# if 'X' not in kwargs.keys(): kwargs['X'] = nan*ones(self.n)
if self.x0 is None: self.x0 = zeros(self.n)
def _Prepare(self):
if self._isPrepared: return
self._isPrepared = True
if isinstance(self.d, dict): # FuncDesigner startPoint
self.x0 = self.d
MatrixProblem._Prepare(self)
if self.isFDmodel:
equations = self.C
AsSparse = bool(self.useSparse) if type(self.useSparse) != str else self._useSparse()
C, d = [], []
if len(self._fixedVars) < len(self._freeVars):
Z = dict([(v, zeros_like(self._x0[v]) if v not in self._fixedVars else self._x0[v]) for v in self._x0.keys()])
else:
Z = dict([(v, zeros_like(self._x0[v]) if v in self._freeVars else self._x0[v]) for v in self._x0.keys()])
#Z = self.x0#self._vector2point(zeros(self.n))
for lin_oofun in equations:
if lin_oofun.getOrder(self.freeVars, self.fixedVars) > 1:
raise OpenOptException('SLE constructor requires all equations to be linear')
C.append(self._pointDerivative2array(lin_oofun.D(Z, **self._D_kwargs), useSparse = AsSparse))
d.append(-lin_oofun(Z))
self.d = hstack(d).flatten()
self.C = Vstack(C)
if hasattr(self.C, 'tocsc'): self.C_as_csc = self.C.tocsc()
if isinstance(self.C,ndarray) and self.n > 100 and len(flatnonzero(self.C))/self.C.size < 0.3:
s = "Probably you'd better solve this SLE as sparse"
if not scipyInstalled: s += ' (requires scipy installed)'
self.pWarn(s)
self.x0 = zeros(self.C.shape[1])
def _Prepare(self):
if self._isPrepared: return
self._isPrepared = True
if isinstance(self.d, dict): # FuncDesigner startPoint
self.x0 = self.d
MatrixProblem._Prepare(self)
if self.isFDmodel:
equations = self.C
AsSparse = bool(self.useSparse) if type(self.useSparse) != str else self._useSparse()
C, d = [], []
if len(self._fixedVars) < len(self._freeVars):
Z = dict([(v, zeros_like(self._x0[v]) if v not in self._fixedVars else self._x0[v]) for v in self._x0.keys()])
else:
Z = dict([(v, zeros_like(self._x0[v]) if v in self._freeVars else self._x0[v]) for v in self._x0.keys()])
#Z = self.x0#self._vector2point(zeros(self.n))
for lin_oofun in equations:
if lin_oofun.getOrder(self.freeVars, self.fixedVars) > 1:
raise OpenOptException('SLE constructor requires all equations to be linear')
C.append(self._pointDerivative2array(lin_oofun.D(Z, **self._D_kwargs), useSparse = AsSparse))
d.append(-lin_oofun(Z))
self.d = hstack(d).flatten()
self.C = Vstack(C)
if hasattr(self.C, 'tocsc'): self.C_as_csc = self.C.tocsc()
if isinstance(self.C,ndarray) and self.n > 100 and len(flatnonzero(self.C))/self.C.size < 0.3:
s = "Probably you'd better solve this SLE as sparse"
if not scipyInstalled: s += ' (requires scipy installed)'
self.pWarn(s)
self.x0 = zeros(self.C.shape[1])
def __finalize__(self):
MatrixProblem.__finalize__(self)
if self.goal in ['max', 'maximum']:
self.f = -self.f
for fn in ['fk', ]:#not ff - it's handled in other place in RunProbSolver.py
if hasattr(self, fn):
setattr(self, fn, -getattr(self, fn))
def __init__(self, *args, **kwargs):
self.goal = 'minimum'
MatrixProblem.__init__(self, *args, **kwargs)
if len(args) > 1 and not hasattr(args[0], 'is_oovar'):
self.err(
'No more than 1 argument is allowed for classic style LP constructor'
)
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
self.n = self.C.shape[1]
# if 'damp' not in kwargs.keys(): kwargs['damp'] = None
# if 'X' not in kwargs.keys(): kwargs['X'] = nan*ones(self.n)
if self.x0 is None: self.x0 = zeros(self.n)
def _Prepare(self):
if isinstance(self.d, dict): # FuncDesigner startPoint
self.x0 = self.d
MatrixProblem._Prepare(self)
if self.isFDmodel:
self.C, self.d = self._linearOOFunsToMatrices(self.C)
if not self.damp is None and (not hasattr(self, 'X') or not any(isfinite(self.X))):
self.X = zeros(self.n)
def _Prepare(self):
MatrixProblem._Prepare(self)
if self._isFDmodel():
C, d, q, s = renderFDmodel(self)
self.C, self.d, self.q, self.s = C, d, q, s
D = self.f.D(self._x0, fixedVars = self.fixedVars)
_f = self._point2vector(D).flatten()
self.f, self._f = _f, self.f
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if self._isFDmodel():
self.x0 = self.C
return
self.f = asfarray(self.f)
self.n = self.f.size # for p.n to be available immediately after assigning prob
if self.x0 is None: self.x0 = zeros(self.n)
def __init__(self, *args, **kwargs):
self.probType = 'SDP'
self.S = {}
self.d = {}
MatrixProblem.__init__(self, *args, **kwargs)
self.f = asfarray(self.f)
self.n = self.f.size
if self.x0 is None: self.x0 = zeros(self.n)
def _Prepare(self):
if isinstance(self.d, dict): # FuncDesigner startPoint
self.x0 = self.d
MatrixProblem._Prepare(self)
if self.isFDmodel:
self.C, self.d = self._linearOOFunsToMatrices(self.C)
if not self.damp is None and (not hasattr(self, 'X')
or not any(isfinite(self.X))):
self.X = zeros(self.n)
def __init__(self, *args, **kwargs):
if len(args) > 2:
self.err(
'incorrect args number for LLAVP constructor, must be 0..2 + (optionaly) some kwargs'
)
if len(args) > 0: kwargs['C'] = args[0]
if len(args) > 1: kwargs['d'] = args[1]
MatrixProblem.__init__(self)
llavp_init(self, kwargs)
def __init__(self, *args, **kwargs):
self.QC = []
MatrixProblem.__init__(self, *args, **kwargs)
if self._isFDmodel():
if len(args) > 1:
self.x0 = args[1]
self.f = args[0]
else:
if len(args) > 1 or 'f' in kwargs.keys():
self.f = ravel(self.f)
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if len(args) > 1 or 'f' in kwargs.keys():
self.f = ravel(self.f)
self.n = self.f.size
if len(args) > 0 or 'H' in kwargs.keys():
# TODO: handle sparse cvxopt matrix H unchanges
# if not ('cvxopt' in str(type(H)) and 'cvxopt' in p.solver):
if not isspmatrix(self.H):
self.H = asfarray(self.H, float) # TODO: handle the case in runProbSolver()
def __finalize__(self):
MatrixProblem.__finalize__(self)
if self.goal in ['max', 'maximum']:
self.f = -self.f
for fn in [
'fk',
]: #not ff - it's handled in other place in RunProbSolver.py
if hasattr(self, fn):
setattr(self, fn, -getattr(self, fn))
if hasattr(self, '_f'):
self.f = self._f
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if len(args) > 1 or 'f' in kwargs.keys():
self.f = ravel(self.f)
self.n = self.f.size
if len(args) > 0 or 'H' in kwargs.keys():
# TODO: handle sparse cvxopt matrix H unchanges
# if not ('cvxopt' in str(type(H)) and 'cvxopt' in p.solver):
if not isspmatrix(self.H):
self.H = asfarray(
self.H, float) # TODO: handle the case in runProbSolver()
def _Prepare(self):
MatrixProblem._Prepare(self)
if self.solver.__name__ in ['cvxopt_sdp', 'dsdp']:
try:
from cvxopt.base import matrix
matrixConverter = lambda x: matrix(x, tc='d')
except:
self.err('cvxopt must be installed')
else:
matrixConverter = asfarray
for i in self.S.keys(): self.S[i] = matrixConverter(self.S[i])
for i in self.d.keys(): self.d[i] = matrixConverter(self.d[i])
def solve(self, *args, **kw):
C = self.C
if type(C) in (tuple, list) and isinstance(C[0], dict):
from FuncDesigner import ootranslator
K = set()
N = 0
varSizes = {}
for d in C:
K.update(d.keys())
for key in d.keys():
if key in varSizes:
if varSizes[key] != d[key].shape[1]:
s = 'incorrect shape 2nd coordinate %d for variable %s, defined in other array as %d' % (
d[key].shape[1], key.name, varSizes[key])
self.err(s)
else:
varSizes[key] = d[key].shape[1] if not isscalar(
d[key]) else 1
tmp = list(d.values())
N += tmp[0].shape[0] if not isscalar(tmp[0]) else 1
P = dict([(key, [0] * val) for key, val in varSizes.items()])
T = ootranslator(P)
C2 = vstack([T.pointDerivative2array(d) for d in C])
self.C = C2
if C2.shape != (N, N):
self.err(
'square matrix of shape (%d,%d) expected, shape %s obtained instead'
% (N, N, C2.shape))
r = MatrixProblem.solve(self, *args, **kw)
if type(C) in (tuple, list) and isinstance(C[0], dict):
r.eigenvectors = [T.vector2point(v) for v in self.eigenvectors.T]
return r
def solve(self, *args, **kw):
C = self.C
if type(C) in (tuple, list) and isinstance(C[0], dict):
from FuncDesigner import ootranslator
K = set()
N = 0
varSizes = {}
for d in C:
K.update(d.keys())
for key in d.keys():
if key in varSizes:
if varSizes[key] != d[key].shape[1]:
s = 'incorrect shape 2nd coordinate %d for variable %s, defined in other array as %d' %(d[key].shape[1], key.name, varSizes[key])
self.err(s)
else:
varSizes[key] = d[key].shape[1] if not isscalar(d[key]) else 1
tmp = list(d.values())
N += tmp[0].shape[0] if not isscalar(tmp[0]) else 1
P = dict([(key, [0]*val) for key, val in varSizes.items()])
T = ootranslator(P)
C2 = vstack([T.pointDerivative2array(d) for d in C])
self.C = C2
if C2.shape != (N, N):
self.err('square matrix of shape (%d,%d) expected, shape %s obtained instead' % (N, N, C2.shape))
r = MatrixProblem.solve(self, *args, **kw)
if type(C) in (tuple, list) and isinstance(C[0], dict):
r.eigenvectors = [T.vector2point(v) for v in self.eigenvectors.T]
return r
def _Prepare(self):
if not self._isFDmodel():
if not isspmatrix(self.H):
self.H = asfarray(
self.H) # TODO: handle the case in runProbSolver()
self.n = self.H.shape[0]
if not hasattr(self, 'x0') or self.x0 is None or self.x0[0] is nan:
self.x0 = zeros(self.n)
MatrixProblem._Prepare(self)
if self._isFDmodel():
H, f, C = quad_render(self.H, self)
self.user.f = (self.H, )
self.H, self.f, self.C = H, f, C
# print(H, f, C)
if self.fixedVars is None or (self.freeVars is not None and len(
self.freeVars) < len(self.fixedVars)):
order_kw = {'Vars': self.freeVarsSet}
else:
order_kw = {'fixedVars': self.fixedVarsSet}
order_kw['fixedVarsScheduleID'] = self._FDVarsID
from FuncDesigner import ooarray
for c in self.constraints:
if isinstance(c, ooarray):
for elem in c:
processConstraint(elem, order_kw, self)
else:
processConstraint(c, order_kw, self)
r = []
for v in self._freeVarsList:
if isinstance(v.domain, (tuple, list, ndarray, set)):
self.err(
'for FuncDesigner MILP models only variables with domains int, bool or None (real) are implemented for now'
)
if v.domain is int or v.domain is 'int' or v.domain is bool or v.domain is 'bool':
r1, r2 = self._oovarsIndDict[v]
r += arange(r1, r2).tolist()
self.intVars, self._intVars = r, self.intVars
self._intVars_vector = self.intVars
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if self.goal == 'all':
Name, name = 'all eigenvectors and eigenvalues', 'all'
if not isinstance(self.C[0], dict):
self.N = self.C.shape[0]
else:
assert type(self.goal) in (dict, tuple, list) and len(self.goal) == 1, \
'EIG goal argument should be "all" or Python dict {goal_name: number_of_required_eigenvalues}'
if type(self.goal) == dict:
goal_name, N = list(self.goal.items())[0]
else:
goal_name, N = self.goal
self.N = N
name = ''.join(goal_name.lower().split())
if name in ('lm', 'largestmagnitude'):
Name, name = 'largest magnitude', 'le'
elif name in ('sm', 'smallestmagnitude'):
Name, name = 'smallest magnitude', 'sm'
elif name in ('lr', 'largestrealpart'):
Name, name = 'largest real part', 'lr'
elif name in ('sr', 'smallestrealpart'):
Name, name = 'smallest real part', 'sr'
elif name in ('li', 'largestimaginarypart'):
Name, name = 'largest imaginary part', 'li'
elif name in ('si', 'smallestimaginarypart'):
Name, name = 'smallest imaginary part', 'si'
elif name in ('la', 'largestamplitude'):
Name, name = 'largestamplitude', 'la'
elif name in ('sa', 'smallestamplitude'):
Name, name = 'smallest amplitude', 'sa'
elif name in ('be', 'bothendsofthespectrum'):
Name, name = 'both ends of the spectrum', 'be'
self.goal = Name
self._goal = name
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if self.goal == 'all':
Name, name = 'all eigenvectors and eigenvalues', 'all'
if not isinstance(self.C[0], dict):
self.N = self.C.shape[0]
else:
assert type(self.goal) in (dict, tuple, list) and len(self.goal) == 1, \
'EIG goal argument should be "all" or Python dict {goal_name: number_of_required_eigenvalues}'
if type(self.goal) == dict:
goal_name, N = list(self.goal.items())[0]
else:
goal_name, N = self.goal
self.N = N
name = ''.join(goal_name.lower().split())
if name in ('lm', 'largestmagnitude'):
Name, name = 'largest magnitude', 'le'
elif name in ('sm', 'smallestmagnitude'):
Name, name = 'smallest magnitude', 'sm'
elif name in ('lr', 'largestrealpart'):
Name, name = 'largest real part', 'lr'
elif name in ('sr', 'smallestrealpart'):
Name, name = 'smallest real part', 'sr'
elif name in ('li', 'largestimaginarypart'):
Name, name = 'largest imaginary part', 'li'
elif name in ('si', 'smallestimaginarypart'):
Name, name = 'smallest imaginary part', 'si'
elif name in ('la', 'largestamplitude'):
Name, name = 'largestamplitude', 'la'
elif name in ('sa', 'smallestamplitude'):
Name, name = 'smallest amplitude', 'sa'
elif name in ('be', 'bothendsofthespectrum'):
Name, name = 'both ends of the spectrum', 'be'
self.goal = Name
self._goal = name
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if 'damp' not in kwargs.keys(): self.damp = None
if 'f' not in kwargs.keys(): self.f = None
if not self._isFDmodel():
if len(args) > 0:
self.n = args[0].shape[1]
else:
self.n = kwargs['C'].shape[1]
#self.lb = -inf * ones(self.n)
#self.ub = inf * ones(self.n)
if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n)
if not hasattr(self, 'ub'): self.ub = inf * ones(self.n)
if self.x0 is None: self.x0 = zeros(self.n)
else: # is FD model
if type(self.C) not in (set, tuple, list):
if 'is_oovar' not in dir(self.C):
s = '''
Icorrect data type for LLSP constructor,
first argument should be numpy ndarray,
scipy sparse matrix, FuncDesigner oofun or list of oofuns'''
self.err(s)
self.C = [self.C]
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
if 'damp' not in kwargs.keys(): self.damp = None
if 'f' not in kwargs.keys(): self.f = None
if not self._isFDmodel():
if len(args)>0:
self.n = args[0].shape[1]
else:
self.n = kwargs['C'].shape[1]
#self.lb = -inf * ones(self.n)
#self.ub = inf * ones(self.n)
if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n)
if not hasattr(self, 'ub'): self.ub = inf * ones(self.n)
if self.x0 is None: self.x0 = zeros(self.n)
else: # is FD model
if type(self.C) not in (set, tuple, list):
if 'is_oovar' not in dir(self.C):
s = '''
Icorrect data type for LLSP constructor,
first argument should be numpy ndarray,
scipy sparse matrix, FuncDesigner oofun or list of oofuns'''
self.err(s)
self.C = [self.C]
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
self.x0 = zeros(2 * len(self.q))
def _Prepare(self):
MatrixProblem._Prepare(self)
if not self.damp is None and not any(isfinite(self.X)):
self.X = zeros(self.n)
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
self.f = asfarray(self.f)
self.n = self.f.size # for p.n to be available immediately after assigning prob
if self.x0 is None: self.x0 = zeros(self.n)
def __init__(self, *args, **kw):
self.goal = 'max'
self.objective = 'weight'
MatrixProblem.__init__(self, *args, **kw)
self.__init_kwargs = kw
self._init = True
def __init__(self, *args, **kw):
MatrixProblem.__init__(self, *args, **kw)
self.__init_kwargs = kw
self._init = True
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
self.x0 = zeros(2*len(self.q))
def __init__(self, *args, **kwargs):
MatrixProblem.__init__(self, *args, **kwargs)
def _Prepare(self):
# TODO: handle cvxopt sparse matrix case here
self.n = self.H.shape[0]
if not hasattr(self, 'x0') or self.x0 is None or self.x0[0] == nan:
self.x0 = zeros(self.n)
MatrixProblem._Prepare(self)
def __init__(self, *args, **kw):
MatrixProblem.__init__(self, *args, **kw)
self.__init_kwargs = kw
self._init = True
def __finalize__(self):
if self.isFDmodel: self.intVars = self._intVars
MatrixProblem.__finalize__(self)
def __init__(self, *args, **kw):
self.goal = 'max'
self.objective = 'weight'
MatrixProblem.__init__(self, *args, **kw)
self.__init_kwargs = kw
self._init = True
def _Prepare(self):
MatrixProblem._Prepare(self)
if not self.damp is None and not any(isfinite(self.X)):
self.X = zeros(self.n)
def __init__(self, *args, **kwargs):
self.goal = 'minimum'
MatrixProblem.__init__(self, *args, **kwargs)
if len(args) > 1 and not hasattr(args[0], 'is_oovar'):
self.err('No more than 1 argument is allowed for classic style LP constructor')
def _Prepare(self):
# TODO: handle cvxopt sparse matrix case here
self.n = self.H.shape[0]
if not hasattr(self, 'x0') or self.x0 is None or self.x0[0] == nan:
self.x0 = zeros(self.n)
MatrixProblem._Prepare(self)
