scipplan 0.1.0a0__py2.py3-none-any.whl

scipplan/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0alpha0"
+print(f"SCIPPlan Version: {__version__}")
+__release__ = "v0.1.0"
+__author__ = "Ari Gestetner, Buser Say"
+__email__ = "ages0001@student.monash.edu, buser.say@monash.edu"

scipplan/config.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from textwrap import dedent
+import argparse
+
+@dataclass
+class Config:
+    """
+    The Config class provides an interface to set the configuration for SCIPPlan. 
+    Config can be set by creating an instance of the class adding the variables desired. 
+    Alternatively, the `get_config` class method will return a config instance using variables set by the programs args (e.g. -D 'domain').
+    """
+    domain: str
+    instance: int
+    horizon: int = field(default=None)
+    epsilon: float = field(default=None)
+    gap: float = field(default=None)
+    show_output: bool = False
+    save_sols: bool = False
+    bigM: float = 1000.0
+    dt_var: str = "Dt"
+    _defaults: dict[str, bool] = field(default_factory=dict, repr=False)
+    
+    def __post_init__(self) -> None:
+        # Set all defaults to False and if the value is None then it will be updated to true
+        self._defaults = {
+            "domain": False,
+            "instance": False,
+            "horizon": False,
+            "epsilon": False,
+            "gap": False
+        }
+        if self.horizon is None:
+            print("Horizon is not provided, and is set to 1")
+            self.horizon = 1
+            self._defaults["horizon"] = True
+            
+        if self.epsilon is None:
+            print("Epsilon is not provided, and is set to 0.1")
+            self.epsilon = 0.1
+            self._defaults["epsilon"] = True
+            
+        if self.gap is None:
+            print("Gap is not provided, and is set to 10.0%")
+            self.gap = 0.1
+            self._defaults["gap"] = True
+            
+    def __str__(self) -> str:
+        text = f"""
+        Configuration:
+        
+        Display SCIP Output: {self.show_output}
+        Save Solutions: {self.show_output}
+        Dt Variable Name: {self.dt_var}
+        
+        Domain (str): {self.domain}
+        Instance (int): {self.instance}
+        Horizon (int): {self.horizon} {'(default)' if self._defaults['horizon'] is True else ''}
+        Epsilon (float): {self.epsilon} {'(default)' if self._defaults['epsilon'] is True else ''}
+        Gap (float): {self.gap * 100}% {'(default)' if self._defaults['gap'] is True else ''}
+        BigM (float): {self.bigM}
+        """
+        return dedent(text)
+    
+    def increment_horizon(self, value: int = 1):
+        self._defaults["horizon"] = False
+        self.horizon += value
+        
+    
+    @classmethod
+    def get_config(cls) -> Config:
+        parser = argparse.ArgumentParser(
+            prog="SCIPPlan"
+        )
+        parser.add_argument(
+            "-D", 
+            "--domain", 
+            required=True,
+            type=str,
+            help="This variable is the name of the domain (e.g. pandemic or navigation)"
+        )
+        parser.add_argument(
+            "-I", 
+            "--instance", 
+            required=True,
+            type=int,
+            help="This is the instance number of the domain (e.g. navigation has instances 1, 2 and 3)"
+        )
+        parser.add_argument(
+            "-H", 
+            "--horizon", 
+            required=False,
+            # default=1,
+            type=int,
+            help="The initial horizon. The solve method will initially begin with this horizon until it finds a feasible solution"
+        )
+        parser.add_argument(
+            "-E", 
+            "--epsilon", 
+            required=False,
+            # default=0.1,
+            type=float,
+            help="SCIPPlan iteratively checks solution for violations at each epsilon value"
+        )
+        parser.add_argument(
+            "-G", 
+            "--gap", 
+            required=False,
+            # default=0.1,
+            type=float,
+            help="SCIP will search for solution with an optimality gap by at least this value"
+        )
+        
+        parser.add_argument(
+            "--bigM", 
+            required=False,
+            default=1000.0,
+            type=float,
+            help="A large value which is used for some constraint encoding formulations, defaults to 1000.0 and can be changed as needed"
+        )
+        
+        parser.add_argument(
+            "--dt-var", 
+            required=False,
+            default="Dt",
+            type=str,
+            help="When writing the constraints, dt_var is the variable name for Dt, defaults to 'Dt' and can be changed based on users preference (e.g. 'dt')"
+        )
+        
+        parser.add_argument(
+            "--show-output", 
+            action="store_true", 
+            default=False, 
+            help="Include this flag to show output from SCIP"
+        )
+        
+        parser.add_argument(
+            "--save-sols", 
+            action="store_true", 
+            default=False, 
+            help="Include this flag to save the solutions from each of the scipplan iterations as well as constraints generated (note, only saves for horizon which has been solved)"
+        )
+        
+        args = parser.parse_args()
+        
+        return Config(**vars(args))
+    
+    
+if __name__ == "__main__":
+    
+    print(Config.get_config())

