def __init__(self, *args, **kwargs):
"""HSO Optimizer Class Initialization
Documentation last updated: October. 22, 2008 - Ruben E. Perez
"""
name = 'HSO'
category = 'Global Optimizer'
def_opts = {
# Memory Size [4,10]
'hms': [int, 10],
'dbw': [float, 0.01],
'hmcr': [float, 0.96],
'par': [float, 0.6],
# Maximum Number Iterations
'maxiter': [int, 1e4],
# Flag to Turn On Information Output
'printout': [int, 0],
# Initial Position Flag (0 - no position, 1 - position given)
'xinit': [int, 0],
# Random Number Seed (0 - Auto-Seed based on time clock)
'seed': [float, 0],
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""KSOPT Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'KSOPT'
category = 'Local Optimizer'
def_opts = {
'ITMAX': [int, 4e2], # Maximum Number of Iterations
'RDFUN': [float, 1e-4], # Objective Convergence Relative Tolerance
'RHOMIN': [float, 5.0], # Initial KS multiplier
'RHOMAX': [float, 100.0], # Final KS multiplier
# Print Control (0 - None, 1 - Final, 2 - Iters)
'IPRINT': [int, 2],
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'KSOPT.out'], # Output File Name
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""PSQP Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'PSQP'
category = 'Local Optimizer'
def_opts = {
'XMAX': [float, 1e16], # Maximum Stepsize
'TOLX': [float, 1e-16], # Variable Change Tolerance
'TOLC': [float, 1e-6], # Constraint Violation Tolerance
'TOLG': [float, 1e-6], # Lagrangian Gradient Tolerance
'RPF': [float, 1e-4], # Penalty Coefficient
'MIT': [int, 1000], # Maximum Number of Iterations
'MFV': [int, 2000], # Maximum Number of Function Evaluations
'MET': [int, 2], # Variable Metric Update (1 - BFGS, 2 - Hoshino)
# Negative Curvature Correction (1 - None, 2 - Powell's Correction)
'MEC': [int, 2],
'IPRINT': [int, 2], # Output Level (0 - None, 1 - Final, 2 - Iter)
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'PSQP.out'], # Output File Name
}
informs = {
1:
'Change in design variable was less than or equal to tolerance',
2:
'Change in objective function was less than or equal to '
'tolerance',
3:
'Objective function less than or equal to tolerance',
4:
'Maximum constraint value is less than or equal to tolerance',
11:
'Maximum number of iterations exceeded',
12:
'Maximum number of function evaluations exceeded',
13:
'Maximum number of gradient evaluations exceeded',
-6:
'Termination criterion not satisfied, but obtained point is '
'acceptable',
# <0 : 'Method failed',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""SOLVOPT Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'SOLVOPT'
category = 'Local Optimizer'
def_opts = {
'xtol': [float, 1e-4], # Variables Tolerance
'ftol': [float, 1e-6], # Objective Tolerance
'maxit': [int, 15000], # Maximum Number of Iterations
# Output Level (-1 -> None, 0 -> Final, N - each Nth iter)
'iprint': [int, 1],
'gtol': [float, 1e-8], # Constraints Tolerance
'spcdil': [float, 2.5], # Space Dilation
'iout': [int, 6], # Output Unit Number
'ifile': [str, 'SOLVOPT.out'], # Output File Name
}
informs = {
1: 'Normal termination.',
-2: 'Improper space dimension.',
-3: 'Objective equals infinity.',
-4: 'Gradient equals zero or infinity.',
-5: 'Objective equals infinity.',
-6: 'Gradient equals zero or infinity.',
-7: 'Objective function is unbounded.',
-8: 'Gradient zero at the point, but stopping criteria are not '
'fulfilled.',
-9: 'Iterations limit exceeded.',
-11: 'Premature stop is possible. Try to re-run the routine from '
'the obtained point.',
-12: 'Result may not provide the optimum. The function apparently '
'has many extremum points.',
-13: 'Result may be inaccurate in the coordinates. The function is '
'flat at the optimum.',
-14: 'Result may be inaccurate in a function value. The function '
'is extremely steep at the optimum.',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""SLSQP Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'SLSQP'
category = 'Local Optimizer'
def_opts = {
# SLSQP Options
'ACC': [float, 1e-6], # Convergence Accurancy
'MAXIT': [int, 50], # Maximum Iterations
# Output Level (<0 - None, 0 - Screen, 1 - File)
'IPRINT': [int, 1],
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'SLSQP.out'], # Output File Name
}
informs = {
-1: "Gradient evaluation required (g & a)",
0: "Optimization terminated successfully.",
1: "Function evaluation required (f & c)",
2: "More equality constraints than independent variables",
3: "More than 3*n iterations in LSQ subproblem",
4: "Inequality constraints incompatible",
5: "Singular matrix E in LSQ subproblem",
6: "Singular matrix C in LSQ subproblem",
7: "Rank-deficient equality constraint subproblem HFTI",
8: "Positive directional derivative for linesearch",
9: "Iteration limit exceeded",
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""MMFD Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'MMFD'
category = 'Local Optimizer'
def_opts = {
# Feasible Directions Approach (0 - MMFD, 1 - MFD)
'IOPT': [int, 0],
'IONED': [int, 0], # One-Dimensional Search Method (0,1,2,3)
'CT': [float, -3e-2], # Constraint Tolerance
'CTMIN': [float, 4e-3], # Active Constraint Tolerance
# Objective Absolute Tolerance (DABOBJ*abs(f(x)))
'DABOBJ': [float, 1e-3],
'DELOBJ': [float, 1e-3], # Objective Relative Tolerance
'THETAZ': [float, 1e-1], # Push-Off Factor
'PMLT': [float,
1e1], # Penalty multiplier for equality constraints
'ITMAX': [int, 4e2], # Maximum Number of Iterations
# consecutive Iterations Iterations for Convergence
'ITRMOP': [int, 3],
# Print Control (0 - None, 1 - Final, 2 - Iters)
'IPRINT': [int, 2],
'IFILE': [str, 'MMFD.out'], # Output File Name
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""NSGA2 Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'NSGA-II'
category = 'Global Optimizer'
def_opts = {
'PopSize': [int, 100],
'maxGen': [int, 150],
'pCross_real': [float, 0.6],
'pMut_real': [float, 0.2],
'eta_c': [float, 10],
'eta_m': [float, 20],
'pCross_bin': [float, 0],
'pMut_bin': [float, 0],
# Flag to Turn On Output to filename (0 - , 1 - , 2 - )
'PrintOut': [int, 1],
# Random Number Seed (0 - Auto-Seed based on time clock)
'seed': [float, 0],
# Use Initial Solution Flag (0 - random population,
# 1 - use given solution)
'xinit': [int, 0],
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""ALGENCAN Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation (None,
'POA'-Parallel Objective Analysis), *Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'ALGENCAN'
category = 'Local Optimizer'
def_opts = {
# ALGENCAN Options
'epsfeas': [float, 1.0e-8], # Feasibility Convergence Accuracy
'epsopt': [float, 1.0e-8], # Optimality Convergence Accuracy
'efacc': [float, 1.0e-4], # Feasibility Level for Newton-KKT
# Acceleration
'eoacc': [float, 1.0e-4], # Optimality Level for Newton-KKT
# Acceleration
'checkder': [bool, False], # Check Derivatives Flag
'iprint': [int, 10], # Print Flag (0 - None, )
'ifile': [str, 'ALGENCAN.out'], # Output File Name
'ncomp': [int, 6], # Print Precision
}
informs = {
0: "Solution was found.",
1: "Stationary or infeasible point was found.",
2: "penalty parameter is too large infeasible or "
"badly scaled problem",
3: "Maximum of iterations reached.",
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""GCMMA Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'GCMMA'
category = 'Local Optimizer'
def_opts = {
# GCMMA Options
'MAXIT': [int, 1000], # Maximum Iterations
'INNMAX': [int, 10], # Maximum Inner Iterations
'GEPS': [float, 1e-6], # Dual Objective Gradient Tolerance
'DABOBJ': [float, 1e-6],
'DELOBJ': [float, 1e-6],
'ITRM': [int, 2],
# Output Level (<0 - None, 0 - Screen, 1 - File)
'IPRINT': [int, 1],
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'GCMMA.out'], # Output File Name
}
informs = {
0: 'The optimality conditions are satisfied.',
1: 'The algorithm has been stopped after MAXIT iterations.',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""COBYLA Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
None,
POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'COBYLA'
category = 'Local Optimizer'
def_opts = {
'RHOBEG': [float, 0.5], # Initial Variables Change
'RHOEND': [float, 1.0e-6], # Convergence Accuracy
# Print Flag (0 - None, 1 - Final, 2,3 - Iteration)
'IPRINT': [int, 2],
'MAXFUN': [int, 3500], # Maximum Iterations
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'COBYLA.out'], # Output File Name
}
informs = {
0: 'Normal return',
1: 'Max. number of function evaluations reach',
2: 'Rounding errors are becoming damaging',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""SDPEN Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: August. 09, 2012 - Ruben E. Perez
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'SDPEN'
category = 'Local Optimizer'
def_opts = {
# SDPEN Options
'alfa_stop': [float, 1e-6], # Convergence Tolerance
'nf_max': [int, 5000], # Maximum Number of Function Evaluations
# Output Level (<0 - None,0 - Final, 1 - Iters, 2 - Full)
'iprint': [int, 0],
'iout': [int, 6], # Output Unit Number
'ifile': [str, 'SDPEN.out'], # Output File Name
}
informs = {
1: 'finished successfully',
2: 'maximum number of evaluations reached',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""CONMIN Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'CONMIN'
category = 'Local Optimizer'
def_opts = {
'ITMAX': [int, 1e4], # Maximum Number of Iterations
'DELFUN': [float, 1e-6], # Objective Relative Tolerance
'DABFUN': [float, 1e-6], # Objective Absolute Tolerance
'ITRM': [int, 2],
'NFEASCT': [int, 20],
# Print Control (0 - None, 1 - Final, 2,3,4,5 - Debug)
'IPRINT': [int, 2],
'IOUT': [int, 6], # Output Unit Number
'IFILE': [str, 'CONMIN.out'], # Output File Name
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""FILTERSD Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'FILTERSD'
category = 'Local Optimizer'
def_opts = {
'rho': [float, 100.0], # initial trust region radius
# tolerance allowed in sum h of constraint feasibilities
'htol': [float, 1e-6],
# tolerance allowed in reduced gradient l2 norm
'rgtol': [float, 1e-5],
# maximum number of major iterations allowed
'maxit': [int, 1000],
# upper limit on the number of gradient calls
'maxgr': [int, 1e5],
# upper bound on the allowed constraint violation
'ubd': [float, 1e5],
# derivative check flag (0 - no check, 1 - check)
'dchk': [int, 0],
# derivative check tolerance
'dtol': [float, 1e-8],
# verbosity of printing (0 - none, 1 - Iter, 2 - Debug)
'iprint': [int, 1],
'iout': [int, 6], # Output Unit Number
'ifile': [str, 'FILTERSD.out'], # Output File Name
}
informs = {
-1: 'ws not large enough',
-2: 'lws not large enough',
-3: 'inconsistency during derivative check',
0: 'successful run',
1: 'unbounded NLP (f <= fmin at an htol-feasible point)',
2: 'bounds on x are inconsistent',
3: 'local minimum of feasibility problem and h > htol, '
'(nonlinear constraints are locally inconsistent)',
4: 'initial point x has h > ubd (reset ubd or x and re-enter)',
5: 'maxit major iterations have been carried out',
6: 'termination with rho <= htol',
7: 'not enough workspace in ws or lws (see message)',
8: 'insufficient space for filter (increase mxf and re-enter)',
9: 'unexpected fail in LCP solver',
10: 'unexpected fail in LCP solver',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""ALHSO Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation (None,
'POA'-Parallel Objective Analysis), *Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'ALHSO'
category = 'Global Optimizer'
def_opts = {
# Memory Size [1,50]
'hms': [int, 5],
# Probability rate of choosing from memory [0.7,0.99]
'hmcr': [float, 0.95],
# Pitch adjustment rate [0.1,0.99]
'par': [float, 0.65],
'dbw': [int, 2000], # Variable Bandwidth Quantization
# Maximum Number of Outer Loop Iterations (Major Iterations)
'maxoutiter': [int, 2e3],
# Maximum Number of Inner Loop Iterations (Minor Iterations)
'maxinniter': [int, 2e2],
# Stopping Criteria Flag
'stopcriteria': [int, 1],
# Consecutively Number of Outer Iterations for which the Stopping
# Criteria must be Satisfied
'stopiters': [int, 10],
# Absolute Tolerance for Equality constraints
'etol': [float, 1e-6],
# Absolute Tolerance for Inequality constraints
'itol': [float, 1e-6],
# Absolute Tolerance for Objective Function
'atol': [float, 1e-6],
# Relative Tolerance for Objective Function
'rtol': [float, 1e-6],
# Number of Iterations Before Print Outer Loop Information
'prtoutiter': [int, 0],
# Number of Iterations Before Print Inner Loop Information
'prtinniter': [int, 0],
# Initial Position Flag (0 - no position, 1 - position given)
'xinit': [int, 0],
# Initial Penalty Factor
'rinit': [float, 1.0],
# Flag to Turn On Output to filename
'fileout': [int, 1],
# We could probably remove fileout flag if filename or
# fileinstance is given
'filename': [str, 'ALHSO.out'],
# Random Number Seed (0 - Auto-Seed based on time clock)
'seed': [float, 0],
# Design Variables Scaling Flag (0 - no scaling,
# 1 - scaling between [-1,1])
'scaling': [int, 1],
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""MIDACO Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
self.spm = False
elif pll_type.upper() == 'POA':
self.poa = True
self.spm = False
elif pll_type.upper() == 'SPM':
self.poa = False
self.spm = True
else:
raise ValueError("pll_type must be either None, 'POA' or 'SPM'")
name = 'MIDACO'
category = 'Global Optimizer'
def_opts = {
# MIDACO Options
# Accuracy for constraint violation (0 - default)
'ACC': [float, 0],
# Seed for random number generator (e.g. ISEED = 0,1,2,3,...)
'ISEED': [int, 0],
# Objective Function Stopping Value (0 - disabled)
'FSTOP': [int, 0],
# Automatic stopping criteria (0 - disable,
# 1 to 500 - from local to global)
'AUTOSTOP': [int, 0],
# Oracle parameter for constrained problems
# (0 - Use internal default)
'ORACLE': [float, 0],
# Focus of MIDACO search process around best solution
# (0 - Use internal default)
'FOCUS': [int, 0],
# Number of iterates (ants) per generation
# (0 - Use internal default)
'ANTS': [int, 0],
# Size of the solution archive (0 - Use internal default)
'KERNEL': [int, 0],
# Internal custom parameters (0 - Use internal default,
# 1 - IP problems,
# 2 - NLP problems,
# 3 - MINLP problems)
'CHARACTER': [int, 0],
# Maximum function evaluations
'MAXEVAL': [int, 10000],
# Maximum time limit, in seconds
'MAXTIME': [int, 86400],
# Output Level (<0 - None, 0 - Screen, 1 - File(s))
'IPRINT': [int, 1],
# Print-Frequency for current best solution
'PRINTEVAL': [int, 1000],
'IOUT1': [int, 36], # History output unit number
'IOUT2': [int, 37], # Best solution output unit number
'IFILE1': [str, 'MIDACO_HIST.out'], # History output file name
'IFILE2': [str, 'MIDACO_BEST.out'], # Best output file name
'LKEY': [str, 'MIDACO_LIMITED_VERSION___'
'[CREATIVE_COMMONS_BY-NC-ND_LICENSE]'],
}
informs = {
1: 'Feasible solution, MIDACO was stopped by the user '
'submitting ISTOP=1',
2: 'Infeasible solution, MIDACO was stopped by the user '
'submitting ISTOP=1',
3: 'Feasible solution, MIDACO stopped automatically '
'using AUTOSTOP option',
4: 'Infeasible solution, MIDACO stopped automatically '
'using AUTOSTOP option',
5: 'Feasible solution, MIDACO stopped automatically by FSTOP',
51: 'WARNING: Some X(i) is greater/lower than +/- 1.0D+12 '
'(try to avoid huge values!)',
52: 'WARNING: Some XL(i) is greater/lower than +/- 1.0D+12 '
'(try to avoid huge values!)',
53: 'WARNING: Some XU(i) is greater/lower than +/- 1.0D+12 '
'(try to avoid huge values!)',
61: 'WARNING: Some X(i) should be discrete (e.g. 1.000) , '
'but is continuous (e.g. 1.234)',
62: 'WARNING: Some XL(i) should be discrete (e.g. 1.000) , '
'but is continuous (e.g. 1.234)',
63: 'WARNING: Some XU(i) should be discrete (e.g. 1.000) , '
'but is continuous (e.g. 1.234)',
71: 'WARNING: Some XL(i) = XU(I) (fixed variable)',
81: 'WARNING: F(X) has value NaN for starting point X '
'(sure your problem is correct?)',
82: 'WARNING: Some G(X) has value NaN for starting point X '
'(sure your problem is correct?)',
91: 'WARNING: FSTOP is greater/lower than +/- 1.0D+8',
92: 'WARNING: ORACLE is greater/lower than +/- 1.0D+8',
101: 'ERROR: L <= 0 or L > 1.0D+6',
102: 'ERROR: N <= 0 or N > 1.0D+6',
103: 'ERROR: NINT < 0',
104: 'ERROR: NINT > N',
105: 'ERROR: M < 0 or M > 1.0D+6',
106: 'ERROR: ME < 0',
107: 'ERROR: ME > M',
201: 'ERROR: some X(i) has type NaN',
202: 'ERROR: some XL(i) has type NaN',
203: 'ERROR: some XU(i) has type NaN',
204: 'ERROR: some X(i) < XL(i)',
205: 'ERROR: some X(i) > XU(i)',
206: 'ERROR: some XL(i) > XU(i)',
301: 'ERROR: ACC < 0 or ACC > 1.0D+6',
302: 'ERROR: ISEED < 0 or ISEED > 1.0D+12',
303: 'ERROR: FSTOP greater/lower than +/- 1.0D+12',
304: 'ERROR: AUTOSTOP < 0 or AUTOSTOP > 1.0D+6',
305: 'ERROR: ORACLE greater/lower than +/- 1.0D+12',
306: 'ERROR: |FOCUS| < 1 or FOCUS > 1.0D+12',
307: 'ERROR: ANTS < 0 or ANTS > 1.0D+8',
308: 'ERROR: KERNEL < 0 or KERNEL > 100',
309: 'ERROR: ANTS < KERNEL',
310: 'ERROR: ANTS > 0 but KERNEL = 0',
311: 'ERROR: KERNEL > 0 but ANTS = 0',
312: 'ERROR: CHARACTER < 0 or CHARACTER > 1000',
313: 'ERROR: some MIDACO parameters has type NaN',
401: 'ERROR: ISTOP < 0 or ISTOP > 1',
501: 'ERROR: Double precision work space size LRW is too small '
'(see below LRW), RW must be at least '
'of size LRW = 200*N+2*M+1000',
601: 'ERROR: Integer work space size LIW is too small '
'(see below LIW), IW must be at least of size LIW = 2*N+L+100',
701: 'ERROR: Input check failed! MIDACO must be called '
'initially with IFAIL = 0',
801: 'ERROR: L > LMAX (user must specify LMAX below in the '
'MIDACO source code)',
802: 'ERROR: L*M+1 > LXM (user must specify LXM below in the '
'MIDACO source code)',
900: 'ERROR: Invalid or corrupted LICENSE_KEY',
999: 'ERROR: N > 4. The free test version is limited '
'up to 4 variables',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""ALPSO Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: ALPSO Parallel Implementation
None,
SPM- Static,
DPM- Dynamic,
POA-Parallel Analysis),
*Default* = None
Documentation last updated: February. 2, 2011 - Ruben E. Perez
"""
if pll_type is None:
try:
# import alpso as alpso
from . import alpso
except:
raise ImportError('pyALPSO: ALPSO shared library '
'failed to import')
name = 'ALPSO'
self.alpso = alpso
elif pll_type.upper() == 'SPM':
try:
# import alpso_spm
from . import alpso_spm
from mpi4py import MPI
except:
raise ImportError('pyALPSO: ALPSO SPM shared library '
'failed to import')
name = 'ALPSO - SPM'
self.alpso = alpso_spm
elif pll_type.upper() == 'DPM':
# if not 'alpso_dpm' in sys.modules:
# raise ImportError('pyALPSO: ALPSO DPM shared
# library failed to import')
try:
# import alpso_dpm
from . import alpso_dpm
from mpi4py import MPI
except:
raise ImportError('pyALPSO: ALPSO DPM shared library '
'failed to import')
name = 'ALPSO - DPM'
self.alpso = alpso_dpm
elif pll_type.upper() == 'POA':
try:
# import alpso_poa
from . import alpso_poa
from mpi4py import MPI
except:
raise ImportError(
'pyALPSO: ALPSO POA shared library failed to import')
name = 'ALPSO - POA'
self.alpso = alpso_poa
else:
raise ValueError(
"pll_type must be either None,'SPM', 'DPM' or 'POA'")
category = 'Global Optimizer'
def_opts = {
# Number of Particles (Depends on Problem dimensions)
'SwarmSize': [int, 40],
# Maximum Number of Outer Loop Iterations (Major Iterations)
'maxOuterIter': [int, 200],
# Maximum Number of Inner Loop Iterations (Minor Iterations)
'maxInnerIter': [int, 6],
# Minimum Number of Inner Loop Iterations (Dynamic Inner Iterations)
'minInnerIter': [int, 6],
# Dynamic Number of Inner Iterations Flag
'dynInnerIter': [int, 0],
# Stopping Criteria Flag (0 - maxIters, 1 - convergence)
'stopCriteria': [int, 1],
# Consecutively Number of Iterations for which the
# Stopping Criteria must be Satisfied
'stopIters': [int, 5],
# Absolute Tolerance for Equality constraints
'etol': [float, 1e-3],
# Absolute Tolerance for Inequality constraints
'itol': [float, 1e-3],
# Absolute Tolerance for Lagrange Multipliers
# 'ltol':[float,1e-2],
# Relative Tolerance for Lagrange Multipliers
'rtol': [float, 1e-2],
# Absolute Tolerance for Lagrange Function
'atol': [float, 1e-2],
# Relative Tolerance in Distance of All Particles
# to Terminate (GCPSO)
'dtol': [float, 1e-1],
# Number of Iterations Before Print Outer Loop Information
'printOuterIters': [int, 0],
# Number of Iterations Before Print Inner Loop Information
'printInnerIters': [int, 0],
# Initial Penalty Factor
'rinit': [float, 1.0],
# Initial Position Flag (0 - no position, 1 - position given)
'xinit': [int, 0],
# Initial Velocity of Particles in Normalized [-1,1] Design Space
'vinit': [float, 1.0],
# Maximum Velocity of Particles in Normalized [-1,1] Design Space
'vmax': [float, 2.0],
# Cognitive Parameter
'c1': [float, 2.0],
# Social Parameter
'c2': [float, 1.0],
# Initial Inertia Weight
'w1': [float, 0.99],
# Final Inertia Weight
'w2': [float, 0.55],
# Number of Consecutive Successes in Finding New Best Position
# of Best Particle Before Search Radius will be Increased (GCPSO)
'ns': [int, 15],
# Number of Consecutive Failures in Finding New Best Position of
# Best Particle Before Search Radius will be Increased (GCPSO)
'nf': [int, 5],
# Time step
'dt': [float, 1.0],
# Craziness Velocity (Added to Particle Velocity After Updating
# the Penalty Factors and Langangian Multipliers)
'vcrazy': [float, 1e-4],
# Flag to Turn On Output to filename
'fileout': [int, 1],
# We could probably remove fileout flag if filename or
# fileinstance is given
'filename': [str, 'ALPSO.out'],
# Random Number Seed (0 - Auto-Seed based on time clock)
'seed': [float, 0],
# Number of Neighbours of Each Particle
'HoodSize': [int, 40],
# Neighbourhood Model (dl/slring - Double/Single Link Ring, wheel -
# Wheel, Spatial - based on spatial distance,
# sfrac - Spatial Fraction)
'HoodModel': [str, 'gbest'],
# Selfless Neighbourhood Model (0 - Include Particle i in NH i,
# 1 - Don't Include Particle i)
'HoodSelf': [int, 1],
# Design Variables Scaling Flag (0 - no scaling,
# 1 - scaling between [-1,1])
'Scaling': [int, 1],
}
informs = {}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
if self.name in ('ALPSO - SPM', 'ALPSO - DPM', 'ALPSO - POA'):
self.myrank = MPI.COMM_WORLD.Get_rank()
else:
self.myrank = 0
def __init__(self, pll_type=None, *args, **kwargs):
"""NLPQLP Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.pll_type = None
elif pll_type.upper() == 'SPM':
self.pll_type = 'SPM'
elif pll_type.upper() == 'POA':
self.pll_type = 'POA'
else:
raise ValueError("pll_type must be either "
"None, 'SPM', 'DPM' or 'POA'")
name = 'NLPQLP'
category = 'Local Optimizer'
def_opts = {
'ACC': [float, 1e-8], # Convergence Accuracy
'ACCQP': [float, 1e-12], # QP Solver Convergence Accuracy
'STPMIN': [float, 1e-10], # Minimum Step Length
# Maximum Number of Function Calls During Line Search
'MAXFUN': [int, 10],
'MAXIT': [int, 100], # Maximum Number of Outer Iterations
'RHOB': [float,
0.0], # BFGS-Update Matrix Initialization Parameter
# Output Level (0 - None, 1 - Final, 2 - Major,
# 3 - Major/Minor, 4 - Full)
'IPRINT': [int, 2],
'MODE': [int, 0], # NLPQLP Mode
'IOUT': [int, 6], # Output Unit Number
# QP Subproblem Solver (True - Quasi-Newton, False - Cholesky)
'LQL': [bool, True],
'IFILE': [str, 'NLPQLP.out'], # Output File Name
}
informs = {
-2:
'Compute gradient values w.r.t. the variables stored in'
' first column of X, and store them in DF and DG.'
' Only derivatives for active constraints ACTIVE(J)=.TRUE. '
'need to be computed.',
-1:
'Compute objective fn and all constraint values subject'
'the variables found in the first L columns of X, and store '
'them in F and G.',
0:
'The optimality conditions are satisfied.',
1:
' The algorithm has been stopped after MAXIT iterations.',
2:
' The algorithm computed an uphill search direction.',
3:
' Underflow occurred when determining a new approximation matrix'
'for the Hessian of the Lagrangian.',
4:
'The line search could not be terminated successfully.',
5:
'Length of a working array is too short.'
' More detailed error information is obtained with IPRINT>0',
6:
'There are false dimensions, for example M>MMAX, N>=NMAX, '
'or MNN2<>M+N+N+2.',
7:
'The search direction is close to zero, but the current iterate '
'is still infeasible.',
8:
'The starting point violates a lower or upper bound.',
9:
'Wrong input parameter, i.e., MODE, LDL decomposition in D and C'
' (in case of MODE=1), IPRINT, IOUT',
10:
'Internal inconsistency of the quadratic subproblem, '
'division by zero.',
100:
'The solution of the quadratic programming subproblem has been'
' terminated with an error message and IFAIL is set to '
'IFQL+100, where IFQL denotes the index of an '
'inconsistent constraint.',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""FSQP Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'FSQP'
category = 'Local Optimizer'
def_opts = {
'mode': [int, 100], # FSQP Mode (See Manual)
# Output Level (0 - None, 1 - Final, 2 - Major, 3 - Major Details)
'iprint': [int, 2],
'miter': [int, 500], # Maximum Number of Iterations
'bigbnd': [float, 1e10], # Plus Infinity Value
'epstol': [float, 1e-8], # Convergence Tolerance
'epseqn': [float, 0], # Equality Constraints Tolerance
'iout': [int, 6], # Output Unit Number
'ifile': [str, 'FSQP.out'], # Output File Name
}
informs = {
0:
'Normal termination of execution',
1:
'User-provided initial guess is infeasible for linear '
'constraints, unable to generate a point satisfying '
'all these constraints',
2:
'User-provided initial guess is infeasible for nonlinear '
'inequality constraints and linear constraints, unable to '
'generate a point satisfying all these constraints',
3:
'The maximum number of iterations has been reached before '
'a solution is obtained',
4:
'The line search fails to find a new iterate',
5:
'Failure of the QP solver in attempting to construct d0, a more '
'robust QP solver may succeed',
6:
'Failure of the QP solver in attempting to construct d1, a more '
'robust QP solver may succeed',
7:
'Input data are not consistent, check print out error messages',
8:
'Two consecutive iterates are numerically equivalent before a '
'stopping criterion is satisfied',
9:
'One of the penalty parameters exceeded bigbnd, the algorithm '
'is having trouble satisfying a nonlinear equality constraint',
}
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)
def __init__(self, pll_type=None, *args, **kwargs):
"""SNOPT Optimizer Class Initialization
**Keyword arguments:**
- pll_type -> STR: Parallel Implementation
(None,
'POA'-Parallel Objective Analysis),
*Default* = None
Documentation last updated: Feb. 16, 2010 - Peter W. Jansen
"""
if pll_type is None:
self.poa = False
elif pll_type.upper() == 'POA':
self.poa = True
else:
raise ValueError("pll_type must be either None or 'POA'")
name = 'SNOPT'
category = 'Local Optimizer'
def_opts = {
# SNOPT Printing Options
# Majors Print (1 - line major iteration log)
'Major print level': [int, 1],
# Minors Print (1 - line minor iteration log)
'Minor print level': [int, 1],
# Print File Name (specified by subroutine snInit)
'Print file': [str, 'SNOPT_print.out'],
# Print File Output Unit (override internally in snopt?)
'iPrint': [int, 18],
# Summary File Name (specified by subroutine snInit)
'Summary file': [str, 'SNOPT_summary.out'],
# Summary File Output Unit (override internally in snopt?)
'iSumm': [int, 19],
'Print frequency': [int,
100], # Minors Log Frequency on Print File
# Minors Log Frequency on Summary File
'Summary frequency': [int, 100],
'Solution': [str, 'Yes'], # Print Solution on the Print File
# (options are normally listed)
'Suppress options listing': [type(None), None],
# Print System Information on the Print File
'System information': [str, 'No'],
# SNOPT Problem Specification Options
# ('Maximize': alternative over Minimize,
# 'Feasible point': alternative over Minimize or Maximize)
'Problem Type': [str, 'Minimize'],
'Objective row': [int, 1], # (has precedence over ObjRow (snOptA))
'Infinite bound': [float, 1.0e+20], # Infinite Bound Value
# SNOPT Convergence Tolerances Options
# Target Nonlinear Constraint Violation
'Major feasibility tolerance': [float, 1.0e-6],
# Target Complementarity Gap
'Major optimality tolerance': [float, 1.0e-6],
# For Satisfying the QP Bounds
'Minor feasibility tolerance': [float, 1.0e-6],
# SNOPT Derivative Checking Options
'Verify level': [int, 0], # Gradients Check Flag
# SNOPT Scaling Options
# Scaling (1 - linear constraints and variables)
'Scale option': [int, 1],
'Scale tolerance': [float, 0.9], # Scaling Tolerance
# Default: scales are not printed
'Scale Print': [type(None), None],
# SNOPT Other Tolerances Options
'Crash tolerance': [float, 0.1],
# smaller for more accurate search
'Linesearch tolerance': [float, 0.9],
'Pivot tolerance': [float, 3.7e-11], # epsilon^(2/3)
# SNOPT QP subproblems Options
'QPSolver': [str, 'Cholesky'], # Default: Cholesky
# (3 - first basis is essentially triangular)
'Crash option': [int, 3],
# (start with elastic mode until necessary)
'Elastic mode': [str, 'No'],
# (used only during elastic mode)
'Elastic weight': [float, 1.0e+4],
'Iterations limit': [int, 10000], # (or 20*ncons if that is more)
'Partial price': [int, 1], # (10 for large LPs)
# SNOPT SQP method Options
# has precedence over argument start,
# ('Warm': alternative to a cold start)
'Start': [str, 'Cold'],
'Major iterations limit': [int, 1000], # or ncons if that is more
'Minor iterations limit': [int, 500], # or 3*ncons if that is more
'Major step limit': [float, 2.0],
# (n1 + 1, n1 = number of nonlinear variables)
'Superbasics limit': [int, None],
'Derivative level': [int, 3], # (NOT ALLOWED IN snOptA)
'Derivative option': [int, 1], # (ONLY FOR snOptA)
'Derivative linesearch': [type(None), None],
'Nonderivative linesearch': [type(None), None],
# epsilon^0.8 (almost full accuracy)
'Function precision': [float, 3.0e-13],
'Difference interval': [float, 5.5e-7], # Function precision^(1/2)
# Function precision^(1/3)
'Central difference interval': [float, 6.7e-5],
# controls early termination of QPs
'New superbasics limit': [int, 99],
'Objective row': [int, 1], # row number of objective in F(x)
'Penalty parameter': [float, 0.0], # initial penalty parameter
# (1 - satisfies linear constraints near x0)
'Proximal point method': [int, 1],
# (or Superbasics limit if that is less)
'Reduced Hessian dimension': [int, 2000],
# (unscaled constraint violation limit)
'Violation limit': [int, 10.0],
'Unbounded step size': [float, 1.0e+18],
'Unbounded objective': [float, 1.0e+15],
# SNOPT Hessian approximation Options
'Hessian full memory': [type(None), None], # default if n1 <= 75
'Hessian limited memory': [type(None), None], # default if n1 > 75
# for full Hessian (never reset)
'Hessian frequency': [int, 999999],
'Hessian updates': [int, 10], # for limited memory Hessian
'Hessian flush': [int, 999999], # no flushing
# SNOPT Frequencies Options
'Check frequency': [int, 60], # test row residuals ||Ax - sk||
'Expand frequency': [int, 10000], # for anti-cycling procedure
'Factorization frequency': [int, 50], # 100 for LPs
'Save frequency': [int, 100], # save basis map
# SNOPT LUSOL Options
'LU factor tolerance': [float, 3.99], # for NP (100.0 for LP)
'LU update tolerance': [float, 3.99], # for NP ( 10.0 for LP)
'LU singularity tolerance': [float, 3.2e-11],
# default threshold pivoting strategy
'LU partial pivoting': [type(None), None],
'LU rook pivoting': [type(None), None], # threshold rook pivoting
# threshold complete pivoting
'LU complete pivoting': [type(None), None],
# SNOPT Basis files Options
'Old basis file': [int, 0], # input basis map
'New basis file': [int, 0], # output basis map
'Backup basis file': [int, 0], # output extra basis map
'Insert file': [int, 0], # input in industry format
'Punch file': [int, 0], # output Insert data
'Load file': [int, 0], # input names and values
'Dump file': [int, 0], # output Load data
'Solution file': [int, 0], # different from printed solution
# SNOPT Partitions of cw, iw, rw Options
'Total character workspace': [int, 500], # lencw: 500
'Total integer workspace': [int, None], # leniw: 500 + 100 * (m+n)
'Total real workspace': [int, None], # lenrw: 500 + 200 * (m+n)
'User character workspace': [int, 500],
'User integer workspace': [int, 500],
'User real workspace': [int, 500],
# SNOPT Miscellaneous Options
'Debug level': [int, 0], # (0 - Normal, 1 - for developers)
'Timing level': [int, 3], # (3 - print cpu times)
}
informs = {
0: 'finished successfully',
1: 'optimality conditions satisfied',
2: 'feasible point found',
3: 'requested accuracy could not be achieved',
4: 'weak QP minimizer',
10: 'the problem appears to be infeasible',
11: 'infeasible linear constraints',
12: 'infeasible linear equalities',
13: 'nonlinear infeasibilities minimized',
14: 'infeasibilities minimized',
15: 'infeasible linear constraints in QP subproblem',
20: 'the problem appears to be unbounded',
21: 'unbounded objective',
22: 'constraint violation limit reached',
30: 'resource limit error',
31: 'iteration limit reached',
32: 'major iteration limit reached',
33: 'the superbasics limit is too small',
40: 'terminated after numerical difficulties',
41: 'current point cannot be improved',
42: 'singular basis',
43: 'cannot satisfy the general constraints',
44: 'ill-conditioned null-space basis',
50: 'error in the user-supplied functions',
51: 'incorrect objective derivatives',
52: 'incorrect constraint derivatives',
53: 'the QP Hessian is indefinite',
54: 'incorrect second derivatives',
55: 'incorrect derivatives',
60: 'undefined user-supplied functions',
61: 'undefined function at the first feasible point',
62: 'undefined function at the initial point',
63: 'unable to proceed into undefined region',
70: 'user requested termination',
71: 'terminated during function evaluation',
72: 'terminated during constraint evaluation',
73: 'terminated during objective evaluation',
74: 'terminated from monitor routine',
80: 'insufficient storage allocated',
81: 'work arrays must have at least 500 elements',
82: 'not enough character storage',
83: 'not enough integer storage',
84: 'not enough real storage',
90: 'input arguments out of range',
91: 'invalid input argument',
92: 'basis file dimensions do not match this problem',
93: 'the QP Hessian is indefinite',
100: 'finished successfully',
101: 'SPECS file read',
102: 'Jacobian structure estimated',
103: 'MPS file read',
104: 'memory requirements estimated',
105: 'user-supplied derivatives appear to be correct',
106: 'no derivatives were checked',
107: 'some SPECS keywords were not recognized',
110: 'errors while processing MPS data',
111: 'no MPS file specified',
112: 'problem-size estimates too small',
113: 'fatal error in the MPS file',
120: 'errors while estimating Jacobian structure',
121: 'cannot find Jacobian structure at given point',
130: 'fatal errors while reading the SP',
131: 'no SPECS file (iSpecs le 0 or iSpecs gt 99)',
132: 'End-of-file while looking for a BEGIN',
133: 'End-of-file while reading SPECS file',
134: 'ENDRUN found before any valid SPECS',
140: 'system error',
141: 'wrong no of basic variables',
142: 'error in basis package',
142: 'Problem dimensions are too large'
}
self.set_options = []
Optimizer.__init__(self, name, category, def_opts, informs, *args,
**kwargs)