def testAStar():
myenv = env.Env('tbl_TrueData', 5)
first = [True for x in range(10)]
while not myenv.end():
for i in range(10):
if not myenv.done[i]:
loc = myenv.locs[i]
if first[i] and myenv.windspeed_at(loc) >= 15.0:
#do not take off
continue
else:
first[i] = False
target = myenv.targets[i]
x, y = (0, 0)
if loc[0] > target[0]:
x = -1
elif loc[1] > target[1]:
y = -1
elif loc[0] < target[0]:
x = 1
elif loc[1] < target[1]:
y = 1
myenv.set_move(i, (x, y))
myenv.tick()
print('score %d time %d remain_task %d' %
(myenv.score, myenv.time, myenv.remain_task))
def __init__(self, s_start, s_goal, step_len, goal_sample_rate,
waypoint_sample_rate, iter_max):
self.s_start = Node(s_start)
self.s_goal = Node(s_goal)
self.step_len = step_len
self.goal_sample_rate = goal_sample_rate
self.waypoint_sample_rate = waypoint_sample_rate
self.iter_max = iter_max
self.vertex = [self.s_start]
self.vertex_old = []
self.vertex_new = []
self.edges = []
self.env = env.Env()
self.plotting = plotting.Plotting(s_start, s_goal)
self.utils = utils.Utils()
self.fig, self.ax = plt.subplots()
self.x_range = self.env.x_range
self.y_range = self.env.y_range
self.obs_circle = self.env.obs_circle
self.obs_rectangle = self.env.obs_rectangle
self.obs_boundary = self.env.obs_boundary
self.obs_add = [0, 0, 0] # [x,y,r]
self.path = []
self.waypoint = []
def make_env(
rank: int,
seed: int,
env_id=None,
**kwargs,
):
kwargs.update(rank=rank, random_seed=seed + rank)
return env.Env(**kwargs)
def __init__(self, xI, xG, obs):
"""
xI: start point
xG: end point
"""
self.xI, self.xG = xI, xG
self.env = env.Env(obs)
self.obs = self.env.obs_map_mod(obs)
def EVAL(ast, _env):
if type(ast) is not list:
return eval_ast(ast, _env)
elif len(ast) == 0: # empty list just return it
return ast
else: # list, evaluate elements
func = ast[0]
if func == "def!": # define a new symbol in environment
return _env.set(ast[1], EVAL(ast[2], _env))
elif func == "let*":
newEnv = env.Env(_env, None, None)
bindings, val = ast[1], ast[2]
for i in range(0, len(bindings), 2):
newEnv.set(
bindings[i],
EVAL(bindings[i + 1], newEnv),
)
retVal = EVAL(val, newEnv)
return retVal
elif func == "do": # evaluate each element of ast (besides the first one)
ast = ast[1:]
evaluated = eval_ast(ast, _env)
return evaluated[-1]
elif func == "if":
ast = ast[1:]
_bool = EVAL(ast[0], _env)
if (
_bool == None or _bool == False
): # if it's false or none evaluate third element or return None if it doesn't exist
if len(ast) < 3: # no third parameter to evaluate
return None
return EVAL(ast[2], _env)
else: # if it's true or anything else, evaluate second element
return EVAL(ast[1], _env)
elif func == "fn*":
ast = ast[1:]
def funcClosure(
*args,
): # return a new function closure. It creates an environment with the inputs as binds to the argument
newEnv = env.Env(_env, ast[0], args)
return EVAL(ast[1], newEnv)
return funcClosure
else: # if it's a symbol
ast = eval_ast(ast, _env)
func = ast[0]
ast = ast[1:]
values = [value for value in ast]
return func(
*values
) # calls the function with the rest of the list as function arguments
def fv(var, symbols):
result = FVTable(var)
for s in symbols:
for c in s.cases:
cc = idClone(c, symbols)
cc.case = c
cc.caseMatch = cc.isSuperType(c, symbols)
result.addCase(s, cc, cc.fv(var, env.Env()))
return result
def __init__(self):
self.env = env.Env()
self.actor = actor()
self.autoencoder_critic, self.encoder, self.critic = CAE_critic()
self.critic_t = clone_model(self.critic); self.critic_t.set_weights(self.critic.get_weights())
self.actor_t = clone_model(self.actor); self.actor_t.set_weights(self.actor.get_weights())
self.memory = deque(maxlen=int(1e+5))
self.goals = np.loadtxt("goals") # list of random goal postitions
self.D_MAX = 6
self.map = Map()
def __init__(self):
self.env = env.Env()
self.delta = 0.00#######要改的，原来是0.5 太大了
self.obs_circle = self.env.obs_circle
self.obs_rectangle = self.env.obs_rectangle
self.obs_boundary = self.env.obs_boundary
self.obs_vertex=[]
self.get_obs_vertex()
self.step = 1
self.keypoints=[]
def type(self, symbols):
envt = env.Env()
lt = self.lhs.type(envt)
rt = self.rhs.type(envt)
llt = symbol.List(None)
llt.arg = lt
lrt = symbol.List(None)
lrt.arg = rt
#this is a bit of a hack, what we really want to do is subst at all levels of list nesting, but we only do one depth here because only one depth is supported in constraints etc.
return self.body.type(symbols).subst(lt, rt, envt, symbols).subst(
llt, lrt, envt, symbols)
def test_sameenv():
"""
Same env
"""
env0 = env.Env()
gc = env.GC(env0)
s = Scope.root_scope()
def _fun(e, y):
val, err, _gc = interp0(parse(y)[0], e, s, s.extend())
gc.extend(_gc)
return val
unittest(lambda: env0, _fun, test_suite)
def __init__(self, s_start, s_goal, res=0.5):
self.res = res
self.s_start = self.pos2ind(s_start)
self.s_goal = self.pos2ind(s_goal)
self.Env = env.Env() # class Env
self.utils = utils.Utils()
self.u_set = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1),
(0, -1), (-1, -1)]
self.OPEN = my_queue.QueuePrior() # priority queue / OPEN set
self.CLOSED = [] # CLOSED set / VISITED order
self.PARENT = dict() # recorded parent
self.g = dict() # cost to come
def __init__(self):
self.env = env.Env()
self.actor = actor()
self.autoencoder_critic, self.encoder, self.critic = CAE_critic_latent(
)
self.critic_t = clone_model(self.critic)
self.critic_t.set_weights(self.critic.get_weights())
self.actor_t = clone_model(self.actor)
self.actor_t.set_weights(self.actor.get_weights())
self.B_pixel = deque(maxlen=int(6e+4)) # pixel-space replay buffer
self.B_latent = deque(maxlen=int(2e+5)) # latent-space replay buffer
self.goals = np.loadtxt("goals") # list of random goal postitions
self.D_MAX = 6
self.map = Map()
def write_seq2(epochs, filename):
f = open(filename, 'wb+')
# origin_cards = ['3', '3', '3', '3', '4', '4', '4', '4', '5', '5', '5', '5',
# '6', '6', '6', '6', '7', '7', '7', '7', '8', '8', '8', '8',
# '9', '9', '9', '9', '10', '10', '10', '10', 'J', 'J', 'J', 'J',
# 'Q', 'Q', 'Q', 'Q', 'K', 'K', 'K', 'K', 'A', 'A', 'A', 'A',
# '2', '2', '2', '2', '*', '$']
origin_cards = [
'3', '3', '3', '3', '4', '4', '4', '4', '5', '5', '5', '5', '6', '6',
'6', '6', '7', '7', '7', '7', '8', '8', '8', '8', '9', '9', '9', '9',
'10', '10', '10', '10', 'J', 'J', 'J', 'J'
]
f.write(len(origin_cards).to_bytes(2, byteorder='little', signed=False))
for i in range(epochs):
cards = origin_cards.copy()
enrivon = env.Env()
random.shuffle(cards)
for c in cards:
if c == '10':
c = '1'
f.write(ord(c).to_bytes(1, byteorder='little', signed=False))
# print(cards)
handcards = [cards[:int(len(cards) / 2)], cards[int(len(cards) / 2):]]
enrivon.reset()
enrivon.prepare2_manual(Card.char2color(cards))
end = False
ind = 0
while not end:
intention, end = enrivon.step2_auto()
put_list = Card.to_cards_from_3_17(intention)
try:
a = next(i for i, v in enumerate(action_space)
if v == put_list)
except StopIteration as e:
print(put_list)
f.write(a.to_bytes(2, byteorder='little', signed=False))
# assert(action_space[a] == put_list)
for c in put_list:
handcards[ind].remove(c)
ind = 1 - ind
# assert((not handcards[0]) or (not handcards[1]))
if i % 1000 == 0:
print("writing %d..." % i)
sys.stdout.flush()
f.close()
print("write completed with %d epochs" % epochs)
def subst(var, symbols):
st = SubstTable(var)
for s in symbols:
for c in s.cases:
if var in c.deepVars():
cc = renameForFresh(c, var.variable)
cc.case = c
cc.caseMatch = cc.isSuperType(c, symbols)
vs = varInBinding(var, c.bindings)
if vs:
for b in vs:
e = env.Env()
cnstr = judge.InTest(None)
cnstr.nt = False
cnstr.lhs = var
cnstr.rhs = b[0]
e[var] = cnstr
st.addCase(s, cc,
cc.subst(var.variable, var, e, symbols),
"where " + str(var) + " in " + str(b[0]))
cnstr.nt = True
st.addCase(
s, cc, cc.subst(var.variable, var, e, symbols),
"where " + str(var) + " not in " + str(b[0]))
else:
st.addCase(s, cc,
cc.subst(var.variable, var, env.Env(), symbols))
if var == c:
fast = ast.Ast(ast.ID, None)
fast.val = var.name
fast.mod = "'"
fresh = symbol.Id(fast, c.parent)
fresh.repr = None
st.addCase(s, fresh, fresh)
return st
def write_seq3(epochs, filename):
f = open(filename, 'wb+')
origin_cards = [
'3', '3', '3', '3', '4', '4', '4', '4', '5', '5', '5', '5', '6', '6',
'6', '6', '7', '7', '7', '7', '8', '8', '8', '8', '9', '9', '9', '9',
'10', '10', '10', '10', 'J', 'J', 'J', 'J', 'Q', 'Q', 'Q', 'Q', 'K',
'K', 'K', 'K', 'A', 'A', 'A', 'A', '2', '2', '2', '2', '*', '$'
]
for i in range(epochs):
cards = origin_cards.copy()
enrivon = env.Env()
lord_id = -1
while lord_id == -1:
random.shuffle(cards)
enrivon.reset()
lord_id = enrivon.prepare_manual(Card.char2color(cards))
for c in cards:
if c == '10':
c = '1'
f.write(ord(c).to_bytes(1, byteorder='little', signed=False))
f.write(lord_id.to_bytes(2, byteorder='little', signed=False))
handcards = [cards[:17], cards[17:34], cards[34:51]]
extra_cards = cards[51:]
handcards[lord_id] += extra_cards
r = 0
ind = lord_id
while r == 0:
intention, r = enrivon.step_auto()
put_list = Card.to_cards_from_3_17(intention)
# print(put_list)
try:
a = next(i for i, v in enumerate(action_space)
if v == put_list)
except StopIteration as e:
print(put_list)
# raise Exception('cards error')
f.write(a.to_bytes(2, byteorder='little', signed=False))
for c in put_list:
handcards[ind].remove(c)
ind = int(ind + 1) % 3
f.write(r.to_bytes(2, byteorder='little', signed=True))
f.close()
print("write completed with %d epochs" % epochs)
def __init__(self, s_start, s_goal, step_len, goal_sample_rate, iter_max):
self.s_start = Node(s_start)
self.s_goal = Node(s_goal)
self.step_len = step_len
self.goal_sample_rate = goal_sample_rate
self.iter_max = iter_max
self.vertex = [self.s_start]
self.env = env.Env()
self.plotting = plotting.Plotting(s_start, s_goal)
self.utils = utils.Utils()
self.x_range = self.env.x_range
self.y_range = self.env.y_range
self.obs_circle = self.env.obs_circle
self.obs_rectangle = self.env.obs_rectangle
self.obs_boundary = self.env.obs_boundary
def __init__(self, s_start, s_goal, e, heuristic_type):
self.s_start, self.s_goal = s_start, s_goal
self.heuristic_type = heuristic_type
self.Env = env.Env() # class Env
self.u_set = self.Env.motions # feasible input set
self.obs = self.Env.obs # position of obstacles
self.e = e # weight
self.g = dict() # Cost to come
self.OPEN = dict() # priority queue / OPEN set
self.CLOSED = set() # CLOSED set
self.INCONS = {} # INCONSISTENT set
self.PARENT = dict() # relations
self.path = [] # planning path
self.visited = [] # order of visited nodes
def fn(*args, params=params, ast=ast):
try:
args = mal_types.List(args)
vargs_index = params.index('&')
params = mal_types.List(params[:vargs_index] + params[vargs_index + 1:])
rest = args[vargs_index:]
args = mal_types.List(args[:vargs_index])
args.append(mal_types.List(rest))
except ValueError:
pass
if_env = env_module.Env(
outer=env,
binds=params,
exprs=args,
)
return EVAL(ast, if_env)
def test_get_attribute(self):
visualiser.VisualiserSwitcher.choose_visualiser("pygame")
args = generate_args(
planner_id="rrt",
map_fname="maps/test.png",
start_pt=np.array([25, 123]),
goal_pt=np.array([225, 42]),
)
args.no_display = True
e = env.Env(args, fixed_seed=0)
# test get planner
assert isinstance(e.planner, Planner)
# test get sampler
assert isinstance(e.sampler, Sampler)
def __init__(self, s_start, s_goal, heuristic_type, eps, res=0.5):
self.res = res
self.s_start = self.pos2ind(s_start)
self.s_goal = self.pos2ind(s_goal)
self.heuristic_type = heuristic_type
self.eps = eps
self.Env = env.Env() # class Env
self.utils = utils.Utils()
self.u_set = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1),
(1, 0), (1, 1)]
self.OPEN = my_queue.HeapDict() # priority queue / OPEN set
self.CLOSED = [] # CLOSED set / VISITED order
self.PARENT = {} # recorded parent
self.INCONS = [] # overconsistent node
self.g = {} # cost to come
def main():
x_start = (2, 2) # Starting node
x_goal = (49, 24) # Goal node
environment = env.Env()
y1_plot = []
y2_plot = []
mean_iter = []
mean_length = []
step_len_list = [1, 2, 4, 8]
for step_len in step_len_list:
for i in range(100):
rrt = Rrt(environment, x_start, x_goal, step_len, 0.10, 10000)
path, nb_iter = rrt.planning()
mean_iter.append(nb_iter)
mean_length.append(get_path_length(path))
if path:
# print('Found path in ' + str(nb_iter) + ' iterations, length : ' + str(get_path_length(path)))
if showAnimation:
rrt.plotting.animation(rrt.vertex, path, "RRT", True)
plotting.plt.show()
else:
print("No Path Found in " + str(nb_iter) + " iterations!")
if showAnimation:
rrt.plotting.animation(rrt.vertex, [], "RRT", True)
plotting.plt.show()
y1_plot.append(sum(mean_iter) / len(mean_iter))
y2_plot.append(sum(mean_length) / len(mean_length))
print("step_len={},mean iter={},mean length={}".format(
step_len,
sum(mean_iter) / len(mean_iter),
sum(mean_length) / len(mean_length)))
plt.subplot(121)
plt.plot(step_len_list, y1_plot, "r-o", label="mean_iter")
plt.xlabel("step len")
plt.ylabel("iter number")
plt.subplot(122)
plt.plot(step_len_list, y2_plot, "b-o", label="mean_length")
plt.xlabel("step len")
plt.ylabel("path length")
plt.show()
def main(self):
awrReportFile = str(
input("Enter the AWR report file name to be analyzed: "))
try:
fName = open(awrReportFile)
except IOError:
print(
"Entered file is not accecible. Please entry correct AWR report."
)
exit()
finally:
fName.close()
htmlFile = open(awrReportFile, 'r', encoding='utf-8')
sourceCode = htmlFile.read()
soup = BeautifulSoup(sourceCode, "lxml")
"Call DB, host and snap detail fetch class by defininig object"
envDetail = env.Env()
envDetail.extractenvinfo(soup)
"Call ADDM and Foreground detail fetch class by defininig object"
addmEventDetails = addmevent.AddmEvent()
addmEventDetails.Addm(soup)
"Call IO profile detail fetch class by defininig object"
ioProfileDetails = ioprofile.IOProfile()
ioProfileDetails.ioprofile(soup)
"Call SQL Order by CPU detail fetch class by defininig object"
cpuOrderByDetails = sqlstats.SqlStats()
cpuOrderByDetails.sqlstatistics(soup)
"Call SQL Order by Elapsed Time detail fetch class by defininig object"
elapsedTimeOrderByDetails = sqlstats.SqlStats()
elapsedTimeOrderByDetails.elapsedsqlstatistics(soup)
"Call SQL Order by User IO detail fetch class by defininig object"
userIOOrderByDetails = sqlstats.SqlStats()
userIOOrderByDetails.iowaitsqlstatistics(soup)
"Call SQL Order by Gets detail fetch class by defininig object"
getsOrderByDetails = sqlstats.SqlStats()
getsOrderByDetails.getssqlstatistics(soup)
"Call SQL Order by Physical Reads detail fetch class by defininig object"
pReadsOrderByDetails = sqlstats.SqlStats()
pReadsOrderByDetails.preadssqlstatistics(soup)
"Call SGA Target Advisory method to conclude"
sgaTargetAdvise = sgatarget.SgaAdvisryTarget()
sgaTargetAdvise.sgatargetadvisory(soup)
def __init__(self):
self.env = env.Env()
self.actor = actor()
self.autoencoder_critic, self.encoder, self.critic = CAE_critic()
self.critic_t = clone_model(self.critic); self.critic_t.set_weights(self.critic.get_weights())
self.actor_t = clone_model(self.actor); self.actor_t.set_weights(self.actor.get_weights())
self.memory = deque(maxlen=int(1e+5))
self.goals = np.loadtxt("goals") # list of random goal postitions
self.D_MAX = 6
self.map = Map()
# gradient of the policy
val = self.critic.output
act = self.critic.input[1]
grad_val2act = tf.gradients(val, act)
outputTensor_a = self.actor.output
grad_val2param = tf.gradients(outputTensor_a[0], self.actor.trainable_weights, grad_val2act[0][0])
self.grad_func = K.function([self.critic.input[0], self.critic.input[1], self.actor.input, K.learning_phase()], grad_val2param)
def test_do_env():
"""
Quote by (do )
"""
env0 = env.Env()
gc = env.GC(env0)
s = Scope.root_scope()
def _fun(e, y):
val, err, _gc = interp0(parse(f"(do {y})")[0], e, s, s.extend())
gc.extend(_gc)
return val
unittest(lambda: env0, _fun, test_suite + \
["(do (def i 100)\
(while (> i 0)\
(do (set i (- i 1))\
(((do ((do (fn (x) (fn (y) (fn (z) (+ x y z))))) 1)) 2) 3)))\
(. (env) __len__))", len(env.Env.buintin_func)])
print(env0.counter)
def __init__(self, step_len, goal_sample_rate, iter_max):
self.step_len = step_len
self.goal_sample_rate = goal_sample_rate
self.iter_max = iter_max
self.env = env.Env()
self.plotting = plotting.Plotting("RRT_CONNECT")
self.utils = utils.Utils()
self.x_range = self.env.x_range
self.y_range = self.env.y_range
self.obs_circle = self.env.obs_circle
self.obs_rectangle = self.env.obs_rectangle
self.obs_boundary = self.env.obs_boundary
self.s_start = Node((0, 0))
self.s_goal = Node((0, 0))
self.path = []
self.key_points = []
def main():
#Config params
world = 1 # two worlds available: 1,2
if world == 1:
s_start = (10, 10)
s_goal = (70, 50)
elif world == 2:
s_start = (5, 5)
s_goal = (35, 25)
label = "2D Dijkstra"
environment = env.Env(world_id=1)
dijkstra = Dijkstra(environment, "euclidean")
plot = Plotter(environment, s_start, s_goal)
path, visited_nodes = dijkstra.get_path(s_start, s_goal)
plot.animate_path_and_visited(label, path, visited_nodes)
def __init__(self, x_start, x_goal):
self.xI, self.xG = x_start, x_goal
self.e = 0.001 # threshold for convergence
self.gamma = 0.9 # discount factor
self.env = env.Env(self.xI, self.xG)
self.motion = motion_model.Motion_model(self.xI, self.xG)
self.plotting = plotting.Plotting(self.xI, self.xG)
self.u_set = self.env.motions # feasible input set
self.stateSpace = self.env.stateSpace # state space
self.obs = self.env.obs_map() # position of obstacles
self.lose = self.env.lose_map() # position of lose states
self.name1 = "policy_iteration, gamma=" + str(self.gamma)
[self.value, self.policy] = self.iteration()
self.path = self.extract_path(self.xI, self.xG, self.policy)
self.plotting.animation(self.path, self.name1)
def __init__(self,
s_start,
s_goal,
obs,
bot_size=[0, 0, 0, 0],
ratio=1,
heuristic_type='manhattan'):
self.s_start = s_start
self.s_goal = s_goal
self.heuristic_type = heuristic_type
self.Env = env.Env(obs, bot_size, ratio) # class env
self.u_set = self.Env.motions
self.obs = self.Env.obs
self.Dstop = 30 # the terminal distance
self.OPEN = [] # priority queque / OPENset
self.ClOSED = [] # visited points
self.PARENT = dict() # the recorded parent
self.g = dict() # cost to come
def __init__(self, x_start, x_goal):
self.xI, self.xG = x_start, x_goal
self.M = 500 # iteration numbers
self.gamma = 0.9 # discount factor
self.alpha = 0.5
self.epsilon = 0.1
self.env = env.Env(self.xI, self.xG)
self.motion = motion_model.Motion_model(self.xI, self.xG)
self.plotting = plotting.Plotting(self.xI, self.xG)
self.u_set = self.env.motions # feasible input set
self.stateSpace = self.env.stateSpace # state space
self.obs = self.env.obs_map() # position of obstacles
self.lose = self.env.lose_map() # position of lose states
self.name1 = "SARSA, M=" + str(self.M)
[self.value, self.policy] = self.Monte_Carlo(self.xI, self.xG)
self.path = self.extract_path(self.xI, self.xG, self.policy)
self.plotting.animation(self.path, self.name1)
def run():
pygame.init()
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MAJOR_VERSION, 4)
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MINOR_VERSION, 1)
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK,
pygame.GL_CONTEXT_PROFILE_CORE)
pygame.display.set_mode((1280, 720), pygame.DOUBLEBUF | pygame.OPENGL)
program = get_program()
groups = obj_loader.load('shangwu', 'part1.obj')
env_obj = env.Env()
arrow_obj = arrow.Arrow()
coord_obj = coord.Coord()
uniform.get_locs(program)
camera_obj = camera.Camera()
running = True
clock = pygame.time.Clock()
while running:
clock.tick(50)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
camera_obj.process_event(event)
uniform.set_view(camera_obj.view)
draw(program, groups)
env_obj.draw()
coord_obj.draw()
pygame.display.flip()
