def generate_problem(self, problem_range): min_blocks = self.get_value("min_blocks") max_blocks = self.get_value("max_blocks") assert min_blocks >= BlocksworldDomainGenerator.MIN_BLOCKS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") blocks = random.randint(min_blocks, max_blocks) properties = { "min_blocks": min_blocks, "max_blocks": max_blocks, "blocks": blocks, "bin_params": ["blocks"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -n %u" % (BlocksworldDomainGenerator.GENERATOR_BIN, blocks) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_n = self.get_value("min_n") max_n = self.get_value("max_n") assert min_n >= NPuzzleDomainGenerator.MIN_N for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") n = random.randint(min_n, max_n) properties = { "min_n": min_n, "max_n": max_n, "n": n, } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -n %u" % ( NPuzzleDomainGenerator.GENERATOR_BIN, n) unused_completed_process = subprocess.run( gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_size = self.get_value("min_size") max_size = self.get_value("max_size") min_g_percent = self.get_value("min_g_percent") max_g_percent = self.get_value("max_g_percent") min_hole_percent = self.get_value("min_hole_percent") max_hole_percent = self.get_value("max_hole_percent") assert min_size >= VisitAllDomainGenerator.MIN_SIZE assert min_g_percent >= 0 and max_g_percent <= 100 assert min_hole_percent >= 0 and max_hole_percent <= 100 for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") size = random.randint(min_size, max_size) goal_percent = random.randint(min_g_percent, max_g_percent) goals = int((size * size * goal_percent) / 100) goals = max(VisitAllDomainGenerator.MIN_GOALS, goals) hole_percent = random.randint(min_hole_percent, max_hole_percent) holes = int((((size * size) - goals - 1) * hole_percent) / 100) seed = random.randint(1, VisitAllDomainGenerator.MAX_SEED) properties = { "min_size": min_size, "max_size": max_size, "min_g_percent": min_g_percent, "max_g_percent": max_g_percent, "min_hole_percent": min_hole_percent, "max_hole_percent": max_hole_percent, "size": size, "goals": goals, "holes": holes, "seed": seed, "bin_params": ["size"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -n %u -r %.2f -u %u -s %u" % ( VisitAllDomainGenerator.GENERATOR_BIN, size, goal_percent / 100.0, holes, seed) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def write(self, solution_filepath): file_handle = open(solution_filepath, "w") file.write_properties(file_handle, self._properties, ";") for grounded_action in self._action_list: file_handle.write("%s\n" % (grounded_action)) file_handle.close()
def generate_problem(self, problem_range): min_size = self.get_value("min_size") max_size = self.get_value("max_size") min_balls = self.get_value("min_balls") max_balls = self.get_value("max_balls") min_walls = self.get_value("min_walls") max_walls = self.get_value("max_walls") assert min_size >= SokobanDomainGenerator.MIN_SIZE assert min_balls >= SokobanDomainGenerator.MIN_BALLS assert min_walls >= SokobanDomainGenerator.MIN_WALLS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") size = random.randint(min_size, max_size) balls = random.randint(min_balls, max_balls) walls = random.randint(min_walls, max_walls) properties = { "size": size, "min_size": min_size, "max_size": max_size, "min_balls": min_balls, "max_balls": max_balls, "min_walls": min_walls, "max_walls": max_walls, "size": size, "balls": balls, "walls": walls, "bin_params": ["size"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -n %u -b %u -w %u" % ( SokobanDomainGenerator.GENERATOR_BIN, size, balls, walls) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_spanners = self.get_value("min_spanners") max_spanners = self.get_value("max_spanners") min_nuts = self.get_value("min_nuts") max_nuts = self.get_value("max_nuts") min_locations = self.get_value("min_locations") max_locations = self.get_value("max_locations") assert min_spanners >= SpannerDomainGenerator.MIN_SPANNERS assert min_nuts >= SpannerDomainGenerator.MIN_NUTS assert min_locations >= SpannerDomainGenerator.MIN_LOCATIONS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") spanners = random.randint(min_spanners, max_spanners) nuts = min(spanners, random.randint(min_nuts, max_nuts)) locations = random.randint(min_locations, max_locations) properties = { "min_spanners": min_spanners, "max_spanners": max_spanners, "min_nuts": min_nuts, "max_nuts": max_nuts, "min_locations": min_locations, "max_locations": max_locations, "spanners": spanners, "nuts": nuts, "locations": locations, "bin_params": ["spanners", "nuts", "locations"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s %u %u %u" % (SpannerDomainGenerator.GENERATOR_BIN, spanners, nuts, locations) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_robots = self.get_value("min_robots") max_robots = self.get_value("max_robots") min_rooms = self.get_value("min_rooms") max_rooms = self.get_value("max_rooms") min_balls = self.get_value("min_balls") max_balls = self.get_value("max_balls") assert min_robots >= GrippersDomainGenerator.MIN_ROBOTS assert min_rooms >= GrippersDomainGenerator.MIN_ROOMS assert min_balls >= GrippersDomainGenerator.MIN_BALLS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") robots = random.randint(min_robots, max_robots) rooms = random.randint(min_rooms, max_rooms) balls = random.randint(min_balls, max_balls) properties = { "min_robots": min_robots, "max_robots": max_robots, "min_rooms": min_rooms, "max_rooms": max_rooms, "min_balls": min_balls, "max_balls": max_balls, "robots": robots, "rooms": rooms, "balls": balls, "bin_params": ["robots", "rooms", "balls"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -n %u -r %u -o %u" % ( GrippersDomainGenerator.GENERATOR_BIN, robots, rooms, balls) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_cocktails = self.get_value("min_cocktails") max_cocktails = self.get_value("max_cocktails") min_ingredients = self.get_value("min_ingredients") max_ingredients = self.get_value("max_ingredients") min_shots = self.get_value("min_shots") max_shots = self.get_value("max_shots") assert min_cocktails >= BarmanDomainGenerator.MIN_COCKTAILS assert min_ingredients >= BarmanDomainGenerator.MIN_INGREDIENTS assert min_shots >= BarmanDomainGenerator.MIN_SHOTS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") cocktails = random.randint(min_cocktails, max_cocktails) ingredients = random.randint(min_ingredients, max_ingredients) shots = random.randint(min_shots, max_shots) properties = { "min_cocktails": min_cocktails, "max_cocktails": max_cocktails, "min_ingredients": min_ingredients, "max_ingredients": max_ingredients, "min_shots": min_shots, "max_shots": max_shots, "cocktails": cocktails, "ingredients": ingredients, "shots": shots, } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s %u %u %u" % (BarmanDomainGenerator.GENERATOR_BIN, cocktails, ingredients, shots) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_rows = self.get_value("min_rows") max_rows = self.get_value("max_rows") min_columns = self.get_value("min_columns") max_columns = self.get_value("max_columns") assert min_rows >= GoldminerDomainGenerator.MIN_ROWS assert min_columns >= GoldminerDomainGenerator.MIN_COLUMNS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") rows = random.randint(min_rows, max_rows) columns = random.randint(min_columns, max_columns) seed = random.randint(1, GoldminerDomainGenerator.MAX_SEED) properties = { "min_rows": min_rows, "max_rows": max_rows, "min_columns": min_columns, "max_columns": max_columns, "rows": rows, "columns": columns, "seed": seed, "bin_params": ["rows", "columns"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -r %u -c %u -s %u" % ( GoldminerDomainGenerator.GENERATOR_BIN, rows, columns, seed) unused_completed_process = subprocess.run( gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_locations = self.get_value("min_locations") max_locations = self.get_value("max_locations") min_cars = self.get_value("min_cars") max_cars = self.get_value("max_cars") assert min_locations >= FerryDomainGenerator.MIN_LOCATIONS assert min_cars >= FerryDomainGenerator.MIN_CARS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") locations = random.randint(min_locations, max_locations) cars = random.randint(min_cars, max_cars) seed = random.randint(1, FerryDomainGenerator.MAX_SEED) properties = { "min_locations": min_locations, "max_locations": max_locations, "min_cars": min_cars, "max_cars": max_cars, "locations": locations, "cars": cars, "seed": seed, "bin_params": ["locations", "cars"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -l %u -c %u -s %u" % ( FerryDomainGenerator.GENERATOR_BIN, locations, cars, seed) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_floors = self.get_value("min_floors") max_floors = self.get_value("max_floors") min_passengers = self.get_value("min_passengers") max_passengers = self.get_value("max_passengers") assert min_floors >= MiconicDomainGenerator.MIN_FLOORS assert min_passengers >= MiconicDomainGenerator.MIN_PASSENGERS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") floors = random.randint(min_floors, max_floors) passengers = random.randint(min_passengers, max_passengers) properties = { "min_floors": min_floors, "max_floors": max_floors, "min_passengers": min_passengers, "max_passengers": max_passengers, "floors": floors, "passengers": passengers, "bin_params": ["floors", "passengers"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -f %u -p %u" % (MiconicDomainGenerator.GENERATOR_BIN, floors, passengers) unused_completed_process = subprocess.run( gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_curbs = self.get_value("min_curbs") max_curbs = self.get_value("max_curbs") assert min_curbs >= ParkingDomainGenerator.MIN_CURBS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") curbs = random.randint(min_curbs, max_curbs) max_cars = 2 * curbs - 2 cars = random.randint(ParkingDomainGenerator._MIN_CARS, max_cars) properties = { "min_curbs": min_curbs, "max_curbs": max_curbs, "min_cars": 1, "max_cars": max_cars, "curbs": curbs, "cars": cars, } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s %u %u" % (ParkingDomainGenerator.GENERATOR_BIN, curbs, cars) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_children = self.get_value("min_children") max_children = self.get_value("max_children") min_trays = self.get_value("min_trays") max_trays = self.get_value("max_trays") min_gluten_ratio = self.get_value("min_gluten_ratio") max_gluten_ratio = self.get_value("max_gluten_ratio") min_sandwich_ratio = self.get_value("min_sandwich_ratio") max_sandwich_ratio = self.get_value("max_sandwich_ratio") assert min_children >= ChildsnackDomainGenerator.MIN_CHILDREN assert min_trays >= ChildsnackDomainGenerator.MIN_TRAYS assert min_sandwich_ratio >= \ ChildsnackDomainGenerator.MIN_SANDWICH_RATIO for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") seed = random.randint(0, ChildsnackDomainGenerator.MAX_SEED) children = random.randint(min_children, max_children) trays = random.randint(min_trays, max_trays) gluten_ratio = random.uniform(min_gluten_ratio, max_gluten_ratio) gluten_ratio = round_no(gluten_ratio, prec=2, base=0.25) sandwich_ratio = random.uniform(min_sandwich_ratio, max_sandwich_ratio) properties = { "min_children": min_children, "max_children": max_children, "min_trays": min_trays, "max_trays": max_trays, "min_gluten_ratio": min_gluten_ratio, "max_gluten_ratio": max_gluten_ratio, "min_sandwich_ratio": min_sandwich_ratio, "max_sandwich_ratio": max_sandwich_ratio, "seed": seed, "children": children, "trays": trays, "gluten_ratio": "%.1f" % (gluten_ratio), "sandwich_ratio": "%.1f" % (sandwich_ratio), "bin_params": ["children", "trays"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) # Use %.1f to force the 2nd endpoint of the ratio values (the max). # example: %.1f(1.9xxx...) = 2.0 gen_cmd = "%s %s %u %u %u %.1f %.1f" % ( ChildsnackDomainGenerator.GENERATOR_BIN, ChildsnackDomainGenerator.PROBLEM_TYPE, seed, children, trays, gluten_ratio, sandwich_ratio) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): locations = self.get_value("locations") last_location = locations - 1 min_crates = self.get_value("min_crates") max_crates = self.get_value("max_crates") assert min_crates >= DeliveryDomainGenerator.MIN_CRATES for problem_no in problem_range: crates = random.randint(min_crates, max_crates) assert crates > 0 # Generate a list of start locations and destinations. source_list = [] destination_list = [] for _ in range(crates): source_list.append(random.randint(0, last_location)) destination_list.append(random.randint(0, last_location)) problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") properties = { "locations": locations, "min_crates": min_crates, "max_crates": max_crates, "crates": crates, "bin_params": ["crates"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) file_handle.write("""(define (problem delivery-%uc-%ul) """ % (crates, locations)) file_handle.write(""" (:domain %s) """ % (DeliveryDomainGenerator._DOMAIN_NAME)) file_handle.write(""" (:objects truck0%s) """ % ("".join([" crate%u" % (i) for i in range(crates)]))) file_handle.write(""" (:init (truck truck0) (atl%u truck0)%s) """ % (random.randint(0, last_location), "".join([ " (crate crate%u) (atl%u crate%u)" % (i, source_list[i], i) for i in range(crates) ]))) file_handle.write(""" (:goal (and%s)) """ % ("".join([ " (atl%u crate%u)" % (destination_list[i], i) for i in range(crates) ]))) file_handle.write(")") file_handle.close() # Just return an empty list. return []
def generate_problem(self, problem_range): min_satellites = self.get_value("min_satellites") max_satellites = self.get_value("max_satellites") min_instruments = self.get_value("min_instruments") max_instruments = self.get_value("max_instruments") min_modes = self.get_value("min_modes") max_modes = self.get_value("max_modes") min_targets = self.get_value("min_targets") max_targets = self.get_value("max_targets") min_observations = self.get_value("min_observations") max_observations = self.get_value("max_observations") assert min_satellites >= SatelliteDomainGenerator.MIN_SATELLITES assert min_instruments >= SatelliteDomainGenerator.MIN_INSTRUMENTS assert min_modes >= SatelliteDomainGenerator.MIN_MODES assert min_targets >= SatelliteDomainGenerator.MIN_TARGETS assert min_observations >= SatelliteDomainGenerator.MIN_OBSERVATIONS for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") satellites = random.randint(min_satellites, max_satellites) instruments = random.randint(min_instruments, max_instruments) modes = random.randint(min_modes, max_modes) targets = random.randint(min_targets, max_targets) observations = random.randint(min_observations, max_observations) seed = random.randint(1, SatelliteDomainGenerator.MAX_SEED) properties = { "min_satellites": min_satellites, "max_satellites": max_satellites, "min_instruments": min_instruments, "max_instruments": max_instruments, "min_modes": min_modes, "max_modes": max_modes, "min_targets": min_targets, "max_targets": max_targets, "min_observations": min_observations, "max_observations": max_observations, "satellites": satellites, "instruments": instruments, "modes": modes, "targets": targets, "observations": observations, "seed": seed, "bin_params": [ "satellites", "instruments", "modes", "targets", "observations" ] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s %s %u %u %u %u %u" % ( SatelliteDomainGenerator.GENERATOR_BIN, seed, satellites, instruments, modes, targets, observations) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_x = self.get_value("min_x") max_x = self.get_value("max_x") min_y = self.get_value("min_y") max_y = self.get_value("max_y") min_types = self.get_value("min_types") max_types = self.get_value("max_types") min_keys = self.get_value("min_keys") max_keys = self.get_value("max_keys") min_locks = self.get_value("min_locks") max_locks = self.get_value("max_locks") min_prob = self.get_value("min_prob") max_prob = self.get_value("max_prob") assert min_x >= GridDomainGenerator.MIN_X assert min_y >= GridDomainGenerator.MIN_Y assert min_types >= GridDomainGenerator.MIN_TYPES assert min_keys >= GridDomainGenerator.MIN_KEYS assert min_locks >= GridDomainGenerator.MIN_LOCKS assert min_prob >= GridDomainGenerator.MIN_PROBABILITY assert max_prob <= GridDomainGenerator.MAX_PROBABILITY for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") x = random.randint(min_x, max_x) y = random.randint(min_y, max_y) types = random.randint(min_types, max_types) keys = random.randint(min_keys, max_keys) locks = random.randint(min_locks, max_locks) probability = random.randint(min_prob, max_prob) # Legal values for keys and locks. keys = min((x * y) - 2, keys) locks = min(keys, locks) locks = max(1, locks) properties = { "min_x": min_x, "max_x": max_x, "min_y": min_y, "max_y": max_y, "min_types": min_types, "max_types": max_types, "min_keys": min_keys, "max_keys": max_keys, "min_locks": min_locks, "max_locks": max_locks, "min_prob": min_prob, "max_prob": max_prob, "x": x, "y": y, "types": types, "keys": keys, "locks": locks, "probability": probability, "bin_params": ["x", "y", "keys", "locks"], } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -x %u -y %u -t %u -k %u -l %u -p %u" % ( GridDomainGenerator.GENERATOR_BIN, x, y, types, keys, locks, probability) unused_completed_process = subprocess.run(gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []
def generate_problem(self, problem_range): min_depots = self.get_value("min_depots") max_depots = self.get_value("max_depots") min_distributors = self.get_value("min_distributors") max_distributors = self.get_value("max_distributors") min_trucks = self.get_value("min_trucks") max_trucks = self.get_value("max_trucks") min_pallets = self.get_value("min_pallets") max_pallets = self.get_value("max_pallets") min_hoists = self.get_value("min_hoists") max_hoists = self.get_value("max_hoists") min_crates = self.get_value("min_crates") max_crates = self.get_value("max_crates") assert min_depots >= DepotsDomainGenerator.MIN_DEPOTS assert min_distributors >= DepotsDomainGenerator.MIN_DISTRIBUTORS assert min_trucks >= DepotsDomainGenerator.MIN_TRUCKS assert min_pallets >= DepotsDomainGenerator.MIN_PALLETS assert min_hoists >= DepotsDomainGenerator.MIN_HOISTS assert min_crates >= DepotsDomainGenerator.MIN_CRATES for problem_no in problem_range: problem_file = "problem_%u.problem.pddl" % (problem_no) file_handle = open("%s/%s" % (self._base_dir, problem_file), "w") depots = random.randint(min_depots, max_depots) distributors = random.randint(min_distributors, max_distributors) trucks = random.randint(min_trucks, max_trucks) pallets = random.randint(min_pallets, max_pallets) hoists = random.randint(min_hoists, max_hoists) crates = random.randint(min_crates, max_crates) seed = random.randint(1, DepotsDomainGenerator.MAX_SEED) properties = { "min_depots": min_depots, "max_depots": max_depots, "min_distributors": min_distributors, "max_distributors": max_distributors, "min_trucks": min_trucks, "max_trucks": max_trucks, "min_pallets": min_pallets, "max_pallets": max_pallets, "min_hoists": min_hoists, "max_hoists": max_hoists, "min_crates": min_crates, "max_crates": max_crates, "depots": depots, "distributors": distributors, "trucks": trucks, "pallets": pallets, "hoists": hoists, "crates": crates, "seed": seed, "bin_params": ["depots", "trucks"] } file.write_properties(file_handle, properties, constants.PDDL_COMMENT_PREFIX) gen_cmd = "%s -e %u -i %u -t %u -p %u -h %u -c %u -s %u" % ( DepotsDomainGenerator.GENERATOR_BIN, depots, distributors, trucks, pallets, hoists, crates, seed) unused_completed_process = subprocess.run( gen_cmd, shell=True, stdout=file_handle) # Just return an empty list. return []