def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ # translate the problem unload actions using example_have_cake.py as example syntax unloads = [] for a in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("In({},{})".format(c, p)), expr("At({}, {})".format(p, a)) ] precond_neg = [] effect_add = [expr("At({}, {})".format(c, a))] effect_rem = [expr("In({}, {})".format(c, p))] unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ # TODO create all Unload ground actions from the domain Unload action unloads = [] for a in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("In({}, {})".format(c, p)), expr("At({}, {})".format(p, a)), ] precond_neg = [] effect_add = [expr("At({}, {})".format(c, a))] effect_rem = [expr("In({}, {})".format(c, p))] unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ loads = [] for ap in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("At({}, {})".format(p, ap)), expr("At({}, {})".format(c, ap)), ] precond_neg = [] effect_add = [expr("In({}, {})".format(c, p))] effect_rem = [expr("At({}, {})".format(c, ap))] load_action = Action( expr("Load({}, {}, {})".format(c, p, ap)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load_action) return loads
def fly_actions(): """Create all concrete Fly actions and return a list :return: list of Action objects """ flys = [] for fr in self.airports: for to in self.airports: if fr != to: for p in self.planes: precond_pos = [ expr("At({}, {})".format(p, fr)), ] precond_neg = [] effect_add = [expr("At({}, {})".format(p, to))] effect_rem = [expr("At({}, {})".format(p, fr))] fly = Action( expr("Fly({}, {}, {})".format(p, fr, to)), [precond_pos, precond_neg], [effect_add, effect_rem]) flys.append(fly) return flys
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ all_cargos_planes_airports = ((cargo, plane, airport) for cargo in self.cargos for plane in self.planes for airport in self.airports) unload_actions_list = [] for cargo, plane, airport in all_cargos_planes_airports: precond_pos = [ expr("In({}, {})".format(cargo, plane)), expr("At({}, {})".format(plane, airport)) ] precond_neg = [] effect_add = [expr("At({}, {})".format(cargo, airport))] effect_rem = [expr("In({}, {})".format(cargo, plane))] unload = Action( expr("Unload({}, {}, {})".format(cargo, plane, airport)), [precond_pos, precond_neg], [effect_add, effect_rem]) unload_actions_list.append(unload) return unload_actions_list
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ # TODO create all load ground actions from the domain Load action # Action(Load(C, P, A)): # PRECOND: At(C, A) ^ At(P, A) ^ Cargo(C) ^ Plane(P) ^ Airport(A) # EFFECT : In(C, P) ^ ¬At(C, A) ^ Cargo(C) ^ Plane(P) ^ Airport(A) # iterate over all origin and destination airports, planes and cargo, creating concrete action objects loads = [] for cargo in self.cargos: for plane in self.planes: for airport in self.airports: fluent = expr("Load({}, {}, {})".format( cargo, plane, airport)) preconds_pos = [ expr("At({}, {})".format(cargo, airport)), expr("At({}, {})".format(plane, airport)) ] preconds_neg = [] effects_add = [expr("In({}, {})".format(cargo, plane))] effects_rem = [ expr("At({}, {})".format(cargo, airport)) ] preconds = [preconds_pos, preconds_neg] effects = [effects_add, effects_rem] load = Action(fluent, preconds, effects) loads.append(load) return loads
def unload_actions(): """Create all concrete Unload actions and return a list Action(Unload(c, p, a), PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) EFFECT: At(c, a) ∧ ¬ In(c, p)) :return: list of Action objects """ unloads = [] # create combinations of all cargos, planes and airports # to generate all possible unload actions for cargo in self.cargos: for plane in self.planes: for airport in self.airports: # generate action precodnitions and effects # in predefined format (see method docs) precond_pos = [ expr("In({}, {})".format(cargo, plane)), expr("At({}, {})".format(plane, airport)) ] precond_neg = [] effect_add = [ expr("At({}, {})".format(cargo, airport)) ] effect_rem = [expr("In({}, {})".format(cargo, plane))] # create action and append it to all other unload actions unload = Action( expr("Unload({}, {}, {})".format( cargo, plane, airport)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def load_actions(): '''Create all concrete Load actions and return a list :return: list of Action objects ''' loads = [] # TODO create all load ground actions from the domain Load action for a in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr('At({}, {})'.format(c, a)), expr('At({}, {})'.format(p, a)), ] precond_neg = [] effect_add = [expr('In({}, {})'.format(c, p))] effect_rem = [expr('At({}, {})'.format(c, a))] load_action = Action( expr('Load({}, {}, {})'.format(c, a, p)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load_action) return loads
def load_actions(): '''Create all concrete Load actions and return a list Action(Load(c, p, a), PRECOND: At(c, a) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) EFFECT: ¬ At(c, a) ∧ In(c, p)) :return: list of Action objects ''' loads = [] # TODO create all load ground actions from the domain Load action for a in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("At({}, {})".format(p, a)), expr("At({}, {})".format(c, a)), ] precond_neg = [] effect_add = [expr("In({}, {})".format(c, p))] effect_rem = [expr("At({}, {})".format(c, a))] load = Action(expr("Load({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads
def unload_actions(): """Create all concrete Unload actions and return a list Action(Unload(c, p, a), PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) EFFECT: At(c, a) ∧ ¬ In(c, p)) :return: list of Action objects """ unloads = [] for c in self.cargos: for a in self.airports: for p in self.planes: precond_pos = [ expr("At({}, {})".format(p, a)), expr("In({}, {})".format(c, p)) ] precond_neg = [] effect_add = [expr("At({}, {})".format(c, a))] effect_rem = [expr("In({}, {})".format(c, p))] unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def unload_actions(): '''Create all concrete Unload actions and return a list :return: list of Action objects ''' unloads = [] for cargo, plane, airport in product(self.cargos, self.planes, self.airports): precond_pos = [ expr(f"In({cargo}, {plane})"), expr(f"At({plane}, {airport})") ] precond_neg = [] effect_add = [expr(f"At({cargo}, {airport})")] effect_rem = [expr(f"In({cargo}, {plane})")] unload = Action(expr(f"Unload({cargo}, {plane}, {airport})"), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ loads = [] # TODO create all load ground actions from the domain Load action ####Implement this function for a in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("At({}, {})".format(p, a)), expr("At({}, {})".format(c, a)), ] precond_neg = [] effect_add = [expr("In({}, {})".format(c, p))] effect_rem = [expr("At({}, {})".format(c, a))] load = Action(expr("Load({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ loads = [] cargos = self.cargos planes = self.planes airports = self.airports for i in range(len(self.cargos)): for j in range(len(self.planes)): for k in range(len(self.airports)): #ca_index = self.state_map.index(expr("At({}, {})".format(cargos[i], airports[k]))) #if self.initial_state_TF[ca_index] == 'T': #pa_index = self.state_map.index(expr("At({}, {})".format(planes[j], airports[k]))) #if self.initial_state_TF[pa_index] == 'T': precond_pos = [ expr("At({}, {})".format(cargos[i], airports[k])), expr("At({}, {})".format(planes[j], airports[k])) ] precond_neg = [] #precond_neg = [expr("In({}, {})".format(cargos[i], planes[j]))] effect_add = [ expr("In({}, {})".format(cargos[i], planes[j])) ] effect_rem = [ expr("At({}, {})".format(cargos[i], airports[k])) ] load = Action( expr("Load({}, {}, {})".format( cargos[i], planes[j], airports[k])), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads
def unload_actions(): '''Create all concrete Unload actions and return a list :return: list of Action objects ''' unloads = [] for element in itertools.product(self.cargos, self.planes, self.airports): cargo, plane, airport = element precond_pos = [expr("%s(%s,%s)"%(self._AT, plane, airport))] precond_pos.append(expr("%s(%s,%s)"%(self._IN, cargo, plane))) precond_pos.append(expr("%s(%s)"%(self._CARGO, cargo))) precond_pos.append(expr("%s(%s)"%(self._AIRPORT, airport))) precond_pos.append(expr("%s(%s)"%(self._PLANE, plane))) precond_neg = [] effect_add = [expr("%s(%s,%s)"%(self._AT, cargo, airport))] effect_rem = [expr("%s(%s,%s)"%(self._IN, cargo, plane))] action_e = expr("%s(%s,%s)"%(self._UNLOAD, cargo, plane)) action = Action(action_e, [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(action) return unloads
def fly_actions(): '''Create all concrete Fly actions and return a list :return: list of Action objects ''' flys = [] for element in itertools.product(self.planes, self.airports, self.airports): plane, from_a, to_a = element if from_a == to_a: continue; precond_pos = [expr("%s(%s,%s)"%(self._AT, plane, from_a))] precond_pos.append(expr("%s(%s)"%(self._PLANE, plane))) precond_pos.append(expr("%s(%s)"%(self._AIRPORT, to_a))) precond_pos.append(expr("%s(%s)"%(self._AIRPORT, from_a))) precond_neg = [] effect_rem = [expr("%s(%s,%s)"%(self._AT, plane, from_a))] effect_add = [expr("%s(%s,%s)"%(self._AT, plane, to_a))] action_e = expr("%s(%s,%s,%s)"%(self._FLY, plane, from_a, to_a)) action = Action(action_e, [precond_pos, precond_neg], [effect_add, effect_rem]) flys.append(action) return flys
def unload_actions(): """Create all concrete Unload actions as a list: Unload(c, p, a), PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) EFFECT: At(c, a) ∧ ¬ In(c, p) :return: list of Action objects """ unloads = [] for airport in self.airports: for plane in self.planes: for cargo in self.cargos: precond_pos = [ expr("In({},{})".format(cargo, plane)), expr("At({},{})".format(plane, airport)) ] precond_neg = [] effect_pos = [expr("At({},{})".format(cargo, airport))] effect_rem = [expr("In({},{})".format(cargo, plane))] action = expr("Unload({},{},{})".format( cargo, plane, airport)) unload = Action(action, [precond_pos, precond_neg], [effect_pos, effect_rem]) unloads.append(unload) return unloads
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ loads = [] # TODO create all load ground actions from the domain Load action # Form triplets of cargo, planes, airports cta_list = [(cur_cargo, cur_plane, cur_airport) for cur_airport in self.airports for cur_plane in self.planes for cur_cargo in self.cargos] # Build all possible actions for cargo, plane, air in cta_list: # Positive preconditions # (no negative preconditions) pos_prec = [ expr("At({}, {})".format(cargo, air)), expr("At({}, {})".format(plane, air)) ] add_effect = [expr("In({}, {})".format(cargo, plane))] rem_effect = [expr("At({}, {})".format(cargo, air))] # Empty list for negative preconditions # Build complete Action cur_load = Action( expr("Load({}, {}, {})".format(cargo, plane, air)), [pos_prec, []], [add_effect, rem_effect]) loads.append(cur_load) return loads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ # initialize unloads list unloads = [] # TODO create all Unload ground actions from the domain Unload action # for each cargo for c in self.cargos: # for each plane for p in self.planes: # for each airport for a in self.airports: # PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) precond_pos = [ expr("In({}, {})".format(c, p)), expr("At({}, {})".format(p, a)) ] # precondition negative precond_neg = [] # EFFECT: At(c, a) ∧ ¬ In(c, p)) # effect add, cargo at airport, At(c, a) effect_add = [expr("At({}, {})".format(c, a))] # effect remove, cargo not in plane, ¬ In(c, p) effect_rem = [expr("In({}, {})".format(c, p))] # action unload(cargo, plane, airport), preconditions, effects unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) # append unload action objects unloads.append(unload) # return list of unload action objects return unloads
def load_actions(): '''Create all concrete Load actions and return a list :return: list of Action objects ''' loads = [] # Get all combinations of cargo, airports, and planes for cargo, plane, airport in product(self.cargos, self.planes, self.airports): precond_pos = [ expr(f"At({cargo}, {airport})"), expr(f"At({plane}, {airport})") ] precond_neg = [] effect_add = [expr(f"In({cargo}, {plane})")] effect_rem = [expr(f"At({cargo}, {airport})")] load = Action(expr(f"Load({cargo}, {plane}, {airport})"), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ unloads = [] all_pairs = [(cargo, plane, airport) for cargo in self.cargos for plane in self.planes for airport in self.airports] for (cargo, plane, airport) in all_pairs: precond_pos = [ expr("In({}, {})".format(cargo, plane)), expr("At({}, {})".format(plane, airport)) ] precond_neg = [] effect_add = [expr("At({}, {})".format(cargo, airport))] effect_rem = [expr("In({}, {})".format(cargo, plane))] action = Action( expr("Unload({}, {}, {})".format(cargo, plane, airport)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(action) return unloads
def load_actions(): '''Create all concrete Load actions and return a list :return: list of Action objects ''' loads = [] for cargo in self.cargos: for plane in self.planes: for airport in self.airports: precond_pos = [ expr("At({}, {})".format(cargo, airport)), expr("At({}, {})".format(plane, airport)) ] precond_neg = [] effect_add = [expr("In({}, {})".format(cargo, plane))] effect_rem = [ expr("At({}, {})".format(cargo, airport)) ] load = Action( expr("Load({}, {}, {})".format( cargo, plane, airport)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ unloads = [] # TODO create all Unload ground actions from the domain Unload action for apt in self.airports: for pl in self.planes: for crg in self.cargos: precond_pos = [ expr("At({},{})".format(pl, apt)), expr("In({},{})".format(crg, pl)) ] precond_neg = [] effect_add = [expr("At({},{})".format(crg, apt))] #effect_rem = [expr("At({},{})".format(pl, apt))] effect_rem = [expr("In({},{})".format(crg, pl))] unload_act = Action( expr("Unload({},{},{})".format(crg, pl, apt)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload_act) return unloads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ # TODO create all Unload ground actions from the domain Unload action # Action(Unload(c, p, a), # PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a) # EFFECT: At(c, a) ∧ ¬ In(c, p)) # iterate over all origin and destination airports planes and cargo, creating concrete action objects unloads = [] for cargo in self.cargos: for plane in self.planes: for airport in self.airports: fluent = expr("Unload({}, {}, {})".format( cargo, plane, airport)) preconds_pos = [ expr("In({}, {})".format(cargo, plane)), expr("At({}, {})".format(plane, airport)) ] preconds_neg = [] effects_add = [ expr("At({}, {})".format(cargo, airport)) ] effects_rem = [expr("In({}, {})".format(cargo, plane))] preconds = [preconds_pos, preconds_neg] effects = [effects_add, effects_rem] unload = Action(fluent, preconds, effects) unloads.append(unload) return unloads
def unload_actions(): """Create all concrete Unload actions Returns ------- collection of Action objects """ unloads = [] for c in self.cargos: for p in self.planes: for a in self.airports: precond_pos = set([ expr("In({}, {})".format(c, p)), expr("At({}, {})".format(p, a)), ]) precond_neg = set([]) effect_add = set([expr("At({}, {})".format(c, a))]) effect_rem = set([expr("In({}, {})".format(c, p))]) unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def fly_actions(): '''Create all concrete Fly actions and return a list Action(Fly(p, from, to), PRECOND: At(p, from) ∧ Plane(p) ∧ Airport(from) ∧ Airport(to) EFFECT: ¬ At(p, from) ∧ At(p, to)) :return: list of Action objects ''' flys = [] for fr in self.airports: for to in self.airports: if fr != to: for p in self.planes: precond_pos = [ expr("At({}, {})".format(p, fr)), ] precond_neg = [] effect_add = [expr("At({}, {})".format(p, to))] effect_rem = [expr("At({}, {})".format(p, fr))] fly = Action( expr("Fly({}, {}, {})".format(p, fr, to)), [precond_pos, precond_neg], [effect_add, effect_rem]) flys.append(fly) return flys
def fly_actions(): """Create all concrete Fly actions Returns ------- collection of Action objects """ flys = [] for fr in self.airports: for to in self.airports: if fr != to: for p in self.planes: precond_pos = set([expr("At({}, {})".format(p, fr)), \ ]) precond_neg = set([]) effect_add = set( [expr("At({}, {})".format(p, to))]) effect_rem = set( [expr("At({}, {})".format(p, fr))]) fly = Action(expr("Fly({}, {}, {})".format(p, fr, to)), \ [precond_pos, precond_neg], \ [effect_add, effect_rem]) flys.append(fly) return flys
def unload_actions(): '''Create all concrete Unload actions and return a list :return: list of Action objects ''' unloads = [] for fr in self.airports: for p in self.planes: for c in self.cargos: precond_pos = [ expr("At({}, {})".format(p, fr)), expr("In({}, {})".format(c, p)), ] precond_neg = [] effect_add = [expr("At({}, {})".format(c, fr))] effect_rem = [expr("In({}, {})".format(c, p))] unload = Action( expr("Unload({}, {}, {})".format(c, p, fr)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) return unloads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ unloads = [] # create all Unload ground actions from the domain Unload action for c in self.cargos: for p in self.planes: for a in self.airports: precond_pos = [ expr("In({}, {})".format(c, p)), expr("At({}, {})".format(p, a)) ] precond_neg = [] effect_add = [expr("At({}, {})".format(c, a))] effect_rem = [expr("In({}, {})".format(c, p))] unload = Action( expr("Unload({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) unloads.append(unload) #print("# of unloads:",len(set([(unload.name,unload.args) for unload in unloads]))) return unloads
def unload_actions(): """Create all concrete Unload actions and return a list :return: list of Action objects """ unloads = [] # TODO create all Unload ground actions from the domain Unload action for cargo in self.cargos: for airoport in self.airports: for plane in self.planes: precond_pos = [ expr("In({}, {})".format(cargo, plane)), expr("At({},{})".format(plane, airoport)) ] effect_add = [ expr("At({},{})".format(cargo, airoport)) ] effect_rem = [expr("In({},{})".format(cargo, plane))] unloads.append( Action( expr("Unload({},{},{})".format( cargo, plane, airoport)), [precond_pos, []], [effect_add, effect_rem])) return unloads
def load_actions(): """Create all concrete Load actions and return a list :return: list of Action objects """ loads = [] for a in self.airports: for p in self.planes: for c in self.cargos: # cargo c and plane p must be on airport a, cargo c, plane p, and airport must be exist precond_pos = [ expr('At({}, {})'.format(c, a)), expr('At({}, {})'.format(p, a)) ] precond_neg = [] # load cargo c to plane p effect_add = [expr('In({}, {})'.format(c, p))] # remove cargo c from airport a effect_rem = [expr('At({}, {})'.format(c, a))] load = Action(expr("Load({}, {}, {})".format(c, p, a)), [precond_pos, precond_neg], [effect_add, effect_rem]) loads.append(load) return loads