scipplan 0.1.0a1__tar.gz → 0.1.1a0__tar.gz

{scipplan-0.1.0a1/scipplan.egg-info → scipplan-0.1.1a0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: scipplan
-Version: 0.1.0a1
+Version: 0.1.1a0
 Summary: Metric Hybrid Factored Planning in Nonlinear Domains with Constraint Generation in Python.
 Author: Ari Gestetner, Buser Say
-Author-email: ages0001@student.monash.edu, buser.say@monash.edu
+Author-email: ari.gestetner@monash.edu, buser.say@monash.edu
 License: MIT License
 Keywords: scip,automated planner
 Classifier: Development Status :: 3 - Alpha
@@ -121,13 +121,17 @@ state_continuous: Location_x
 state_continuous: Location_y
 state_continuous: Speed_x
 state_continuous: Speed_y
+global_boolean: aux_1
 ```
-where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - sign like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
+where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - symbol like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
 Additionally a variable for Dt has to be defined and has to be the same as the dt_var in the config object so if you would like to use a different variable name for Dt (e.g. dt) please also ensure you add it to the config via the `--dt-var` tag or the `dt_var` parameter.  
+The variable type `global` is used when you would like a non state variable to be equal over every time step over the horizon (e.g. if $v_t$ is a variable at time $t$ and $H$ is the horizon, then $v_1 = v_2 = \dots = v_{H+1}$).  
+
 The available variable types are
 - state
 - action
 - auxiliary
+- global
 
 The available value types are 
 - continuos
@@ -144,7 +148,7 @@ Location_y == 0.0
 Speed_x == 0.0
 Speed_y == 0.0
 ```
-notice te use of teh constant value defined earlier in the constants file.
+notice the use of the constant value defined earlier in the constants file.
 ### Goals
 The goals file should encode the final state values such that t=H+1, for example
 ```txt

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/README.md

@@ -102,13 +102,17 @@ state_continuous: Location_x
 state_continuous: Location_y
 state_continuous: Speed_x
 state_continuous: Speed_y
+global_boolean: aux_1
 ```
-where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - sign like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
+where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - symbol like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
 Additionally a variable for Dt has to be defined and has to be the same as the dt_var in the config object so if you would like to use a different variable name for Dt (e.g. dt) please also ensure you add it to the config via the `--dt-var` tag or the `dt_var` parameter.  
+The variable type `global` is used when you would like a non state variable to be equal over every time step over the horizon (e.g. if $v_t$ is a variable at time $t$ and $H$ is the horizon, then $v_1 = v_2 = \dots = v_{H+1}$).  
+
 The available variable types are
 - state
 - action
 - auxiliary
+- global
 
 The available value types are 
 - continuos
@@ -125,7 +129,7 @@ Location_y == 0.0
 Speed_x == 0.0
 Speed_y == 0.0
 ```
-notice te use of teh constant value defined earlier in the constants file.
+notice the use of the constant value defined earlier in the constants file.
 ### Goals
 The goals file should encode the final state values such that t=H+1, for example
 ```txt

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/scipplan/__init__.py

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

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/scipplan/config.py

@@ -32,17 +32,17 @@ class Config:
             "gap": False
         }
         if self.horizon is None:
-            print("Horizon is not provided, and is set to 1")
+            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")
+            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%")
+            print("Gap is not provided, and is set to 10.0%. ")
             self.gap = 0.1
             self._defaults["gap"] = True
             
@@ -64,9 +64,11 @@ class Config:
         return dedent(text)
     
     def increment_horizon(self, value: int = 1):
-        self._defaults["horizon"] = False
+        # self._defaults["horizon"] = False
         self.horizon += value
         
+    def get_defaults(self) -> dict[str, bool]:
+        return self._defaults
     
     @classmethod
     def get_config(cls) -> Config:

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/scipplan/parse_model.py

