def algRaySphereIntersection(sphere, ray): b = 2 * (ray.direction.x * (ray.origin.x - sphere.center.x) + ray.direction.y * (ray.origin.y - sphere.center.y) + ray.direction.z * (ray.origin.z - sphere.center.z)) c = square(ray.origin.x - sphere.center.x) + square( ray.origin.y - sphere.center.y) + square(ray.origin.z - sphere.center.z) - sphere.square_radius discriminant = square(b) - 4 * c # The ray misses the sphere if discriminant < 0: return None # The square root of the discriminant is precomputed since # taking the square root is often an expensive operation. sqrt_discriminant = sqrt(discriminant) t0 = (-b - sqrt_discriminant) / 2 # Intersection is not behind the origin of the ray if t0 >= 0: return Vector( array([ ray.origin.x + ray.direction.x * t0, ray.origin.y + ray.direction.y * t0, ray.origin.z + ray.direction.z * t0 ])) else: t1 = (-b + sqrt_discriminant) / 2 return Vector( array([ ray.origin.x + ray.direction.x * t1, ray.origin.y + ray.direction.y * t1, ray.origin.z + ray.direction.z * t1 ]))
def adadelta(allparams, nat_stepsize, num_epochs, seq_len, num_seqs=None, rho=0.95, epsilon=1e-6, num_samples=1, permute=True): natparams, params = allparams[:1], allparams[1:] sum_gsq = zeros_like(params) # accumulated sq. grads sum_usq = zeros_like(params) # accumulated sq. updates accumulate = lambda a, b: add(scale(rho, a), scale(1 - rho, b)) for epoch in xrange(num_epochs): vals = [] batches, num_batches = split_into_batches(data, seq_len, num_seqs) for y in batches: val, grad = scale( 1. / num_datapoints, val_and_grad(y, num_batches, num_samples, *allparams)) natgrad, grad = grad[:1], grad[1:] sum_gsq = accumulate(sum_gsq, square(grad)) diag_scaling = div(sqrt(add_scalar(epsilon, sum_usq)), sqrt(add_scalar(epsilon, sum_gsq))) update = mul(diag_scaling, grad) sum_usq = accumulate(sum_usq, square(update)) natparams = add(natparams, scale(nat_stepsize, natgrad)) params = add(params, update) allparams = concat(natparams, params) vals.append(val) if callback: callback(epoch, vals, natgrad, allparams) return allparams
def raySphereIntersection(sphere, ray): # Origin of ray to center of sphere vector (Origin to Center) oc = sphere.center - ray.origin # Length squared of oc l2oc = oc.dot(oc) outside = l2oc > sphere.square_radius # t-value of point on the ray that is closest to the center of the sphere # (t Closest Approach) tca = oc.dot(ray.direction) # Ray originates outside the sphere and is pointing away from it, # therefore it cannot intersect it if tca < 0 and outside: return None t2ca = square(tca) # Check if the closest point is within the sphere, otherwise the ray misses d2 = square(l2oc - t2ca) t2hc = sphere.square_radius - d2 if t2hc < 0: return None t = tca + sqrt(t2hc) if outside: t = tca - sqrt(t2hc) return Vector( array([ ray.origin.x + ray.direction.x * t, ray.origin.y + ray.direction.y * t, ray.origin.z + ray.direction.z * t ]))
def move(): global T global cnt head = snake[-1].copy() head.move(aim) if head in walls: rectangle(-200, -195, 60, 20, 'white') f timer() ontimer(move, 100) return if head in pwalls: if pwalls.get(head) != None: pwalls[head] -= 1 if pwalls[head] == 0: pwalls.pop(head) walls.add(head) if head in thorns: again() return for body in snake: for i in range(len(lasers)): if cnt > 0 and lasers[i][0].x <= body.x <= lasers[i][1].x and lasers[i][0].y <= body.y <= lasers[i][1].y: again() return if len(foods) == 0: nextstage() return if head in teledict: head = teledict[head] if head in foods: foods.remove(head) else: snake.pop(0) snake.append(head) clear() for body in snake: square(body.x, body.y, 9, 'black') for telep in teledict: square(telep.x, telep.y, 9, 'magenta') square(teledict[telep].x, teledict[telep].y, 9, 'purple') for food in foods: square(food.x, food.y, 9, 'green') for i in range(len(lasers)): if cnt > 0 : line(lasers[i][0].x, lasers[i][0].y+4.5, lasers[i][1].x, lasers[i][1].y+4.5) cnt += 1 if cnt == 10: cnt = -5 for wall in walls: square(wall.x, wall.y, 9, 'gray') for pwall in pwalls: squarenum(pwall.x, pwall.y, 9, 'blue', pwalls[pwall]) for thorn in thorns: triangle(thorn.x, thorn.y, 9, 'red') timer() update() ontimer(move, 100)
def fib_iter(a, b, p, q, count): logl("(" + str(a) + ", " + str(b) + ", " + str(p) + ", " + str(q) + ", " + str(count) + ")") if count == 0: return b elif even(count): return fib_iter(a, b, square(p) + square(q), 2 * p * q + square(q), count / 2) else: return fib_iter((b * q) + (a * q) + (a * p), (b * p) + (a * q), p, q, (count - 1))
def fast_expt(b, n): if n == 0: return 1 elif even(n): return square(fast_expt(b, n / 2)) else: return b * fast_expt(b, n - 1)
def expmod(base, exp, m): if exp == 0: return 1 elif even(exp): return square(expmod(base, exp / 2, m)) % m else: return base * expmod(base, exp - 1, m) % m
def sarsa(amap, gamma, alpha, epsilon, num_episodes, seed): '''SARSA algorithm''' env = gym.make('FrozenLake-v0', desc=util.square(amap)).unwrapped env.seed(seed) np.random.seed(seed) Q = np.zeros([env.observation_space.n, env.action_space.n]) for _ in range(num_episodes): state = env.reset() action = util.select_action(state, Q, epsilon, env) done = False while not done: next_state, reward, done, _ = env.step(action) next_action = util.select_action(next_state, Q, epsilon, env) update = reward + gamma * Q[next_state, next_action] - Q[state, action] Q[state, action] = Q[state, action] + alpha * update state = next_state action = next_action env.close() Q_star = np.argmax(Q, axis=1) mapping = ['<', 'v', '>', '^'] return ''.join([mapping[action] for action in Q_star])
def sqrmod(x): def check_sqrt(x, square): if square == 1 and x != 1 and x != m - 1: return 0 return square return check_sqrt(x, square(x)) % m
def fast_expt(b, n): logl("(" + str(b) + ", " + str(n) + ")") if n == 0: return 1 elif even(n): return square(fast_expt(b, n / 2)) else: return b * fast_expt(b, n - 1)
def find_divisor(n, test_divisor): logl("(" + str(n) + ", " + str(test_divisor) + ")") if square(test_divisor) > n: return n elif divides(test_divisor, n): return test_divisor else: return find_divisor(n, test_divisor + 1)
def expt_iter(a, b, n): logl("(" + str(a) + ", " + str(b) + ", " + str(n) + ")") if n == 0: return a elif even(n): return expt_iter(a, square(b), n / 2) else: return expt_iter(a * b, b, n - 1)
def expmod(base, exp, m): logl("(" + str(base) + ", " + str(exp) + ", " + str(m) + ")") if exp == 0: return 1 elif even(exp): return square(expmod(base, exp / 2, m)) % m else: return base * expmod(base, exp - 1, m) % m
def gardenWindows(): dest=x(width-2850-wallThick) return map(lambda x: window.Window(x)\ .withFrameThickness(150) \ .withBoxDepth(150), [ util.square(x(2850),z(wallMinHeight)).transO(dest), util.faceFromVectors([O,x(2850),xz(2850,heightAt(wallThick)), z(heightAt(2850+wallThick))]) .transO(dest+z(wallMinHeight)) \ ])
def draw_stone_masks(self, im): for i,j in util.square(self.board_size): #print('roi_middle', self.roi_middle) #print('stone roi', self.stone_roi[i,j].shape) roi = im[self.cur_grid[i,j,0]-self.roi_middle: self.cur_grid[i,j,0]+self.roi_middle+1, self.cur_grid[i,j,1]-self.roi_middle: self.cur_grid[i,j,1]+self.roi_middle+1] #print('roi', roi.shape) roi[self.stone_roi[i,j] > 0, :] = 255 return im
def f(x, y): # def f_helper(a, b): # return x * square(a) + y * b + a * b # return f_helper(1 + (x * y), 1 - y) # l = lambda a, b: x * square(a) + y * b + a * b # return l(1 + x * y, 1 - y) a = 1 + (x * y) b = 1 - y return x * square(a) + y * b + a * b
def get_starting_world(): world = [] p = player.get_player() ability = player.get_ability(p) difficulty = util.get_config_var("difficulty") for i in range(util.square(ability) * difficulty): monster = f"Monster {i}" world.append(monster) return world
def initialize(self): cap = cv2.VideoCapture(self.source) if not cap.isOpened(): cap.open() # read a few frames to make sure the camera is self-calibrated for i in range(10): cap.read() # let user position camera print("Position the camera, then hit space.") while cv2.waitKey(20) != ord(' '): ret, img = cap.read() cv2.imshow(self.window_name, img) # find the board grid ret, img = cap.read() self.lines = find_grid.find_grid(img, self.board_size) self.grid = find_grid.get_grid_intersections(self.lines, self.board_size) self.corners = util.get_board_corners(self.grid) rvec, tvec, inliners, t = pose.get_pose(self.corners, self.board_size, self.cam_mtx, self.distortion) self.offsets = pose.compute_offsets(self.grid, self.board_size, t, rvec, tvec, self.cam_mtx, self.distortion) self.corners = np.int32(self.corners) self.offsets = np.int32(self.offsets) board_mask = util.get_board_mask(img.shape[:2], self.corners) self.cap = select_frames.FrameSelector(cap) self.cap.set_roi(None, board_mask) self.cap.initialize() self.finder = find_stones.StoneFinder(self.board_size, self.lines, self.grid, self.black, self.white, self.offsets) self.finder.set_last_gray_image(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)) if self.debug: self.finder.draw_stone_masks(img) for i, j in util.square(self.board_size): pt1, pt2 = tuple(self.grid[i,j,::-1].ravel()), \ tuple(self.offsets[i,j,::-1].ravel()) cv2.line(img, pt1, pt2, (0, 255, 0), 2) cv2.imshow('pose', img) cv2.waitKey(0) cv2.destroyWindow('pose') return True
def test_practice_input_1(self): '''test_practice_input_1''' result = sarsa( 'SFFG', 1.0, 0.24, 0.09, 49553, 202404, ) answer = '<<v<' mapped_answer = util.square(answer) util.logger('Answer policy:', level='high') util.logger(np.array([mapped_answer]).T, level='high') self.assertEqual(result, answer)
def test_practice_input_2(self): '''test_practice_input_2''' result = sarsa( 'SFFFHFFFFFFFFFFG', 1.0, 0.25, 0.29, 14697, 741684, ) answer = '^vv><>>vvv>v>>><' mapped_answer = util.square(answer) util.logger('Answer policy:', level='high') util.logger(np.array([mapped_answer]).T, level='high') self.assertEqual(result, answer)
def test_practice_input_3(self): '''test_practice_input_3''' result = sarsa( 'SFFFFHFFFFFFFFFFFFFFFFFFG', 0.91, 0.12, 0.13, 42271, 983459, ) answer = '^>>>><>>>vvv>>vv>>>>v>>^<' mapped_answer = util.square(answer) util.logger('Answer policy:', level='high') util.logger(np.array([mapped_answer]).T, level='high') self.assertEqual(result, answer)
def adam(allparams, nat_stepsize, stepsize, num_epochs, seq_len, num_seqs=None, b1=0.9, b2=0.999, eps=1e-8, num_samples=1): natparams, params = allparams[:1], allparams[1:] m = zeros_like(params) v = zeros_like(params) i = 0 accumulate = lambda rho, a, b: add(scale(1 - rho, a), scale(rho, b)) for epoch in xrange(num_epochs): vals = [] batches, num_batches = split_into_batches(data, seq_len, num_seqs) for y in batches: val, grad = scale( 1. / num_datapoints, val_and_grad(y, num_batches, num_samples, *allparams)) natgrad, grad = grad[:1], grad[1:] m = accumulate(b1, grad, m) # first moment estimate v = accumulate(b2, square(grad), v) # second moment estimate mhat = scale(1. / (1 - b1**(i + 1)), m) # bias correction vhat = scale(1. / (1 - b2**(i + 1)), v) update = scale(stepsize, div(mhat, add_scalar(eps, sqrt(vhat)))) natparams = add(natparams, scale(nat_stepsize, natgrad)) params = add(params, update) allparams = concat(natparams, params) vals.append(val) i += 1 if callback: callback(epoch, vals, natgrad, allparams) return allparams
def adam(gradfun, allparams, num_iters, step_size, b1=0.9, b2=0.999, eps=1e-8): natparams, params = allparams[:1], allparams[1:] m = zeros_like(params) v = zeros_like(params) i = 0 accumulate = lambda rho, a, b: add(scale(1-rho, a), scale(rho, b)) for i in xrange(num_iters): grad = gradfun(allparams, i) natgrad, grad = grad[:1], grad[1:] m = accumulate(b1, grad, m) # first moment estimate v = accumulate(b2, square(grad), v) # second moment estimate mhat = scale(1./(1 - b1**(i+1)), m) # bias correction vhat = scale(1./(1 - b2**(i+1)), v) update = scale(step_size, div(mhat, add_scalar(eps, sqrt(vhat)))) natparams = sub(natparams, scale(step_size, natgrad)) params = sub(params, update) allparams = concat(natparams, params) return allparams
def sqrt3(x): return fixed_point_of_transform(lambda y: square(y) - x, newton_transform, 1.0)
def sqrt(x): return newtons_method(lambda y: square(y) - x, 1.0)
img = cv2.imread('tests/photos/1.jpg') corners = np.array([[75, 251], [164, 542], [445, 383], [275, 51]], dtype=np.int32) board_size = 9 data = np.load('camera_params.npz') mtx = data['mtx'] #dist = data['dist'] dist = None rvec, tvec, inliers, t = pose.get_pose(corners, board_size, mtx, dist, True) img = pose.draw_pose(img, board_size, corners, t, rvec, tvec, mtx, dist) lines = find_grid.find_grid(img, board_size, corners) grid = find_grid.get_grid_intersections(lines, board_size) offsets = pose.compute_offsets(grid, board_size, t, rvec, tvec, mtx, dist) finder = find_stones.StoneFinder(board_size, lines, grid, np.zeros((0, 2), dtype=np.int32), np.zeros((0, 2), dtype=np.int32), offsets) finder.draw_stone_masks(img) for i, j in util.square(board_size): pt1, pt2 = tuple(grid[i, j, ::-1].ravel()), tuple(offsets[i, j, ::-1].ravel()) cv2.line(img, pt1, pt2, (0, 255, 0), 2) cv2.imshow('pose', img) cv2.waitKey(0) cv2.destroyAllWindows()
def problem_6(max): natural_numbers = range(1, max+1) return square(sum(natural_numbers)) - sum(map(square, natural_numbers))
def n(i): if i == 1: return x else: return -square(x)
setup(600, 600, 370, 0) hideturtle() tracer(False) listen() #stage setting snake = [vector(20, 20)] walls = {vector(100, 0), vector(-100, 0)} pwalls = {vector(150, 0): 5} thorns = {vector(10, 10)} lasers = [[vector(-100, 0), vector(100, 0)]] teledict = {vector(0, 100): vector(0, -100)} foods = {vector(0, 0), vector(50, 50)} for body in snake: square(body.x, body.y, 9, 'black') for telep in teledict: square(telep.x, telep.y, 9, 'magenta') square(teledict[telep].x, teledict[telep].y, 9, 'purple') for food in foods: square(food.x, food.y, 9, 'green') for i in range(len(lasers)): line(lasers[i][0].x, lasers[i][0].y + 4.5, lasers[i][1].x, lasers[i][1].y + 4.5) for wall in walls: square(wall.x, wall.y, 9, 'gray') for pwall in pwalls: squarenum(pwall.x, pwall.y, 9, 'blue', pwalls[pwall]) for thorn in thorns: triangle(thorn.x, thorn.y, 9, 'red') done()
def cubic(a, b, c): return lambda x: cube(x) + a * square(x) + b * x + c
from math import pi, sin import util if __name__ == '__main__': print('8 squared = {}'.format(util.square(8))) val = util.quad(pi) print('pi quad = {:0.6f}'.format(val)) print('sin(pi) = {:0.2f}'.format(sin(pi))) xs = [1, 2, 3, 4] x = 6 if x in xs: print('{} is in {}'.format(x, xs)) else: print('{} is not in {}'.format(x, xs))
def good_enough(guess): return abs(square(guess) - x) < 0.001