opt.+opt
- class opt.LineOptSolverOptions
Bases:
handleLineOptSolverOptions Configuration for opt.LineOptSolver, mirroring native-Python LineOptSolver.defaultOptions(). Chained setters return self.
- Property Summary
- fdRefresh
partial_plus_fd full-FD correction period
- fdStep
- fdStepLayered
the SolverLN fixed point is smooth only above its own noise floor, which penaltyWeight amplifies by 1e6. See _kb/05-solvers-overview.md.
- Type:
Step for a differencing that RE-SOLVES a LayeredNetwork
- frozenLayers
a cell array of layer names (host or task layers) whose variables are held at the model’s current value instead of being optimized. [] freezes nothing.
- Type:
Explicit layer freezing (LQN only)
- gradientRestarts
- lqnGradient
LayeredNetwork (LQN) gradient source (used only when the model is a LayeredNetwork and the gradient path is taken):
- ‘fd’ finite-difference the whole LayeredNetwork per
parameter – correct total derivative, robust default.
- ‘partial_sens’ assemble the direction from SolverLN’s per-layer
WITHIN-LAYER partial derivatives – cheap, biased.
- ‘partial_plus_fd’ partial_sens direction, corrected by a full
LayeredNetwork finite difference every fdRefresh gradient evaluations.
- maxIterations
- mutationHigh
- mutationLow
- optimizer
- penaltyWeight
- popsize
- recombination
- scenarioAggregation
- seed
- strategy
- timeLimit
- tol
- verbose
- Method Summary
- round(v)
- setFdStep(v)
- setFdStepLayered(v)
- setFrozenLayers(v)
- setGradientRestarts(v)
- setLqnGradient(v)
- setMaxIterations(v)
- setMutation(low, high)
- setOptimizer(v)
- setPenaltyWeight(v)
- setPopsize(v)
- setRecombination(v)
- setScenarioAggregation(v)
- setSeed(v)
- setStrategy(v)
- setTimeLimit(v)
- setTolerance(v)
- setVerbose(v)
- class opt.LineOptSolver
Bases:
handleLineOptSolver Main line-opt solver. Minimizes a penalized scalar objective (constraints as penalties) over the decision variables, aggregating across scenarios, using the self-contained opt.de.DifferentialEvolution engine (numpy-exact RNG) or an analytic/FD projected-gradient path. Mirrors native-Python LineOptSolver.
- Constructor Summary
- LineOptSolver(problem, options)
- Property Summary
- bestValue
- bestX
- caches
cell of dictionary
- convergenceHistory
- deadline
- evaluators
cell of opt.LineEvaluator
- fixedValueMap
- freeVariables
cell of opt.DecisionVariable (post-freeze)
- gradCalls
- iterations
- lqnSensCache
dict valuesKey -> sensitivity dict (or [])
- opt
- problem
- scenarioWeights
- startTime
- Method Summary
- aggregateScenarios(values)
- allContinuous()
Continuous (differentiable) types, incl. the continuous LQN knobs host demand and think time.
- buildEmptyResult()
#ok<MANU>
- buildResult(x, objectiveValue, solveTime)
- deCallback(nit)
- engineBestVector(r)
- finiteDifferenceGradient(x)
Central finite-difference gradient of the penalized scalar objective. Works for any model or solver (for a LayeredNetwork each perturbed evaluation re-solves the whole ensemble, giving the correct total derivative). One-sided differences near an infeasible/unstable boundary where a two-sided value is non-finite. A layered evaluation re-solves an iterative fixed point, so the step must clear its noise floor (see fdStepLayered).
- freezeLayers(freeVars, fixed)
Partition variables by the frozenLayers option (LQN only). A variable whose layer set (DecisionVariable.getLayer) intersects the frozen set is moved from free to fixed, held at its current model parameter value (DecisionVariable.currentValue). If the current value cannot be read the variable is dropped from the optimization, leaving the model’s built-in value untouched. No-op for a flat model or when no layers are frozen.
- lqnAnalyticGradient(x)
Partial-sensitivity gradient for a LayeredNetwork ([] to fall back to the whole-model finite difference). Assembles d(objective)/dx from SolverLN’s per-layer WITHIN-LAYER service-rate derivatives, WITHOUT re-solving per parameter: (i) read d(layer metric)/d(rate) at the variable’s host-layer row, (ii) map each layer metric to the LQN node metric it approximates and take d(penalized scalar)/ d(that node metric) by cheap metric-space finite differences, (iii) chain through d(rate)/d(demand) = -1/D^2 and the linear decode. Returns [] when multi-scenario, any variable is not a host-demand variable, or the sensitivity table is unavailable. BIASED (omits cross-layer coupling); fd/partial_plus_fd correct it.
- mergeValues(values)
merge: start from fixed, overlay values
- metricFieldFor(~, kind)
property name, not the dictionary itself: a dictionary is a value type, so the perturbation must be written back through res
- objectiveFunction(x)
- objectiveGradient(x)
Gradient of the penalized objective in encoded space. For a LayeredNetwork the source is selected by lqnGradient: ‘fd’ (whole-model finite difference, robust default), ‘partial_sens’ (SolverLN per-layer partial derivatives, cheap/biased), or ‘partial_plus_fd’ (partial with a periodic full-FD correction). A flat network always finite-differences. All paths fall back to finite differences, which always work.
- projectedGradientDescent(x0)
- scalarMetricDerivative(res, allValues, kind, mkey, objective, cons, pw, h)
d(penalized scalar)/d(node metric[kind][mkey]) by central FD in metric space (pure arithmetic, no solving).
- scalarObjective(~, res, allValues, objective, cons, pw)
- shouldUseGradient()
- solve()
- solveEvolution(bounds)
- solveGradient(bounds)
- class opt.WorkflowResult
Bases:
handleWorkflowResult Result from a decomposed workflow optimization. Mirrors native-Python line_solver.opt.results.WorkflowResult.
- Constructor Summary
- WorkflowResult()
- Property Summary
- converged
- cyclesCompleted
- finalObjective
- finalVariableValues
Map name -> value
- frozenLayers
the final frozen layer set and the total LINE solve count.
- Type:
LQN layer-wise decomposition diagnostics (solveLayered)
- modelEvaluations
- objectiveHistory
- subproblemResults
Map name -> opt.SubProblemResult
- totalSolveTime
- Method Summary
- getFinalVariableValue(name)
- getSubProblemResult(name)
- isConverged()
- class opt.SubProblemResult
Bases:
handleSubProblemResult Result from solving one decomposition subproblem. Mirrors native-Python line_solver.opt.results.SubProblemResult.
- class opt.SubProblem
Bases:
handleSubProblem A subset of variables to optimize while others are fixed. Mirrors native-Python line_solver.opt.decomposition.SubProblem.
- class opt.SensitivityData
Bases:
handleSensitivityData Analytic performance sensitivities for a product-form model, mirroring native-Python compute_model_sensitivities: metric kind (‘RespT’|’QLen’|’Tput’|’Util’) -> metric key -> parameter key -> d(metric)/d(parameter). Keys are canonical strings: a metric key is ‘station’ (Util) or ‘station||class’; a parameter key is ‘rate||station||class’. Backed by nested dictionaries.
- Constructor Summary
- SensitivityData()
- Property Summary
- data
dict kind -> (dict metricKey -> (dict paramKey -> value))
- Method Summary
- add(kind, metricKey, paramKey, value)
dictionary is a value type, so each nested level is written back
- forKind(kind)
- isempty()
- static metricKey(station, jobclass)
- static paramKey(station, jobclass)
- class opt.OptimizationResult
Bases:
handleOptimizationResult Result from a single optimization run. Mirrors native-Python line_solver.opt.results.OptimizationResult.
- Constructor Summary
- OptimizationResult()
- Property Summary
- constraintViolations
Map name -> violation
- convergenceHistory
- feasible
- iterations
- modelEvaluations
- objectiveValue
- solveTime
- terminatedBy
- variableValues
Map name -> value (scalar or vector)
- Method Summary
- getConstraintViolation(name)
- getObjectiveValue()
- getTotalViolation()
- getVariableValue(name)
- isFeasible()
- class opt.MinimizeCost
Bases:
opt.ObjectiveMinimizeCost Minimize infrastructure cost subject to SLA constraints. Cost = server costs (‘name_servers’) + rate costs (variable names containing the station name and ‘rate’) + replica costs (‘name_replicas’). Mirrors native-Python MinimizeCost.
serverCost/rateCost/replicaCost are dictionaries keyed by station name (char) -> cost, or []. subjectTo is a cell array of opt.Constraint.
- class opt.MaximizePerformance
Bases:
opt.ObjectiveMaximizePerformance Maximize weighted throughput + 1/RespT + 1/QLen, subject to an optional budget constraint. Returns negated performance (DE minimizes). Mirrors native-Python MaximizePerformance.
- Constructor Summary
- MaximizePerformance(throughputWeight, responseTimeWeight, queueLengthWeight, stations, budget, budgetTerms)
- Property Summary
- queueLengthWeight
- responseTimeWeight
- stations
cell of station names, or [] = all
- throughputWeight
- Method Summary
- evaluate(result, ~)
- isMinimization(~)
- class opt.LineEvaluator
Bases:
handleLineEvaluator Interface between the optimizer and SolverAuto. Applies decision variable values to a per-evaluation model copy, solves, and extracts per-(station,class) and system metrics. Mirrors native-Python line_solver.opt.evaluator.LineEvaluator.
A copied model carries a cached NetworkStruct that scalar setters do not invalidate, so evaluateValues forces refreshStruct after applying variables.
- Constructor Summary
- LineEvaluator(model, variables, fixedVariables)
- Property Summary
- baseModel
- evaluationCount
- fixedVariables
cell of {var, value}
- isLayered
- totalDimension
- varOffsets
- variables
cell of opt.DecisionVariable
- Method Summary
- applyVariables(model, values)
- copyModel()
- decodeVariables(x)
- evaluateLayeredSensitivities(values)
Compute LQN per-layer service-rate partial sensitivities on demand: rebuild the configured model copy, solve it with SolverLN, and reshape SolverLN.getSensitivityTable into a dictionary ‘Station||JobClass’ -> struct(Tput,RespT,QLen, Util). Called only by the partial-sensitivity gradient path. Returns [] on any failure (the caller then finite-differences).
- evaluateValues(values)
- evaluateValuesWithCache(values, cache)
cache is a dictionary (value type), so the caller must take the second output back for the memoization to persist
- extractLayeredMetrics(~, avgTable, result)
Extract per-LQN-node metrics from SolverLN’s average table (one row per Processor/Task/Entry/Activity; columns Node, NodeType, QLen, Util, RespT, ResidT, ArvR, Tput). Throughput/queue-length/ response-time keyed by (node,node); utilization by node, matching the flat EvaluationResult convention. Non-finite cells skipped.
- extractLayeredSystemMetrics(~, model, result)
Derive end-to-end (system) metrics from the reference task(s): a closed LQN’s system throughput is the reference task’s throughput; its end-to-end response time is the sum of response times over the reference task’s entries. Keyed by the reference task’s name so MinimizeSystemResponseTime / SystemResponseTimeConstraint resolve without a chain concept.
- extractMetrics(~, model, QN, UN, RN, TN, result)
- extractSystemMetrics(~, solver, model, result)
- getBounds()
- getEvaluationCount()
- static valuesKey(values)
- class opt.Layered
Layered LayeredNetwork (LQN) support for line-opt. Static-method twin of native-Python line_solver.opt.layered: model-type detection, element resolution by name in a per-evaluation LQN model copy, the activity -> processor mapping used to tag host-layer variables and key the per-layer sensitivity table, and the SolverLN avg/sensitivity readers.
IMPORTANT (see SolverLN.getSensitivityTable): the per-layer table holds WITHIN-LAYER PARTIAL service-rate derivatives (fixed-point layer parameters held constant); it omits cross-layer coupling and is thus a biased estimate of the total derivative. lqnGradient=’fd’ finite- differences the whole LayeredNetwork instead (correct total derivative); ‘partial_sens’ uses this table directly; ‘partial_plus_fd’ corrects it with a periodic full-model finite difference.
- Method Summary
- static activityProcessorName(model, activityName)
Name of the processor an activity ultimately runs on ([] if the Activity -> Task -> Processor chain is incomplete). Used both to tag a HostDemand variable’s host layer and to key its host-layer sensitivity row (Layer=processor, Station=processor, JobClass=activity).
- static byName(elements, name)
First element of the cell/array ELEMENTS whose name is NAME ([]).
- static computeSensitivities(solver)
Per-(Station,JobClass) within-layer service-rate partial derivatives from SolverLN.getSensitivityTable, reshaped into a dictionary keyed ‘Station||JobClass’ -> struct with fields Tput/RespT/QLen/Util (d(metric)/d(service rate)). [] on failure.
- static distMean(value)
Mean of a think-time/demand that may be a distribution or scalar ([] if unavailable). Used by LQN variables’ currentValue.
- static elemName(element)
Name of an LQN element (Processor/Task/Entry/Activity).
- static isLayered(model)
True if MODEL is a LayeredNetwork (LQN), false for a flat Network.
- static isRefTask(task)
True if TASK is a reference (workload-generating) task.
- static makeSolver(model)
Construct a quiet SolverLN for a per-evaluation LQN model copy.
- static resolveActivity(model, name)
Resolve an Activity by name inside a (copied) LQN model.
- static resolveProcessor(model, name)
Resolve a Processor/Host by name inside a (copied) LQN model.
- static resolveTask(model, name)
Resolve a Task by name inside a (copied) LQN model.
- static solveAvg(model)
Solve an LQN and return (solver, avgTable). The table has one row per LQN node with columns Node, NodeType, QLen, Util, RespT, ResidT, ArvR, Tput.
- static taskOfActivity(model, activityName)
The Task an activity belongs to, resolved in MODEL ([] if none). Prefers the activity’s own parent handle; falls back to the task whose activity list or name matches.
- static taskProcessorName(model, taskName)
Name of the processor a task is deployed on ([] if undeployed).
- class opt.EvaluationResult
Bases:
handleEvaluationResult Metrics from evaluating a LINE model via SolverAuto. Mirrors native-Python line_solver.opt.results.EvaluationResult. Per- (station, class) metrics use a dictionary keyed by ‘station||class’; utilizations by station; system metrics by chain/class name.
- Constructor Summary
- EvaluationResult()
- Property Summary
- feasible
- queueLengths
- responseTimes
Map ‘station||class’ -> value
- sensitivities
opt.SensitivityData or []
- solveTime
- solverUsed
- systemResponseTimes
Map chain/class -> value
- systemThroughputs
- throughputs
- utilizations
Map ‘station’ -> value
- Method Summary
- aggregate(~, m, station, doMean, defaultVal)
- getQueueLength(station, jobclass)
- getResponseTime(station, jobclass)
- getSystemResponseTime(jobclass)
- getSystemThroughput(jobclass)
- getThroughput(station, jobclass)
- getUtilization(station)
- key(~, station, jobclass)
- setQueueLength(station, jobclass, v)
- setResponseTime(station, jobclass, v)
- setThroughput(station, jobclass, v)
- class opt.DecompositionWorkflow
Bases:
handleDecompositionWorkflow Decomposes a joint problem into per-variable-type subproblems solved via Gauss-Seidel cycling with fixed-value propagation. An internal topological sort orders subproblems when dependencies are set. Mirrors native-Python DecompositionWorkflow.
- Constructor Summary
- DecompositionWorkflow(problem)
- Property Summary
- DEFAULT_ORDER
Flat-network variable types first, then LayeredNetwork (LQN) types; only types present in a given problem produce subproblems.
- dependencyGraph
Map toNode -> cell of fromNodes
- problem
- solverOptions
- subproblems
- Method Summary
- addSubProblem(name, variables, after)
- autoDecompose()
- createPartialProblem(subproblem, fixedValues)
- evaluateFullObjective(variableValues)
- getExecutionOrder()
- getProblem()
- getSubProblems()
- static layerSignatures(evalResult, layers)
Representative [Util, QLen, Tput, RespT] per layer, keyed by its node. A layer named after a processor or task has a same-named node in the LQN average table; its metrics are the layer’s convergence signature. Layers without a matching node (e.g. the ‘_nolayer’ bucket) get an empty signature so they never auto-freeze.
- setDependency(fromProblem, toProblem)
- setSolverOptions(options)
- static sigDelta(a, b)
Max relative change between two layer signatures (inf if unknown).
- solveHierarchical()
- solveLayered(maxCycles, tolerance, autoFreeze, freezeTol, frozenLayers)
Solve an LQN by layer, optionally freezing converged layers. Groups decision variables by the LQN layer they perturb (host or task layer) and cycles Gauss-Seidel over the layer groups, fixing every other layer’s variables at their current values while one layer is optimized. The LQN analogue of solveSequential, but the subproblems are LAYERS rather than variable types.
Freezing has two composable sources: frozenLayers (an explicit seed set held fixed throughout) and autoFreeze (adaptive: after each cycle a layer whose representative node metrics moved less than freezeTol relative is frozen and skipped; unfrozen again if any still-active layer later moves by more than freezeTol). Convergence is on the full penalized objective delta, or when every layer is frozen. Falls back to solveSequential for a flat network. The WorkflowResult carries frozenLayers (final frozen set) and modelEvaluations (total LINE solves).
- solveSequential(maxCycles, tolerance)
- class opt.BudgetConstraint
Bases:
opt.ConstraintBudgetConstraint Budget constraint: total cost <= budget.
- class opt.BisectionSolver
Bases:
handleBisectionSolver Exact O(log n) solver for a single integer decision variable with monotone feasibility. direction=’min_feasible’ finds the smallest feasible value (server sizing); ‘max_feasible’ the largest (population sizing). Mirrors native-Python line_solver.opt.sizing.BisectionSolver.
- class opt.TaskThinkTime
Bases:
opt.DecisionVariableTaskThinkTime Optimize the think time of an LQN Task (continuous). Mirrors native-Python TaskThinkTime.
- class opt.TaskReplication
Bases:
opt.DecisionVariableTaskReplication Optimize the replication (fan-out replicas) of an LQN Task (integer). Mirrors native-Python TaskReplication.
- class opt.TaskMultiplicity
Bases:
opt.DecisionVariableTaskMultiplicity Optimize the multiplicity (thread/instance count) of an LQN Task (integer). Mirrors native-Python TaskMultiplicity.
- class opt.ProcessorMultiplicity
Bases:
opt.DecisionVariableProcessorMultiplicity Optimize the multiplicity (core count) of an LQN Processor (integer). Mirrors native-Python ProcessorMultiplicity.
- class opt.OptimizationProblem
Bases:
handleOptimizationProblem Declarative specification of a queueing-network optimization problem. Mirrors native-Python line_solver.opt.problem.OptimizationProblem.
- Constructor Summary
- OptimizationProblem(model)
- Property Summary
- FLAT_VAR_TYPES
- LQN_VAR_TYPES
Decision-variable types operating on a LayeredNetwork vs a flat one.
- constraints
cell of opt.Constraint
- fixedVariables
cell of {var, value}
- isLayeredModel
- model
- objective
- scenarios
cell of {model, weight}
- variables
cell of opt.DecisionVariable
- Method Summary
- addConstraint(constraint)
- addScenario(scenarioModel, weight)
- addVariable(variable)
- decompose()
- getConstraints()
- getFixedVariables()
- getModel()
- getObjective()
- getScenarios()
- getVariables()
- isLayered()
- isValid()
- setFixedVariables(pairs)
- setObjective(objective)
- solve(options)
- validate()
- class opt.HostDemand
Bases:
opt.DecisionVariableHostDemand Optimize the mean host demand D of an LQN Activity (continuous). The processor-layer service rate is mu = 1/D; this is the primary LQN tuning knob (analogous to ServiceRate for a flat station). Exposes the partial-sensitivity gradient hooks (sensKey/sensMetricTargets/rateJacobian/decodeJacobian). Mirrors native-Python HostDemand.
- Constructor Summary
- HostDemand(activity, bounds, name)
- Property Summary
- activity
activity name (char)
- maxDemand
- minDemand
- Method Summary
- apply(model, value)
- currentValue(model)
- decode(x)
- decodeJacobian(~)
- getActivity()
- getLayer(model)
- getVariableType()
- rateJacobian(~, value)
d(service rate)/d(demand) = d(1/D)/dD = -1/D^2 at D=value.
- sensKey(model)
Row key ‘Station||JobClass’ in the per-layer sensitivity table. Host-layer rows are (Layer=processor, Station=processor, JobClass=activity); the value is d(metric)/d(service rate).
- sensMetricTargets(model)
Map each layer-row metric to the EvaluationResult key it approximates: the host-layer row utilization tracks the processor node’s utilization (keyed by node name); its throughput/queue- length/response-time track the activity node’s (keyed ‘act||act’).
- class opt.DecisionVariable
Bases:
handleDecisionVariable Abstract base for line-opt decision variables. Mirrors native-Python line_solver.opt.variables.DecisionVariable: each variable encodes a tunable model parameter as continuous values in [0,1] (getBounds), decodes them to the native domain (decode), and applies the decoded value to a per-evaluation model copy (apply). Objects are re-resolved by name in the target model because models are copied per evaluation.
- Constructor Summary
- DecisionVariable(name)
- Property Summary
- dimension
- name
- Method Summary
- static connectionMatrix(model)
- currentValue(~, ~)
The variable’s current (decoded) value in the given model, or [] when not introspectable. Used by layer freezing to hold a variable at the model’s existing parameter value. LQN variable subclasses override this.
- getDimension()
- getLayer(~, ~)
LQN layer name(s) this variable perturbs, or {} for flat models. Consumed by layer freezing (explicit frozenLayers and adaptive auto-freeze): a variable whose layer set intersects the frozen set is held fixed. LQN variable subclasses override this.
- getName()
- static indexOfNode(nodes, nameToFind)
- static resolveClass(model, jobclass)
- static resolveNode(model, node)
- static unitBounds(dim)
- class opt.ActivityThinkTime
Bases:
opt.DecisionVariableActivityThinkTime Optimize the activity-level think time of an LQN Activity (continuous). Mirrors native-Python ActivityThinkTime.
- class opt.UtilizationConstraint
Bases:
opt.ConstraintUtilizationConstraint Utilization constraint: U <= maxValue.
- class opt.ThroughputConstraint
Bases:
opt.ConstraintThroughputConstraint Throughput constraint: Tput >= minValue.
- class opt.SystemResponseTimeConstraint
Bases:
opt.ConstraintSystemResponseTimeConstraint End-to-end response time: SysRespT <= maxValue.
- class opt.StationReplicas
Bases:
opt.DecisionVariableStationReplicas Optimize the number of identical station copies. N replicas are represented as one multiserver station with N times the base server count, keeping topology and names fixed. Mirrors native-Python StationReplicas.
- class opt.ServiceRate
Bases:
opt.DecisionVariableServiceRate Optimize the exponential processing rate of a station for a job class. Continuous (differentiable): exposes paramKey/decodeJacobian for the analytic-gradient path. Mirrors native-Python ServiceRate.
- class opt.ServerAllocation
Bases:
opt.DecisionVariableServerAllocation Optimize the number of servers at a station. Encodes an integer server count in [minServers, maxServers]. Mirrors native-Python ServerAllocation.
- class opt.RoutingProbabilities
Bases:
opt.DecisionVariableRoutingProbabilities Optimize routing of a job class from a source node to target nodes. Stick-breaking encoding (dim = targets-1). On apply, default routing is rebuilt from the connection matrix for every class, then the overridden (class, source) row is set to the decoded probabilities. Mirrors native-Python RoutingProbabilities.
- Constructor Summary
- RoutingProbabilities(jobclass, source, targets, name)
- Property Summary
- jobclass
- source
- targets
cell array of Node
- Method Summary
- apply(model, value)
Override only the source node’s outgoing routing for this class, via setProbRouting, leaving all other routes intact. This is the MATLAB idiom that works whether the model was built with link() or addLink() (model.link() is rejected after addLink()).
- decode(x)
- getJobClass()
- getSource()
- getTargets()
- getVariableType()
- class opt.ResponseTimeConstraint
Bases:
opt.ConstraintResponseTimeConstraint Per-station response time constraint: RT <= maxValue.
- class opt.ParetoSweep
Bases:
handleParetoSweep Epsilon-constraint sweep for bi-objective tradeoff analysis. Solves the problem once per epsilon, each time adding constraintFactory(epsilon), and filters to the non-dominated cost frontier. Mirrors native-Python ParetoSweep.
constraintFactory is a function handle mapping an epsilon to an opt.Constraint. solver is ‘de’ (default) or ‘bisection’.
- class opt.ParetoPoint
Bases:
handleParetoPoint One point of a cost-performance tradeoff curve produced by opt.ParetoSweep. Mirrors native-Python ParetoPoint.
- class opt.Objective
Bases:
handleObjective Abstract base for line-opt objectives. Mirrors native-Python line_solver.opt.objectives.Objective: defines the scalar to minimize, with attached constraints folded in as penalties by evaluateWithPenalty.
- class opt.MinimizeSystemResponseTime
Bases:
opt.ObjectiveMinimizeSystemResponseTime Minimize end-to-end (system) response time. Mirrors native-Python MinimizeSystemResponseTime.
- class opt.JobPopulation
Bases:
opt.DecisionVariableJobPopulation Optimize the fixed circulating population of a closed class. Encodes an integer count in [minJobs, maxJobs]. Mirrors native-Python JobPopulation.
- class opt.Constraint
Bases:
handleConstraint Abstract base for line-opt constraints. Each computes a non-negative violation (0 if satisfied). Mirrors native-Python line_solver.opt.objectives.Constraint.
- class opt.ClassServiceMapping
Bases:
opt.DecisionVariableClassServiceMapping Optimize the class-to-station mapping by rerouting a job class through a selected candidate station and bypassing the others, preserving default routing of every other class. Mirrors native-Python ClassServiceMapping.
- class opt.ClassPriority
Bases:
opt.DecisionVariableClassPriority Optimize the priority of job classes. In ‘levels’ mode each class gets an integer priority in [minPriority, maxPriority] (one dim per class); in ‘permutation’ mode encoded keys induce a priority ordering (n-1 dims). Mirrors native-Python ClassPriority.