def calloptionMC(spot,strike,vol,T,Rf,M,alpha): ''' call option using Monte Carlo simulation returns option price and lower and upper bounds ''' S = np.zeros(M) S = spot * np.exp( (Rf - 0.5*vol**2)*T + vol * math.sqrt(T) * random.randn(M)) Carray = np.exp(-Rf * T) * np.maximum(S - strike, 0) c = np.average(Carray) c_std = np.std(Carray) / math.sqrt(M) bounds = c + np.array([-1,1]) * stats.norm.ppf(0.5 + alpha/2) * c_std return c, bounds
def optionBS(spot,strike, vol, T, Rf): ''' call option using Black Scholes ''' denom = vol * math.sqrt(T) d1 = (math.log(spot/strike) + (Rf + 0.5*vol**2)*T) / denom d2 = d1 - denom call = spot * stats.norm.cdf(d1) - strike * math.exp(-Rf * T) * stats.norm.cdf(d2) put = strike * math.exp(-Rf * T) * stats.norm.cdf(-d2) - spot * stats.norm.cdf(-d1) return call, put
def get_feature_vector(trajectory, hf, mf, fa): pois = [gps2grid(22.639444, 113.810833), gps2grid(22.534167, 114.111667)] # airport, train station. feature = np.zeros(11) plate = trajectory[0][0] bl = list(map(int, mf[plate].split('|'))) hl = gps2grid(hl_plates[plate][1], hl_plates[plate][0]) bt = bt_plates[plate][0] // (60 * 5) + 1 last_step = [] for i in range(len(trajectory)): step = trajectory[i] ind = '|'.join(map(str, step[1:])) if ind in fa[plate]: fml = fa[plate][ind] else: fml = 0 db = math.sqrt((bl[0] - step[1])**2 + (bl[1] - step[2])**2) dp = [ math.sqrt((poi[0] - step[1])**2 + (poi[1] - step[2])**2) for poi in pois ] dh = math.sqrt((hl[0] - step[1])**2 + (hl[1] - step[2])**2) dt = step[3] - bt try: f = deepcopy(hf[ind])[:-1] except: f = [0, 0, 0, 0] f.extend(dp) f.extend([fml, db, dh, dt]) if i > 0 and last_step[1] == step[1] and last_step[2] == step[2]: f.append(1) else: f.append(0) fea = np.array(f) feature += fea last_step = step return feature
def rhombus(): fig = plot.figure() p = int(input("CALC -> Please enter the first diagonal length: ")) q = int(input("CALC -> Please enter the second diagonal length: ")) area = (p*q) / 2 perimeter = 2 * math.sqrt(p**2 + q**2) print("CALC -> Area = 1/2 * (diagonal 1) * (diagonal 2) = %.3f" %area) print("CALC -> Perimeter = 2 * sqrt((diagonal 1)^2 + (diagonal 2)^2) = %.3f" %perimeter) p1 = (0, p/2) p2 = (q/2, p) p3 = (q, p/2) p4 = (q/2, 0) tri = patches.Polygon([p1,p2,p3,p4], closed=True,fill=True) sub = fig.add_subplot(111, aspect= 'equal') sub.add_patch(tri) plot.ylim(0, p + 5) plot.xlim(0, q + 5) plot.show()
def triangle(): print("CALC -> Please enter the base length: ") b = int(input("CALC -> ")) print("CALC -> Please enter the height: ") h = int(input("CALC -> ")) fig = plot.figure() area = (1/2)* b * h perimeter = b + h + math.sqrt(h**2 + b**2) print("CALC -> Area = 1/2 * base * height = %.3f" %area) print("CALC -> Perimeter = base + height + sqrt(base^2 + height^2) = %.3f" %perimeter) p1 = (0, h) p2 = (0, 0) p3 = (b, 0) tri = patches.Polygon([p1,p2,p3], closed=True,fill=True) sub = fig.add_subplot(111, aspect= 'equal') sub.add_patch(tri) plot.ylim(0, h + 5) plot.xlim(0, b+ 5) plot.show()
def RMSE(test, predicted): rmse = math.sqrt(mean_squared_error(test, predicted)) return rmse
def grasp_callback(my_grasp): ## Planning to a Pose goal ## ^^^^^^^^^^^^^^^^^^^^^^^ ## We can plan a motion for this group to a desired pose for the ## end-effector pose_target = geometry_msgs.msg.PoseStamped() pose_target.header.stamp = my_grasp.markers[0].header.stamp.secs pose_target.header.frame_id = "/camera_rgb_optical_frame" pose_target.pose.position.x = my_grasp.markers[0].points[1].x pose_target.pose.position.y = my_grasp.markers[0].points[1].y pose_target.pose.position.z = my_grasp.markers[0].points[1].z ## Convert to quaternion u = [1, 0, 0] norm = linalg.norm([ my_grasp.markers[0].points[0].x - my_grasp.markers[0].points[1].x, my_grasp.markers[0].points[0].y - my_grasp.markers[0].points[1].y, my_grasp.markers[0].points[0].z - my_grasp.markers[0].points[1].z ]) v = asarray([ my_grasp.markers[0].points[0].x - my_grasp.markers[0].points[1].x, my_grasp.markers[0].points[0].y - my_grasp.markers[0].points[1].y, my_grasp.markers[0].points[0].z - my_grasp.markers[0].points[1].z ]) / norm if (array_equal(u, v)): pose_target.pose.orientation.w = 1 pose_target.pose.orientation.x = 0 pose_target.pose.orientation.y = 0 pose_target.pose.orientation.z = 0 elif (array_equal(u, negative(v))): pose_target.pose.orientation.w = 0 pose_target.pose.orientation.x = 0 pose_target.pose.orientation.y = 0 pose_target.pose.orientation.z = 1 else: half = [u[0] + v[0], u[1] + v[1], u[2] + v[2]] pose_target.pose.orientation.w = dot(u, half) temp = cross(u, half) pose_target.pose.orientation.x = temp[0] pose_target.pose.orientation.y = temp[1] pose_target.pose.orientation.z = temp[2] norm = math.sqrt( pose_target.pose.orientation.x * pose_target.pose.orientation.x + pose_target.pose.orientation.y * pose_target.pose.orientation.y + pose_target.pose.orientation.z * pose_target.pose.orientation.z + pose_target.pose.orientation.w * pose_target.pose.orientation.w) if norm == 0: norm = 1 pose_target.pose.orientation.x = pose_target.pose.orientation.x / norm pose_target.pose.orientation.y = pose_target.pose.orientation.y / norm pose_target.pose.orientation.z = pose_target.pose.orientation.z / norm pose_target.pose.orientation.w = pose_target.pose.orientation.w / norm print "Timestamp: %d." % pose_target.header.stamp print "Position X: %f." % pose_target.pose.position.x print "Position Y: %f." % pose_target.pose.position.y print "Position Z: %f." % pose_target.pose.position.z print "Orientation X: %f." % pose_target.pose.orientation.x print "Orientation Y: %f." % pose_target.pose.orientation.y print "Orientation Z: %f." % pose_target.pose.orientation.z print "Orientation W: %f." % pose_target.pose.orientation.w ## Broadcast transform br = tf.TransformBroadcaster() br.sendTransform( (pose_target.pose.position.x, pose_target.pose.position.y, pose_target.pose.position.z), (pose_target.pose.orientation.x, pose_target.pose.orientation.y, pose_target.pose.orientation.z, pose_target.pose.orientation.w), my_grasp.markers[0].header.stamp, "/grasping_target", "/camera_rgb_optical_frame") #br.sendTransform((pose_target.pose.position.x, pose_target.pose.position.y, pose_target.pose.position.z), tf.transformations.quaternion_from_euler(my_grasp.grasps[0].axis.x, my_grasp.grasps[0].axis.y, my_grasp.grasps[0].axis.z), my_grasp.header.stamp, "/grasping_target", "/camera_rgb_optical_frame") ## Listening to transform (trans, rot) = listener.lookupTransform('/world', '/grasping_target', rospy.Time(0)) ## Build new pose pose_target_trans = geometry_msgs.msg.PoseStamped() pose_target_trans.header.frame_id = "/world" pose_target_trans.header.stamp = my_grasp.markers[0].header.stamp pose_target_trans.pose.position.x = trans[0] pose_target_trans.pose.position.y = trans[1] pose_target_trans.pose.position.z = trans[2] pose_target_trans.pose.orientation.x = rot[0] pose_target_trans.pose.orientation.y = rot[1] pose_target_trans.pose.orientation.z = rot[2] pose_target_trans.pose.orientation.w = rot[3] print "NEW POSITION." print "Position X: %f." % pose_target_trans.pose.position.x print "Position Y: %f." % pose_target_trans.pose.position.y print "Position Z: %f." % pose_target_trans.pose.position.z print "Orientation X: %f." % pose_target_trans.pose.orientation.x print "Orientation Y: %f." % pose_target_trans.pose.orientation.y print "Orientation Z: %f." % pose_target_trans.pose.orientation.z print "Orientation W: %f." % pose_target_trans.pose.orientation.w my_grasp_pub.publish(pose_target_trans) group.set_pose_target(pose_target_trans.pose, end_effector_link="my_eef") ## Now, we call the planner to compute the plan ## and visualize it if successful ## Note that we are just planning, not asking move_group ## to actually move the robot # group.set_planner_id("RRTstarkConfigDefault") # group.allow_replanning(True) ## Planning with collision detection can be slow. Lets set the planning time ## to be sure the planner has enough time to plan around the box. 10 seconds ## should be plenty. # group.set_planning_time(5.0) plan1 = group.plan() ## Moving to a pose goal ## ^^^^^^^^^^^^^^^^^^^^^ ## ## Moving to a pose goal is similar to the step above ## except we now use the go() function. Note that ## the pose goal we had set earlier is still active ## and so the robot will try to move to that goal. We will ## not use that function in this tutorial since it is ## a blocking function and requires a controller to be active ## and report success on execution of a trajectory. # Uncomment below line when working with a real robot # group.go(wait=True) print "============ DONE PLANNING ============" sys.exit("DONE PLANNING") ## Sleep to give Rviz time to visualize the plan. */ rospy.sleep(5) group.clear_pose_targets()
estimates = [] for i in range(0, ntrials): # toy generation toys = [] for it in range(0, nt): toys.append(rnd.Poisson(mu0)) # LH estimate result = optimize.fmin(lh_poisson, mu0, args=(toys, ), disp=False) estimates.append(result) # compute the mean, variance, bias means.append(numpy.mean(estimates)) variances.append(numpy.var(estimates)) biases.append(numpy.mean(estimates) - mu0) dmeans.append(math.sqrt(variances[-1] / ntrials)) dvariances.append(math.sqrt(2 * variances[-1]**2 / (ntrials - 1))) # plot results nx = len(ntoys) c1 = ROOT.TCanvas("c1", "Mean") gmean = ROOT.TGraphErrors(nx, array('d', ntoys), array('d', means), array('d', dntoys), array('d', dmeans)) gmean.Draw("ALP") c1.Draw() c1.SaveAs("c1.pdf") c2 = ROOT.TCanvas("c2", "Variance") gvar = ROOT.TGraphErrors(nx, array('d', ntoys), array('d', variances), array('d', dntoys), array('d', dvariances)) gvar.Draw("ALP")
def func(x): t = math.log10(self.pipe.epsilon / (3.7 * self.pipe.D) + 2.51 / (max(self.Re) * math.sqrt(x))) return 1 / math.sqrt(x) + 2 * t
def get_distance(self, x1, y1, x2, y2): return math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
def get_distance(p1, p2): return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
def is_prime(n): for i in range(2, int(math.sqrt(n)) + 1): if n % i == 0: return False return True
############## # PARAMETERS # ############## mu0=3.5 ntrials=1000 ################ # MAIN PROGRAM # ################ # derived constants xmin=max(0,int(mu0-5.*math.sqrt(mu0))) xmax=int(mu0+5.*math.sqrt(mu0)) nbins=xmax-xmin # lists to be used to plot the graphs ntoys = [] dntoys = [] crbounds = [] # list of methods means = {} variances = {} methods = ["moments","MLE"] for meth in methods: means[meth] = 0
def protectedSqrt(root): return math.sqrt(abs(root))
def grasp_callback(my_grasp): my_pose = geometry_msgs.msg.PoseStamped() my_pose.header.stamp = my_grasp.markers[0].header.stamp my_pose.header.frame_id = "/xtion_rgb_optical_frame" pose_target = geometry_msgs.msg.Pose() pose_target.position.x = my_grasp.markers[0].points[0].x pose_target.position.y = my_grasp.markers[0].points[0].y pose_target.position.z = my_grasp.markers[0].points[0].z ## Convert to quaternion u = [1, 0, 0] norm = linalg.norm([ my_grasp.markers[i].points[0].x - my_grasp.markers[0].points[1].x, my_grasp.markers[0].points[0].y - my_grasp.markers[0].points[1].y, my_grasp.markers[0].points[0].z - my_grasp.markers[0].points[1].z ]) v = asarray([ my_grasp.markers[0].points[0].x - my_grasp.markers[0].points[1].x, my_grasp.markers[0].points[0].y - my_grasp.markers[0].points[1].y, my_grasp.markers[0].points[0].z - my_grasp.markers[0].points[1].z ]) / norm if (array_equal(u, v)): pose_target.orientation.w = 1 pose_target.orientation.x = 0 pose_target.orientation.y = 0 pose_target.orientation.z = 0 elif (array_equal(u, negative(v))): pose_target.orientation.w = 0 pose_target.orientation.x = 0 pose_target.orientation.y = 0 pose_target.orientation.z = 1 else: half = [u[0] + v[0], u[1] + v[1], u[2] + v[2]] pose_target.orientation.w = dot(u, half) temp = cross(u, half) pose_target.orientation.x = temp[0] pose_target.orientation.y = temp[1] pose_target.orientation.z = temp[2] norm = math.sqrt(pose_target.orientation.x * pose_target.orientation.x + pose_target.orientation.y * pose_target.orientation.y + pose_target.orientation.z * pose_target.orientation.z + pose_target.orientation.w * pose_target.orientation.w) if norm == 0: norm = 1 my_pose.pose.orientation.x = pose_target.orientation.x / norm my_pose.pose.orientation.y = pose_target.orientation.y / norm my_pose_.pose.orientation.z = pose_target.orientation.z / norm my_pose.pose.orientation.w = pose_target.orientation.w / norm pose_target_trans = geometry_msgs.msg.PoseStamped() pose_target_trans.header.stamp = pose_target.header.stamp pose_target_trans.header.frame_id = "/map" now = rospy.Time.now() listener.waitForTransform("/map", "/xtion_rgb_optical_frame", now, rospy.Duration(1.0)) pose_target_trans = listener.transformPose("/map", pose_target) my_grasp_pub.publish(pose_target_trans)