VeraGridEngine.Utils.MIP package

Subpackages

• VeraGridEngine.Utils.MIP.SimpleMip package
  • Submodules
  • VeraGridEngine.Utils.MIP.SimpleMip.highs module
    • solve_with_highs()
  • VeraGridEngine.Utils.MIP.SimpleMip.lpmodel module
    • LpModel
      • LpModel.INFINITY
      • LpModel.OPTIMAL
      • LpModel.add_cst()
      • LpModel.add_int()
      • LpModel.add_var()
      • LpModel.add_vars()
      • LpModel.constraints
      • LpModel.copy()
      • LpModel.fobj_value()
      • LpModel.get_array_value()
      • LpModel.get_coefficients_data()
      • LpModel.get_dual_value()
      • LpModel.get_obj_coefficient()
      • LpModel.get_objective_value()
      • LpModel.get_value()
      • LpModel.get_var_data()
      • LpModel.is_minimize()
      • LpModel.is_mip()
      • LpModel.is_optimal()
      • LpModel.logger
      • LpModel.maximize()
      • LpModel.minimize()
      • LpModel.objective
      • LpModel.originally_infeasible
      • LpModel.print_solution()
      • LpModel.relaxed_slacks
      • LpModel.save_model()
      • LpModel.save_model_to_lp()
      • LpModel.save_model_to_mps()
      • LpModel.set_solution()
      • LpModel.solution_available()
      • LpModel.solve()
      • LpModel.solver_type
      • LpModel.status2string()
      • LpModel.sum()
      • LpModel.variables
    • get_available_mip_solvers()
    • set_var_bounds()
  • VeraGridEngine.Utils.MIP.SimpleMip.lpobjects module
    • LpCst
      • LpCst.add_term()
      • LpCst.add_var()
      • LpCst.coefficient
      • LpCst.copy()
      • LpCst.get_bounds()
      • LpCst.get_index()
      • LpCst.get_rhs()
      • LpCst.linear_expression
      • LpCst.name
      • LpCst.sense
      • LpCst.set_index()
      • LpCst.terms
    • LpExp
      • LpExp.copy()
      • LpExp.offset
      • LpExp.terms
    • LpVar
      • LpVar.copy()
      • LpVar.get_index()
      • LpVar.is_integer
      • LpVar.lower_bound
      • LpVar.name
      • LpVar.set_index()
      • LpVar.upper_bound
  • Module contents

Submodules

VeraGridEngine.Utils.MIP.gslv_interface module

VeraGridEngine.Utils.MIP.mip_interface_template module

This module abstracts the synthax of PuLP out so that in the future it can be exchanged with some other solver interface easily

class VeraGridEngine.Utils.MIP.mip_interface_template.AbstractLpModel(solver_type: MIPSolvers, name: str)

Bases: ABC

Abstract base class for LP/MIP models.

INFINITY: float = 1e+20

OPTIMAL: Any

abstractmethod add_bin(name: str = '') → Any

add binary variable.

abstractmethod add_cst(cst: Any, name: str = '') → Any

Add a constraint.

abstractmethod add_int(lb: int, ub: int, name: str = '') → Any

Add an integer variable.

abstractmethod add_var(lb: float, ub: float, name: str = '') → Any

Add a continuous variable.

abstractmethod fobj_value() → float

Get the objective value.

abstractmethod static get_dual_value(x: Any) → float

Return the dual value of a constraint.

abstractmethod static get_value(x: Any) → float

Return the numerical value of a variable/expression.

abstractmethod is_mip() → bool

Return True if model has integer variables.

logger

abstractmethod minimize(obj_function: Any)

Define minimization objective.

abstractmethod model_as_string() → str

Return model string representation (LP)

name

originally_infeasible: bool

relaxed_slacks: List[Tuple[int, Any, float]]

abstractmethod save_model(file_name: str)

Export the model to LP/MPS for debugging.

abstractmethod static set_var_bounds(var: Any, lb: float, ub: float)

Modify variable bounds.

abstractmethod solve(robust: bool = False, show_logs: bool = False, progress_text: Callable[[str], None] | None = None) → int

Solve the optimization problem.

solver_type

abstractmethod status2string(stat: Any) → str

Convert solver status to readable string.

abstractmethod static sum(exprs: Iterable) → Any

Sum of expressions.

VeraGridEngine.Utils.MIP.ortools_interface module

VeraGridEngine.Utils.MIP.pulp_interface module

This module abstracts the synthax of PuLP out so that in the future it can be exchanged with some other solver interface easily

class VeraGridEngine.Utils.MIP.pulp_interface.PulpLpModel(solver_type: MIPSolvers)