@@ -10,13 +10,68 @@ 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()
+
+def linearise(expr: ast.Compare, aux_var: Variable) -> tuple[ast.Compare, ast.Compare]:
+    """linearise
+    This function linearises an inequality using an auxilary variable
+    
+    The linearisation process is as follows.
+    If the expression is of the form of E1 <= E2, then we linearise by using the following expressions.
+    z=0 ==> E1 <= E2 and z=1 ==> E1 > E2 (equivalent to E1 >= E2 + feastol). This is then equivalent to,
+    E2 + feastol - M + z*M <= E1 <= E2 + zM.
+    
+    Similarly, for E1 < E2 we have z=0 ==> E1 < E2 which is equivalent to E1 <= E2 - feastol + z*M 
+    and z=1 ==> E1 >= E2.
+    Thus for E1 < E2 we have,
+    E2 + z*M - M <= E1 <= E2 + z*M - feastol.
+    
+    If, however, the inequality is of the form of E1 >= E2 then we evaluate the expression, E2 <= E1.
+    Similarly, if the expression is E1 > E2 then we evaluate the expression E2 < E1.
+    
+    :param expr: An inequality expression which is linearised.
+    :type expr: ast.Compare
+    :param aux_var: An auxiliary variable used when linearising the inequality to determine if the expression is true or false.
+    :type aux_var: Variable
+    :raises ValueError: If expr is not a valid inequality (i.e. doesn't use <, <=, > and >=)
+    :return: both the linearised inequalities
+    :rtype: tuple[ast.Compare, ast.Compare]
+    """
+    if not isinstance(expr.ops[0], (ast.Lt, ast.LtE, ast.Gt, ast.GtE)):
+        raise ValueError("Only <, <=, > or >= are allowed")
+    if isinstance(expr.ops[0], ast.GtE):
+        expr.left, expr.comparators[0] = expr.comparators[0], expr.left
+        expr.ops[0] = ast.LtE()
+    if isinstance(expr.ops[0], ast.Gt):
+        expr.left, expr.comparators[0] = expr.comparators[0], expr.left
+        expr.ops[0] = ast.Lt()
+    
+    if isinstance(expr.ops[0], ast.LtE):
+        lhs = ast.BinOp(
+            left=expr.comparators[0], 
+            op=ast.Add(), 
+            right=ast.parse(f"feastol - bigM + {aux_var.name} * bigM").body[0].value
+        )
+        rhs = ast.BinOp(
+            left=expr.comparators[0], 
+            op=ast.Add(), 
+            right=ast.parse(f"{aux_var.name} * bigM").body[0].value
+        )
+    if isinstance(expr.ops[0], ast.Lt):
+        lhs = ast.BinOp(
+            left=expr.comparators[0], 
+            op=ast.Add(), 
+            right=ast.parse(f"{aux_var.name} * bigM - bigM").body[0].value
+        )
+        rhs = ast.BinOp(
+            left=expr.comparators[0], 
+            op=ast.Add(), 
+            right=ast.parse(f"{aux_var.name} * bigM - feastol").body[0].value
+        )
+    expr1 = ast.Compare(lhs, [ast.LtE()], [expr.left])
+    expr2 = ast.Compare(expr.left, [ast.LtE()], [rhs])
+    return expr1, expr2
+    
+
 
 @dataclass
 class Expressions:
@@ -37,8 +92,8 @@ class Expressions:
 
 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
+    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"
@@ -152,22 +207,11 @@ class ParseModel:
                             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))
+                            expr1, expr2 = linearise(expr, aux_var)
                             
-                            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))
+                            self.expressions.add_expressions(self.evaluate(expr1))
+                            self.expressions.add_expressions(self.evaluate(expr2))
+
                         else:
                             raise Exception("or expressions may only be made up of inequalities")
                     lhs = SumExpr()

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/scipplan/plan_model.py

@@ -95,12 +95,17 @@ class PlanModel:
                 
                 self.var_names.add(name)
                 
-                for t in range(self.config.horizon):
-                    variables[(name, t)] = Variable.create_var(self.model, name, vtype, t, self.constants)
-                    var_type = variables[(name, t)].var_type
-                if var_type is VarType.STATE:
-                    variables[(name, self.config.horizon)] = Variable.create_var(self.model, name, vtype, self.config.horizon, self.constants)
-                    
+                if vtype.startswith("global"):
+                    var = Variable.create_var(self.model, name, vtype, "global", self.constants)
+                    for t in range(self.config.horizon + 1):
+                        variables[(name, t)] = var
+                else:
+                    for t in range(self.config.horizon):
+                        variables[(name, t)] = Variable.create_var(self.model, name, vtype, t, self.constants)
+                        var_type = variables[(name, t)].var_type
+                    if var_type is VarType.STATE:
+                        variables[(name, self.config.horizon)] = Variable.create_var(self.model, name, vtype, self.config.horizon, self.constants)
+
         return variables
                 
          

{scipplan-0.1.0a1 → scipplan-0.1.1a0}/scipplan/scipplan.py

@@ -130,9 +130,10 @@ class SCIPPlan:
      
     @classmethod
     def solve(cls, config: Config) -> tuple[SCIPPlan, float]:
+        # Time total solve time including incrementing horizon
+        start_time = time.time()
         while True:
             model = SCIPPlan(config)