scipplan/helpers.py

@@ -0,0 +1,30 @@
+import os
+import csv
+
+from typing import Generator
+from .config import Config
+
+class InfeasibilityError(Exception):
+    """Raise this error when there are no valid solutions for the given horizon"""
+
+def iterate(start: float, stop: float, step: float = 1) -> Generator[float, None, None]:
+    n = start
+    while n <= stop:
+        yield n
+        n += step
+        
+        
+def list_accessible_files(directory):
+    try:
+        files = os.listdir(directory)
+        return files
+    except FileNotFoundError:
+        return []  # Return an empty list if the directory doesn't exist
+
+def write_to_csv(file_name: str, data: list[dict], config: Config) -> None:
+    with open(f"{file_name}_{config.domain}_{config.instance}.csv", 'w', encoding='utf8', newline='') as output_file:
+            fc = csv.DictWriter(output_file, 
+                                fieldnames=data[0].keys(),
+                            )
+            fc.writeheader()
+            fc.writerows(data)

scipplan/parse_model.py

@@ -0,0 +1,275 @@
+import ast
+import operator as op
+from typing import Union
+
+from .variables import Variable
+
+from dataclasses import dataclass, field
+from enum import Enum
+from math import exp, log, sqrt, sin, cos, isclose
+
+from pyscipopt.scip import Model, SumExpr
+
+def switch_comparator(comparator):
+    if isinstance(comparator, ast.Eq): return ast.NotEq()
+    if isinstance(comparator, ast.NotEq): return ast.Eq()
+    if isinstance(comparator, ast.Lt): return ast.Gt()
+    if isinstance(comparator, ast.LtE): return ast.GtE()
+    if isinstance(comparator, ast.Gt): return ast.Lt()
+    if isinstance(comparator, ast.GtE): return ast.LtE()
+
+@dataclass
+class Expressions:
+    expr_str: str
+    horizon: int
+    expressions: list
+    aux_vars: list
+    
+    def add_expressions(self, *expressions):
+        for expression in expressions:
+            self.expressions.append(expression)
+    def __len__(self) -> int:
+        return len(self.expressions)
+    def __iter__(self):
+        for expr in self.expressions:
+            yield expr
+
+
+class ParserType(Enum):
+    """ParserType
+    "enum type CALCULATOR: Used to calculate using feastol
+    "enum type PARSER: Used to parse an expression and create the correct minlp constraints
+    """
+    CALCULATOR = "calculator"
+    PARSER = "parser"
+
+
+@dataclass
+class EvalParams:
+    variables: dict = field(default_factory={})
+    functions: dict = field(default_factory={})
+    operators: dict = field(default_factory={})
+    parser_type: ParserType = ParserType.PARSER
+    rounds_vars: bool = False
+    model: Union[Model, None] = None
+    add_aux_vars: bool = False
+    
+    @classmethod
+    def as_calculator(cls, variables: dict, functions: dict, operators: dict, model: Model, add_aux_vars: bool = False):
+        return EvalParams(variables, functions, operators, ParserType.CALCULATOR, False, model, add_aux_vars)
+    @classmethod
+    def as_parser(cls, variables: dict, functions: dict, operators: dict, model: Model, add_aux_vars: bool = False):
+        return EvalParams(variables, functions, operators, ParserType.PARSER, True, model, add_aux_vars)
+
+
+class ParseModel:
+    
+    def __init__(self, eval_params: EvalParams):
+        self.params = eval_params
+        self.variables = eval_params.variables
+        self.functions = eval_params.functions
+        
+        self.model_feastol = eval_params.model.feastol()
+        self.variables["feastol"] = self.model_feastol
+        
+        # Calculate operators (use evaluate operators for non calculations)
+        feastol = self.model_feastol if eval_params.parser_type is ParserType.CALCULATOR else 0
+        self.operators = {
+            ast.Add: op.add,
+            ast.Sub: op.sub,
+            ast.Mult: op.mul,
+            ast.Div: op.truediv,
+            ast.Pow: op.pow,
+            
+            ast.UAdd: op.pos,
+            ast.USub: op.neg,
+            
+            ast.Not: op.not_,
+            ast.Eq: lambda x, y: op.eq(x, y) if self.params.parser_type is ParserType.PARSER else isclose(x, y, rel_tol=feastol),
+            # ast.Eq: op.eq,
+            ast.NotEq: lambda x, y: op.ne(x, y) if self.params.parser_type is ParserType.PARSER else not isclose(x, y, rel_tol=feastol),
+            # ast.NotEq: op.ne,
+            ast.Lt: lambda x, y: op.lt(x, y + feastol),
+            ast.LtE: lambda x, y: op.le(x, y + feastol),
+            ast.Gt: lambda x, y: op.gt(x + feastol, y),
+            ast.GtE: lambda x, y: op.ge(x + feastol, y),
+        } | eval_params.operators
+        
+        self.expressions = Expressions("", -1, [], [])
+            
+        
+    def evaluate(self, eqtn, aux_vars: Union[list, None] = None, expr_name: Union[str, None] = None, horizon: int = -1):
+        
+        if isinstance(eqtn, str):
+            # Reset self.expressions for every new equation evaluated
+            self.expressions = Expressions(
+                "" if expr_name is None else expr_name, 
+                horizon,
+                [], 
+                [] if aux_vars is None else aux_vars
+            )
+            
+            return self.evaluate(ast.parse(eqtn))
+        
+        if isinstance(eqtn, ast.Module):
+            self.expressions.add_expressions(*(self.evaluate(expr) for expr in eqtn.body))
+            return self.expressions
+        
+        if isinstance(eqtn, ast.Expr):
+            return self.evaluate(eqtn.value)
+  
+        if isinstance(eqtn, ast.BoolOp):
+            # And expressions are decomposed into their individual segments and evaluated separately
+            if isinstance(eqtn.op, ast.And):
+                # Evaluate and add all expressions except the first to the expressions object
+                self.expressions.add_expressions(*(self.evaluate(expr) for expr in eqtn.values[1:]))
+                # Evaluate and return the first expression 
+                return self.evaluate(eqtn.values[0])
+            
+            if isinstance(eqtn.op, ast.Or):
+                if self.params.parser_type is ParserType.CALCULATOR:
+                    results = [self.evaluate(expr) for expr in eqtn.values]
+                    return any(results)
+                else:
+                    aux_vars = self.expressions.aux_vars
+                    if self.params.add_aux_vars is True and len(aux_vars) > 0:
+                        raise Exception("aux_vars should be empty to add new aux vars")
+                    
+                    for idx, expr in enumerate(eqtn.values):
+                        if isinstance(expr, ast.Compare):
+                        
+                            if self.params.add_aux_vars is True:
+                                aux_var = Variable.create_var(
+                                    model=self.params.model, 
+                                    name=f"Aux_{idx}_{self.expressions.expr_str}",
+                                    vtype="auxiliary_boolean",
+                                    time=self.expressions.horizon,
+                                    const_vals={}
+                                )
+                            else:
+                                aux_var: Variable = self.expressions.aux_vars[idx]
+                    
+                            aux_vars.append(aux_var)
+                            self.variables[aux_var.name] = aux_var.model_var
+                            
+                            expr.left = ast.BinOp(
+                                left=expr.left, 
+                                op=(ast.Add() if isinstance(expr.ops[0], (ast.Gt, ast.GtE)) else ast.Sub()), 
+                                right=ast.parse(f"bigM * {aux_var.name}").body[0].value
+                            )
+                            self.expressions.add_expressions(self.evaluate(expr))
+                            
+                            expr.ops[0] = switch_comparator(expr.ops[0])
+                            
+                            expr.comparators[0] = ast.BinOp(
+                                left=expr.comparators[0], 
+                                op=(ast.Add() if isinstance(expr.ops[0], (ast.Gt, ast.GtE)) else ast.Sub()), 
+                                right=ast.parse(f"feastol - bigM").body[0].value
+                            )
+                            
+                            self.expressions.add_expressions(self.evaluate(expr))
+                        else:
+                            raise Exception("or expressions may only be made up of inequalities")
+                    lhs = SumExpr()
+                    for var in aux_vars:
+                        lhs += var.model_var
+                    return lhs <= len(aux_vars) - 1
+                    
+        if isinstance(eqtn, ast.IfExp):
+            raise Exception("Can't use if else")
+            
+        if isinstance(eqtn, ast.Compare):
+            if len(eqtn.comparators) != 1:
+                raise Exception("Too many comparator operators, please don't use more than 1 per equation")
+            
+            left = self.evaluate(eqtn.left)
+            right = self.evaluate(eqtn.comparators[0])
+            comp_type = type(eqtn.ops[0])
+            comparator = self.operators[comp_type]
+            
+            return comparator(left, right)
+            
+        if isinstance(eqtn, ast.Name):
+            return self.variables[eqtn.id]
+        
+        if isinstance(eqtn, ast.BinOp):
+            left = self.evaluate(eqtn.left)
+            right = self.evaluate(eqtn.right)
+            operator = type(eqtn.op)
+            return self.operators[operator](left, right)
+        
+        if isinstance(eqtn, ast.Call):
+            if not isinstance(eqtn.func, ast.Name):
+                raise Exception("Attributes such as main.secondary() functions are not allowed")
+            
+            func_name = eqtn.func.id
+            args = (self.evaluate(arg) for arg in eqtn.args)
+            func = self.functions[func_name]
+            return func(*args)
+        
+        if isinstance(eqtn, ast.Constant):
+            return eqtn.value
+        
+        if isinstance(eqtn, ast.UnaryOp):
+            op_type = type(eqtn.op)
+            operator = self.operators[op_type]
+            return operator(self.evaluate(eqtn.operand))
+        
+        raise Exception("Unknown ast type")
+
+
+functions = {
+    'exp': exp, 
+    'log': log, 
+    'sqrt': sqrt, 
+    'sin': sin, 
+    'cos': cos,
+}
+variables = {
+    'c': 0.15, 
+    'Removed': 634.9055920077616, 
+    'Removed_dash': 1811.3128718631383, 
+    'b2': 0.1, 
+    'Makespan': 180.0, 
+    'Susceptible': 1218.7473517769768, 
+    'Susceptible_dash': 87.1003300803328, 
+    'DurationMax': 90.0, 
+    'N': 2000.0, 
+    'Dt': 0.0, 
+    'Infected': 146.34705621526638, 
+    'Infected_dash': 101.58679805652946, 
+    'TotalTime': 90.87927389935685, 
+    'TotalTime_dash': 136.34829117841537, 
+    'b': 0.19999999999999973, 
+    'Epsilon': 1.0, 
+    'Percentage': 0.8, 
+    'DurationMin': 30.0, 
+    'b1': 0.2, 
+    'Duration': 100.0, 
+    'D': 150.0, 
+    'InitialInfected': 50.0, 
+    'Lockdown': 0.0
+}
+
+constraint = "Infected * exp((b / (b - c)) * log(1 + (Infected / Susceptible))) * exp(-1.0 * (b / (b - c)) * log(1 + (Infected / Susceptible) * exp((b - c) * Dt))) * exp((b - c) * Dt) <= D"
+
+
+
+if __name__ == "__main__":
+    params = EvalParams.as_calculator(variables, functions, {})
+    calc = ParseModel(params).evaluate
+    
+    print(calc(constraint))
+    eqtns = """
+1 + 2
+1 + 5 < 5    
+"""
+    print(calc(eqtns))
+#     print(calc(
+# """
+# a >= b if a + b + c >= 5 else a - b - c == 10
+# """))
+#     print(calc(
+# """
+# a + b + c >= 5 or a - b - c == 10
+# """))