Bases: AbstractLpModel

LPModel implementation for PuLP

INFINITY: float = 1e+20

OPTIMAL: Any = 1

add_bin(name: str = '') → LpVariable

Make integer LP var :param name: name (optional) :return: LpVar

add_cst(cst: LpConstraint | bool, name: str = '') → LpConstraint | int

Add constraint to the model :param cst: constraint object (or general expression) :param name: name of the constraint (optional) :return: Constraint object

add_int(lb: int, ub: int, name: str = '') → LpVariable

Make integer LP var :param lb: lower bound :param ub: upper bound :param name: name (optional) :return: LpVar

add_var(lb: float, ub: float, name: str = '') → LpVariable

Make floating point LP var :param lb: lower bound :param ub: upper bound :param name: name (optional) :return: LpVar

fobj_value() → float

Get the objective function value :return:

static get_dual_value(x: LpConstraint) → float

Get the dual value of a variable stored in a numpy array of objects :param x: constraint :return: result or zero

get_solver(show_logs: bool = False)

Parameters:

show_logs

Returns:

static get_value(x: float | int | LpVariable | LpAffineExpression | LpConstraint | Any) → float

Get the value of a variable stored in a numpy array of objects :param x: solver object (it may be a LP var or a number) :return: result or zero

is_mip()

Is this odel a MIP? :return:

minimize(obj_function: LpAffineExpression)

Set the objective function with minimization sense :param obj_function: expression to minimize

model

model_as_string() → str

Return the LP representation :return: string

save_model(file_name: str = 'ntc_opf_problem.lp') → None

Save problem in LP format :param file_name: name of the file (.lp or .mps supported)

static set_var_bounds(var: LpVariable, lb: float, ub: float)

Modify the bounds of a variable :param var: LpVar instance to modify :param lb: lower bound value :param ub: upper bound value

solve(robust: bool = False, show_logs: bool = False, progress_text: Callable[[str], None] | None = None) → int

Solve the model :param robust: In this interface, this is useless :param show_logs: In this interface, this is useless :param progress_text: progress function pointer :return:

status2string(stat: int) → str

Convert the PuLP status to a string :param stat: :return:

static sum(cst) → LpAffineExpression

Add sum of the constraints to the model :param cst: constraint object (or general expression) :return: Constraint object

VeraGridEngine.Utils.MIP.pulp_interface.get_lp_var_value(x: float | LpVariable) → float

Get the value of a variable stored in a numpy array of objects :param x: soe object (it may be a LP var or a number) :return: result or previous numeric value

VeraGridEngine.Utils.MIP.pulp_interface.get_pulp_available_mip_solvers() → List[str]

Get a list of candidate solvers :return:

VeraGridEngine.Utils.MIP.selected_interface module

Uncomment the appropriate interface imports to use: Pulp or OrTools

VeraGridEngine.Utils.MIP.selected_interface.get_available_mip_frameworks() → List[MIPFramework]

Get list of available frameworks :return: List[MIPFramework]

VeraGridEngine.Utils.MIP.selected_interface.get_available_mip_solvers(tpe: MIPFramework) → List[str]

Get the solvers available in the selected interface :param tpe: :return:

VeraGridEngine.Utils.MIP.selected_interface.get_model_instance(tpe: MIPFramework, solver_type: MIPSolvers) → PulpLpModel | None

Get an instance of the solver framework and the selected solver :param tpe: MIPInterface framework :param solver_type: MIPSolvers :return: OrToolsLpModel or PulpLpModel

VeraGridEngine.Utils.MIP.selected_interface.join(init: str, vals: List[int], sep='_')

Generate naming string :param init: initial string :param vals: concatenation of indices :param sep: separator :return: naming string

VeraGridEngine.Utils.MIP.selected_interface.lpDot(mat: csc_matrix, arr: ndarray[tuple[Any, ...], dtype[object_]]) → ndarray[tuple[Any, ...], dtype[object_]]

CSC matrix-vector or CSC matrix-matrix dot product (A x b) :param mat: CSC sparse matrix (A) :param arr: dense vector or matrix of object type (b) :return: vector or matrix result of the product

VeraGridEngine.Utils.MIP.selected_interface.lpDot1D_changes(mat: csc_matrix, arr: ndarray[tuple[Any, ...], dtype[object_]]) → Tuple[ndarray[tuple[Any, ...], dtype[object_]], List[int]]

CSC matrix-vector or CSC matrix-matrix dot product (A x b) :param mat: CSC sparse matrix (A) :param arr: dense vector or matrix of object type (b) :return: vector or matrix result of the product

Module contents