-            start_time = time.time()
             try:
                 print(f"Encoding the problem over horizon h={config.horizon}.")
                 print("Solving the problem.")
@@ -144,12 +145,21 @@ class SCIPPlan:
                 return model, solve_time 
                     
             
-            except InfeasibilityError:
+            except InfeasibilityError:    
+                if config.get_defaults().get("horizon") is False:
+                    print(f"Horizon of h={model.config.horizon} is infeasible.")
+
+                    solve_time = (time.time() - start_time)
+                    print(f"Total time: {solve_time:.3f}")
+
+                    raise InfeasibilityError
+                    
+                
                 # print("Problem is infeasible for the given horizon.")
-                print(f"Horizon of h={model.config.horizon} is infeasible, incrementing to h={model.config.horizon + 1}")
+                print(f"Horizon of h={model.config.horizon} is infeasible, incrementing to h={model.config.horizon + 1}.")
                 config.increment_horizon()
                 if config.show_output is True:
-                    print(f"Horizon Time: {(time.time() - start_time): .3f} seconds")
+                    print(f"Horizon Time: {(time.time() - start_time): .3f} seconds.")
         
 
     def save_values(self, iteration: int):
@@ -162,8 +172,11 @@ def main():
     print(f"PySCIPOpt Version: {version('pyscipopt')}\n")
     config = Config.get_config()
     print(config)
-  
-    plan, solve_time = SCIPPlan.solve(config)  
+    
+    try:
+        plan, solve_time = SCIPPlan.solve(config)  
+    except InfeasibilityError:
+        return None
     
     if config.save_sols is True:
         write_to_csv("new_constraints", plan.new_constraints, config)
@@ -185,9 +198,9 @@ def main():
         for action_name in action_names:
             if action_name == config.dt_var:
                 continue
-            print(f"{action_name} at step {step} by value {plan.scip_model.getVal(plan.plan.variables[(action_name, step)].model_var):.3f}")
+            print(f"{action_name} at step {step} by value {plan.scip_model.getVal(plan.plan.variables[(action_name, step)].model_var):.3f}.")
         
-        print(f"Dt at step {step} by value {plan.scip_model.getVal(plan.plan.variables[('Dt', step)].model_var):.3f} \n")
+        print(f"Dt at step {step} by value {plan.scip_model.getVal(plan.plan.variables[('Dt', step)].model_var):.3f}. \n")
     
     print(f"Total reward: {(plan.scip_model.getObjVal()):.3f}")
     print(f"Total time: {solve_time:.3f}")

{scipplan-0.1.0a1 → scipplan-0.1.1a0/scipplan.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: scipplan
-Version: 0.1.0a1
+Version: 0.1.1a0
 Summary: Metric Hybrid Factored Planning in Nonlinear Domains with Constraint Generation in Python.
 Author: Ari Gestetner, Buser Say
-Author-email: ages0001@student.monash.edu, buser.say@monash.edu
+Author-email: ari.gestetner@monash.edu, buser.say@monash.edu
 License: MIT License
 Keywords: scip,automated planner
 Classifier: Development Status :: 3 - Alpha
@@ -121,13 +121,17 @@ state_continuous: Location_x
 state_continuous: Location_y
 state_continuous: Speed_x
 state_continuous: Speed_y
+global_boolean: aux_1
 ```
-where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - sign like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
+where the variable and value type of the variable is set in the format "{variable type}_{value type}" and the variable itself has to be in a Python compatible format (e.g. variables can't use - symbol like `some-var` but can use _ like `some_var` as well as the dash sign ' cannot be used). The use of next state variables which is often written using the dash symbol will be explained further in the Transitions section.  
 Additionally a variable for Dt has to be defined and has to be the same as the dt_var in the config object so if you would like to use a different variable name for Dt (e.g. dt) please also ensure you add it to the config via the `--dt-var` tag or the `dt_var` parameter.  
+The variable type `global` is used when you would like a non state variable to be equal over every time step over the horizon (e.g. if $v_t$ is a variable at time $t$ and $H$ is the horizon, then $v_1 = v_2 = \dots = v_{H+1}$).  
+
 The available variable types are
 - state
 - action
 - auxiliary
+- global
 
 The available value types are 
 - continuos
@@ -144,7 +148,7 @@ Location_y == 0.0
 Speed_x == 0.0
 Speed_y == 0.0
 ```
-notice te use of teh constant value defined earlier in the constants file.
+notice the use of the constant value defined earlier in the constants file.
 ### Goals
 The goals file should encode the final state values such that t=H+1, for example
 ```txt