scipplan 0.1.0a3__py2.py3-none-any.whl → 0.2.0a1__py2.py3-none-any.whl

scipplan/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.0alpha3"
+__version__ = "0.2.0alpha1"
 print(f"SCIPPlan Version: {__version__}")
 __release__ = "v0.1.0"
 __author__ = "Ari Gestetner, Buser Say"

scipplan/config.py

@@ -16,6 +16,7 @@ class Config:
     horizon: int = field(default=None)
     epsilon: float = field(default=None)
     gap: float = field(default=None)
+    provide_sols: bool = field(default=False)
     show_output: bool = False
     save_sols: bool = False
     bigM: float = 1000.0
@@ -50,6 +51,7 @@ class Config:
         text = f"""
         Configuration:
         
+        Use System of ODE's: {not self.provide_sols}
         Display SCIP Output: {self.show_output}
         Save Solutions: {self.show_output}
         Dt Variable Name: {self.dt_var}
@@ -80,14 +82,14 @@ class Config:
             "--domain", 
             required=True,
             type=str,
-            help="This variable is the name of the domain (e.g. pandemic or navigation)"
+            help="This variable is the name of the domain (e.g. pandemic or navigation)."
         )
         parser.add_argument(
             "-I", 
             "--instance", 
             required=True,
             type=str,
-            help="This is the instance number of the domain (e.g. navigation has instances 1, 2 and 3)"
+            help="This is the instance number of the domain (e.g. navigation has instances 1, 2 and 3)."
         )
         parser.add_argument(
             "-H", 
@@ -95,7 +97,7 @@ class Config:
             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"
+            help="The initial horizon. The solve method will initially begin with this horizon until it finds a feasible solution."
         )
         parser.add_argument(
             "-E", 
@@ -103,7 +105,7 @@ class Config:
             required=False,
             # default=0.1,
             type=float,
-            help="SCIPPlan iteratively checks solution for violations at each epsilon value"
+            help="SCIPPlan iteratively checks solution for violations at each epsilon value."
         )
         parser.add_argument(
             "-G", 
@@ -111,7 +113,7 @@ class Config:
             required=False,
             # default=0.1,
             type=float,
-            help="SCIP will search for solution with an optimality gap by at least this value"
+            help="SCIP will search for solution with an optimality gap by at least this value."
         )
         
         parser.add_argument(
@@ -119,7 +121,7 @@ class Config:
             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"
+            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(
@@ -127,21 +129,28 @@ class Config:
             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')"
+            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(
+            "--provide-sols", 
+            action="store_true", 
+            default=False, 
+            help="This flag determines whether the user would like to provide a system of odes or solution equations, odes must be provided by default."
+        )
+
         parser.add_argument(
             "--show-output", 
             action="store_true", 
             default=False, 
-            help="Include this flag to show output from SCIP"
+            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)"
+            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()

scipplan/helpers.py

@@ -2,6 +2,7 @@ import os
 import csv
 
 from typing import Generator
+
 from .config import Config
 
 class InfeasibilityError(Exception):

scipplan/parse_model.py

@@ -10,68 +10,13 @@ from math import exp, log, sqrt, sin, cos, isclose
 
 from pyscipopt.scip import Model, SumExpr
 
-
-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
-    
-
+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:
@@ -92,8 +37,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"
@@ -207,11 +152,22 @@ class ParseModel:
                             aux_vars.append(aux_var)
                             self.variables[aux_var.name] = aux_var.model_var
                             
-                            expr1, expr2 = linearise(expr, aux_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))
                             
-                            self.expressions.add_expressions(self.evaluate(expr1))
-                            self.expressions.add_expressions(self.evaluate(expr2))
-
+                            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()

scipplan/plan_model.py

@@ -9,6 +9,9 @@ import os
 from pyscipopt.scip import Model
 from pkg_resources import parse_version
 from importlib.metadata import version
+from sympy import Eq, Function, Derivative as dd, Symbol, parse_expr
+from sympy.solvers.ode.systems import dsolve_system
+
 
 if parse_version(version("pyscipopt")) >= parse_version("4.3.0"):
     from pyscipopt import quicksum, exp, log, sqrt, sin, cos
@@ -27,6 +30,8 @@ class PlanModel:
         # Translation -> line_num -> horizon -> aux
         self.aux_vars: dict[str, list[list[list]]] = {}
         
+        self.file_translations = self.read_translations()
+
         self.constants = self.encode_constants()
         self.variables = self.encode_pvariables()
         self.translations = self.encode_constraints()
@@ -39,8 +44,27 @@ class PlanModel:
             self.model.addCons(dt_var >= 0.0, f"dt_{h}_lower_bound")
             self.model.addCons(dt_var <= self.config.bigM, f"dt_{h}_upper_bound")   
     
-
+    def read_translations(self) -> dict[str, list[str]]:
+        with open(self.get_file_path("solutions" if self.config.provide_sols else "odes")) as f:
+            translations = {}
+            new_sec = True
+            for line in f:
+                line = line.strip()
+                if line == "":
+                    pass
+                elif line == "---":
+                    new_sec = True
+                elif new_sec is True:
+                    translation = line.removesuffix(":")
+                    translations[translation] = []
+                    new_sec = False
+                else:
+                    translations[translation].append(line)
         
+        return translations
+
+
+
     def encode_constants(self) -> dict[str, float]:
         constants = {}
         translation = "constants"
@@ -53,23 +77,20 @@ class PlanModel:
         }
     
             
-        with open(self.get_file_path(translation)) as f:
-            for line in f.readlines():
-                if line.strip() == "":
-                    continue
-                
-                var, val = line.strip().split("=")
-                var, val = var.strip(), val.strip()
-                
-                val = val if val not in config_vals else config_vals[val]
-                
-                try:
-                    val = float(val)
-                except ValueError:
-                    raise ValueError("Constants can only be floats, please reconfigure: ")
-                
-                constants[var] = val
-                self.var_names.add(var)
+        for line in self.file_translations[translation]:
+
+            var, val = line.split("=")
+            var, val = var.strip(), val.strip()
+            
+            val = val if val not in config_vals else config_vals[val]
+            
+            try:
+                val = float(val)
+            except ValueError:
+                raise ValueError("Constants can only be floats, please reconfigure: ")
+            
+            constants[var] = val
+            self.var_names.add(var)
                 
         constants["bigM"] = self.config.bigM
         self.var_names.add("bigM")
@@ -84,22 +105,21 @@ class PlanModel:
                 var_type = variables[(constant, t)].var_type
                 
         translation = "pvariables"
-        with open(self.get_file_path(translation)) as f:
-            for line in f.readlines():
-                
-                var = line.rstrip("\n").strip()
-                if var == "":
-                    continue
-                vtype, name = var.split(": ")
-                vtype, name = vtype.strip(), name.strip()
-                
-                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)
+        for line in self.file_translations[translation]:
+            
+            var = line.rstrip("\n").strip()
+            if var == "":
+                continue
+            vtype, name = var.split(": ")
+            vtype, name = vtype.strip(), name.strip()
+            
+            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)
                     
         return variables
                 
@@ -111,24 +131,37 @@ class PlanModel:
             "instantaneous_constraints",
             "temporal_constraints",
             "goals",
-            "transitions"
+            "odes" if self.config.provide_sols is False else "transitions"
         ]
         translations: dict[str, list[str]] = {}
         for translation in translation_names:
             translations[translation] = []
             
-            with open(self.get_file_path(translation)) as f:
-                for line in f.readlines():
-                    expr = line.rstrip("\n").strip()
-                    # If line is empty don't append
-                    if expr == "":
-                        continue
-                    
-                    translations[translation].append(expr)
+            for line in self.file_translations[translation]:
+                expr = line.rstrip("\n").strip()
+                # If line is empty don't append
+                if expr == "":
+                    continue
+                
+                translations[translation].append(expr)
+
+        if self.config.provide_sols is False: 
+            self.ode_functions = self.solve_odes(translations["odes"])
+
+            translations["transitions"] = []
+            for func_name, func in self.ode_functions.items():
+                translations["transitions"].append((func_name + "_dash" + " == " + func))
             
+            del translations["odes"]
+            
+
         # Encode constraints into model
         for cons_idx, (translation, constraints) in enumerate(translations.items()):
             for idx, constraint in enumerate(constraints):
+                if (self.config.provide_sols is False) and (translation == "temporal_constraints"):
+                    for func_name, func in self.ode_functions.items():
+                        constraint = constraint.replace(func_name, func)
+                    constraints[idx] = constraint
                 if translation == "initials":
                     exprs = PM(self.get_parser_params(horizon=0, add_aux_vars=True)).evaluate(constraint, horizon=0, expr_name=f"{translation}_{idx}_0")
                     
@@ -165,16 +198,15 @@ class PlanModel:
     def encode_reward(self):
         objectives = [None] * self.config.horizon
         translation = "reward"
-        with open(self.get_file_path(translation)) as f:
-            reward = f.readline().rstrip("\n")
-            for t in range(self.config.horizon):
-                objectives[t] = self.model.addVar(f"Obj_{t}", vtype="C", lb=None, ub=None)
-                # For the sake of similarity the reward is similar to constraint parsing, however, only one reward function is allowed
-                exprs = PM(self.get_parser_params(t)).evaluate(reward)
-                for expr_idx, expr in enumerate(exprs):
-                    self.model.addCons(objectives[t] == expr, f"Obj_{t}_{expr_idx}")
-                
-            self.model.setObjective(quicksum(objectives), "maximize")
+        reward = self.file_translations[translation][0]
+        for t in range(self.config.horizon):
+            objectives[t] = self.model.addVar(f"Obj_{t}", vtype="C", lb=None, ub=None)
+            # For the sake of similarity the reward is similar to constraint parsing, however, only one reward function is allowed
+            exprs = PM(self.get_parser_params(t)).evaluate(reward)
+            for expr_idx, expr in enumerate(exprs):
+                self.model.addCons(objectives[t] == expr, f"Obj_{t}_{expr_idx}")
+            
+        self.model.setObjective(quicksum(objectives), "maximize")
             
         return objectives
             
@@ -254,4 +286,47 @@ class PlanModel:
             return os.path.join(pkg_files_path, path)
         else:
             raise Exception("Unkown file name, please enter a configuration for a valid domain instance in translation: ")
-        
+        
+
+    def solve_odes(self, ode_system: list[str]) -> dict[str, str]:
+        dt_var = self.config.dt_var
+
+        dt = Symbol(dt_var)
+        # Used to represent constant variables
+        temp_var = Symbol("TEMP_VAR")
+
+        variables = {}
+        states = []
+
+        for var_name in self.var_names:
+            var = self.variables[(var_name, 0)]
+            if var.var_type is VarType.STATE:
+                states.append(var.name)
+                variables[var.name] = Function(var.name)(dt)
+            elif var.var_type is VarType.CONSTANT:
+                variables[var.name] = self.constants[var.name]
+            else: # the variable is an action or aux variable which is encoded as a function of some unused variable as workaround to not being able to use symbols for constants
+                variables[var.name] = Function(var.name)(temp_var)
+        
+        variables[dt_var] = dt
+        
+        system = []
+        for eqtn in ode_system:
+            lhs, rhs = eqtn.split("==")
+            lhs = parse_expr(lhs.strip(), local_dict=variables | {"dd": dd})
+            rhs = parse_expr(rhs.strip(), local_dict=variables | {"dd": dd})
+            system.append(Eq(lhs, rhs))
+        results = dsolve_system(system, ics={variables[state].subs(dt, 0): state for state in states})
+
+
+
+        functions: dict[str, str] = {}
+        for eqtn in results[0]:
+            new_eqtn = eqtn.doit()
+            func_name = new_eqtn.lhs.name.replace(f"({temp_var.name})", "").replace(f"({self.config.dt_var})", "_dash")
+            functions[func_name] = str(new_eqtn.rhs).replace(f"({temp_var.name})", "").replace(f"({self.config.dt_var})", "_dash")
+        
+        
+        return functions
+
+

scipplan/scipplan.py

@@ -46,6 +46,8 @@ class SCIPPlan:
     def optimize(self):
         iteration = 0
         
+        const_gen_aux_vars = [[None] * self.config.horizon for _ in range(len(self.plan.translations["temporal_constraints"]))]
+
         while True:
             self.scip_model.optimize()
             
@@ -80,10 +82,15 @@ class SCIPPlan:
             
             for idx, constraint in enumerate(self.plan.translations["temporal_constraints"]):
                 t = zero_cross.horizon
-                aux_vars = self.plan.aux_vars["temporal_constraints"][idx][t]
-                params = self.plan.get_parser_params(horizon=t)
+                # aux_vars = self.plan.aux_vars["temporal_constraints"][idx][t]
+                aux_vars = const_gen_aux_vars[idx][t]
+                # Only add aux vars if there are no aux vars added for the secific constraint
+                params = self.plan.get_parser_params(horizon=t, add_aux_vars=aux_vars is None)
                 params.variables[self.config.dt_var] *= zero_cross.coef
                 exprs = PM(params).evaluate(constraint, aux_vars=aux_vars)
+                if const_gen_aux_vars[idx][t] is None:
+                    const_gen_aux_vars[idx][t] = exprs.aux_vars
+                    
                 for eqtn_idx, eqtn in enumerate(exprs):
                     self.plan.model.addCons(eqtn, f"{constraint}_{idx}_{eqtn_idx}")
             

scipplan/translation/odes_navigation_1.txt

@@ -0,0 +1,50 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+odes:
+dd(Location_x, Dt) == Speed_x
+dd(Location_y, Dt) == Speed_y
+dd(Speed_x, Dt) == Accelerate_x
+dd(Speed_y, Dt) == Accelerate_y
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 4.0) or (Location_x >= 6.0) or (Location_y <= 4.0) or (Location_y >= 6.0)
+---
+temporal_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+
+(Location_x <= 4.0) or (Location_x >= 6.0) or (Location_y <= 4.0) or (Location_y >= 6.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

scipplan/translation/odes_navigation_2.txt

@@ -0,0 +1,51 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+odes:
+dd(Location_x, Dt) == Speed_x
+dd(Location_y, Dt) == Speed_y
+dd(Speed_x, Dt) == Accelerate_x
+dd(Speed_y, Dt) == Accelerate_y
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 5.0)
+(Location_x <= 5.0) or (Location_x >= 7.0) or (Location_y <= 5.0) or (Location_y >= 9.0)
+---
+temporal_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 5.0)
+(Location_x <= 5.0) or (Location_x >= 7.0) or (Location_y <= 5.0) or (Location_y >= 9.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

scipplan/translation/odes_navigation_3.txt

@@ -0,0 +1,53 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+odes:
+dd(Location_x, Dt) == Speed_x
+dd(Location_y, Dt) == Speed_y
+dd(Speed_x, Dt) == Accelerate_x
+dd(Speed_y, Dt) == Accelerate_y
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 7.0) or (Location_y <= 7.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 9.0) or (Location_y <= 2.0) or (Location_y >= 6.0)
+---
+temporal_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 7.0) or (Location_y <= 7.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 9.0) or (Location_y <= 2.0) or (Location_y >= 6.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

scipplan/translation/solutions_navigation_1.txt

@@ -0,0 +1,50 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+transitions:
+Location_x_dash - 1.0*Location_x - 1.0*Speed_x*(Dt) - 0.5*Accelerate_x*(Dt)*(Dt) == 0.0
+Location_y_dash - 1.0*Location_y - 1.0*Speed_y*(Dt) - 0.5*Accelerate_y*(Dt)*(Dt) == 0.0
+Speed_x_dash - 1.0*Speed_x - 1.0*Accelerate_x*(Dt) == 0.0
+Speed_y_dash - 1.0*Speed_y - 1.0*Accelerate_y*(Dt) == 0.0
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 4.0) or (Location_x >= 6.0) or (Location_y <= 4.0) or (Location_y >= 6.0)
+---
+temporal_constraints:
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 10.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 10.0
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 0.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 0.0
+
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 4.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 6.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 4.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 6.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

scipplan/translation/solutions_navigation_2.txt

@@ -0,0 +1,51 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+transitions:
+Location_x_dash - 1.0*Location_x - 1.0*Speed_x*(Dt) - 0.5*Accelerate_x*(Dt)*(Dt) == 0.0
+Location_y_dash - 1.0*Location_y - 1.0*Speed_y*(Dt) - 0.5*Accelerate_y*(Dt)*(Dt) == 0.0
+Speed_x_dash - 1.0*Speed_x - 1.0*Accelerate_x*(Dt) == 0.0
+Speed_y_dash - 1.0*Speed_y - 1.0*Accelerate_y*(Dt) == 0.0
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 5.0)
+(Location_x <= 5.0) or (Location_x >= 7.0) or (Location_y <= 5.0) or (Location_y >= 9.0)
+---
+temporal_constraints:
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 10.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 10.0
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 0.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 0.0
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 2.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 4.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 1.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 5.0)
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 5.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 7.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 5.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 9.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

scipplan/translation/solutions_navigation_3.txt

@@ -0,0 +1,53 @@
+constants:
+Epsilon = config_epsilon
+bigM = config_bigM
+---
+pvariables:
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+---
+transitions:
+Location_x_dash - 1.0*Location_x - 1.0*Speed_x*(Dt) - 0.5*Accelerate_x*(Dt)*(Dt) == 0.0
+Location_y_dash - 1.0*Location_y - 1.0*Speed_y*(Dt) - 0.5*Accelerate_y*(Dt)*(Dt) == 0.0
+Speed_x_dash - 1.0*Speed_x - 1.0*Accelerate_x*(Dt) == 0.0
+Speed_y_dash - 1.0*Speed_y - 1.0*Accelerate_y*(Dt) == 0.0
+---
+initials:
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0
+---
+instantaneous_constraints:
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 7.0) or (Location_y <= 7.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 9.0) or (Location_y <= 2.0) or (Location_y >= 6.0)
+---
+temporal_constraints:
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 10.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 10.0
+Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 0.0
+Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 0.0
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 2.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 4.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 1.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 9.0)
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 4.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 7.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 7.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 9.0)
+(Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) <= 4.0) or (Location_x + Speed_x*(Dt) + 0.5*Accelerate_x*(Dt)*(Dt) >= 9.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) <= 2.0) or (Location_y + Speed_y*(Dt) + 0.5*Accelerate_y*(Dt)*(Dt) >= 6.0)
+---
+goals:
+Location_x == 8.0
+Location_y == 8.0
+---
+reward:
+-1.0*(Dt)

{scipplan-0.1.0a3.dist-info → scipplan-0.2.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scipplan
-Version: 0.1.0a3
+Version: 0.2.0a1
 Summary: Metric Hybrid Factored Planning in Nonlinear Domains with Constraint Generation in Python.
 Author: Ari Gestetner, Buser Say
 Author-email: ari.gestetner@monash.edu, buser.say@monash.edu
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: PySCIPOpt ==5.2.1
+Requires-Dist: sympy ==1.13.3
 
 # SCIPPlan
 
@@ -144,7 +146,7 @@ Location_y == 0.0
 Speed_x == 0.0
 Speed_y == 0.0
 ```
-notice the use of the constant value defined earlier in the constants file.
+notice te use of teh 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.0a3.dist-info → scipplan-0.2.0a1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-scipplan/__init__.py,sha256=KScjrF1mIQbNUpdz4Ln6Ig5eA4ExpSUKSd1crpjyuv4,193
-scipplan/config.py,sha256=0D6UcLjrv4PTjYRiPoIYXAsRu4nwcaOIWnsI4lAdK6Y,5221
-scipplan/helpers.py,sha256=YwEr0NeDvb29_Ot686km3ZMJ-vHu-L8zjuexmlKDjpY,974
-scipplan/parse_model.py,sha256=CI_38xmaiVr8DuOi3UdNrVqWHTdW6qm_5luwLZxIk9I,11136
-scipplan/plan_model.py,sha256=daHnVHn2e89OtXXMl63QEoeKGOmy_LwT2oCRTjUUlKQ,11145
-scipplan/scipplan.py,sha256=z6cuRug4amCg6LU7S4RYHcV6uT3vWLHYGRh9OXFkKoU,8225
+scipplan/__init__.py,sha256=RPBElHHcH17D6eKi9tgqPRYINNDEAAyBs3vJOkm8-xw,193
+scipplan/config.py,sha256=Ojs_pdjhwRuANPJcGyb3m5mMGqbTZkHuNvppd_Wd4FQ,5615
+scipplan/helpers.py,sha256=YmS0HPQymsO5_e3jK7WQ-hBRZnxoZtewLhuzubw5sR4,975
+scipplan/parse_model.py,sha256=-vssLQZHbXxkoiHjTHD-ZxY2h0w9LvGuJZXSd4RZvlM,9564
+scipplan/plan_model.py,sha256=iFbpZbSMNYjNxSpL7qW5ajQRGDY-ZAD3wVPaSjm-deo,14012
+scipplan/scipplan.py,sha256=Ykz_L0f2dyX4-EQB1iCH-QR3waVUwxKzgskdQeUP9nE,8675
 scipplan/variables.py,sha256=3sxY3zQuxsa5z2fTFjv4zOSb9GarzojZ4W4kIx9FX68,2561
 scipplan/zero_crossing.py,sha256=kGyJsWZLLXqLW1p3LPDlPC34rTkFF8daDzqgbEcaXus,1043
 scipplan/translation/constants_navigation_1.txt,sha256=X0jvJe5MiwvayKBVXo9TQlGZGfUlpnFpMiReL68rsXc,43
@@ -18,21 +18,27 @@ scipplan/translation/initials_navigation_3.txt,sha256=s7ukUEHwcmMsey1bHCRJh515PL
 scipplan/translation/instantaneous_constraints_navigation_1.txt,sha256=WbITeszv_n93_BhE2eiNqFPAZVO4f2s44KcKUsNURyA,244
 scipplan/translation/instantaneous_constraints_navigation_2.txt,sha256=e5YdZn3OKLJh0kEiCNqpOgxgAAQxIHMB3J5OTYvPlgw,333
 scipplan/translation/instantaneous_constraints_navigation_3.txt,sha256=HnzfFntGIQ0WIMnEfcYPg1cy7u9dJn3xuYqdXZVFFvE,422
+scipplan/translation/odes_navigation_1.txt,sha256=Uv13eTSTvURb6TtY7rq-otlpJMS8cQDYSyaO3X2_SRs,1015
+scipplan/translation/odes_navigation_2.txt,sha256=DcbpXv-q0NP8Tx10YKqD6425esblgPNlTxchkyWMJAc,1192
+scipplan/translation/odes_navigation_3.txt,sha256=ZFTyFEiL1KP0yxOCOzOSoXz9dXulRmtXDBnfZqaVbaE,1370
 scipplan/translation/pvariables_navigation_1.txt,sha256=97t5uPWAWKmtbDPJZIor5nn5qPU6aMcGdpLAuKnlDbQ,217
 scipplan/translation/pvariables_navigation_2.txt,sha256=lGUNN04bC-CJFTThNC3dwP9kU2xGftSshx-24I6zlZw,216
 scipplan/translation/pvariables_navigation_3.txt,sha256=1-yvM5BSJ5TXBlHkMbcXWd5zoc2ezSBpIIuM_zwEXSo,216
 scipplan/translation/reward_navigation_1.txt,sha256=dvR0CkxkWRbO3wP0fenXDSDMpueEUtSUqw990UnCcJY,26
 scipplan/translation/reward_navigation_2.txt,sha256=ck6uUGNhM_DWiG1hHN6_xTps1muychzqTOpz1iLF9bk,26
 scipplan/translation/reward_navigation_3.txt,sha256=O8unFCIySCz4GCBX_9mQcm-JMn5Ur6upp3HBbA4e_C8,22
+scipplan/translation/solutions_navigation_1.txt,sha256=5iLPRtJXqfAXi0QG-3WPtKn8t0pH4-E2AtNp8-7k1CQ,1542
+scipplan/translation/solutions_navigation_2.txt,sha256=b1c74m54iRCcZoe8uqquUQyn6HtRTiFqIA8ss2mZUdg,1895
+scipplan/translation/solutions_navigation_3.txt,sha256=Jv3bzMt84LVyR1DSVJ5B8Ky9id_khZ1PxZ1s3QPKpk8,2249
 scipplan/translation/temporal_constraints_navigation_1.txt,sha256=h06iRA5TDr6R5XdjhEyYnZ3f-FQwUkbKGNw-t0k0jm8,875
 scipplan/translation/temporal_constraints_navigation_2.txt,sha256=x73dbxxb_YzvdvtVNaJfG-S9ggf-yqTYdoU6NiDQBqk,1319
 scipplan/translation/temporal_constraints_navigation_3.txt,sha256=Ki4nAX9-QtBbY9ZdHwHdqta8JQoLrAVvlZrLa1pWLnQ,1668
 scipplan/translation/transitions_navigation_1.txt,sha256=kfnr3_A9mCfflLsL4aq7OeR_BHSNST6eYuAg4ZxaPoU,411
 scipplan/translation/transitions_navigation_2.txt,sha256=kfnr3_A9mCfflLsL4aq7OeR_BHSNST6eYuAg4ZxaPoU,411
 scipplan/translation/transitions_navigation_3.txt,sha256=aIPP3FOjXZ3G6sTqicEIZ0JKJxdxHCRRZIdc5bUPFBM,395
-scipplan-0.1.0a3.dist-info/LICENSE,sha256=tfR4peJA8KJtYEn1NzNV-LWQVRAserdq7OJgYghreR0,1057
-scipplan-0.1.0a3.dist-info/METADATA,sha256=O1UnTCpE4vAdV1zmtvJ5jJKcqTErpVtxjlwHE9BO2wg,11234
-scipplan-0.1.0a3.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110
-scipplan-0.1.0a3.dist-info/entry_points.txt,sha256=3qiNbbp6qIwivyPmmikyp7ByCfmsa9rGFNJPcN9Is8I,52
-scipplan-0.1.0a3.dist-info/top_level.txt,sha256=xO2FLRn7YQ-C25E8lagIEbik5T5FTr-Ta5bdiZezEPY,9
-scipplan-0.1.0a3.dist-info/RECORD,,
+scipplan-0.2.0a1.dist-info/LICENSE,sha256=tfR4peJA8KJtYEn1NzNV-LWQVRAserdq7OJgYghreR0,1057
+scipplan-0.2.0a1.dist-info/METADATA,sha256=9mQSEmKgV45LuDGbyiV3H8IbEHQh0MKmjoyrsG068k4,11296
+scipplan-0.2.0a1.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110
+scipplan-0.2.0a1.dist-info/entry_points.txt,sha256=3qiNbbp6qIwivyPmmikyp7ByCfmsa9rGFNJPcN9Is8I,52
+scipplan-0.2.0a1.dist-info/top_level.txt,sha256=xO2FLRn7YQ-C25E8lagIEbik5T5FTr-Ta5bdiZezEPY,9
+scipplan-0.2.0a1.dist-info/RECORD,,