def test_array1(self): """ Tests functions with single numpy 1d array output """ def f1(x): # single scalar input return np.array([i*x**i for i in range(5)]) df = jacobian(f1)(3.0) for i, d in enumerate(df): self.assertAlmostEqual(i**2 * 3.0 ** (i - 1), d) def f2(params): # one list, one numpy array input x,y = params[0] A = params[1] return np.linalg.dot(np.sin(A), np.array([x,y**2])) A = np.array([[1.0, 2.0],[3.0, 4.0]]) x,y = 2.0, np.pi params = [[x, y], A] df = jacobian(f2)(params) # df0_dx self.assertAlmostEqual(df[0][0][0], np.sin(A)[0][0]) # df1_dx self.assertAlmostEqual(df[1][0][0], np.sin(A)[1][0]) # df0_dy self.assertAlmostEqual(df[0][0][1], 2*np.sin(A)[0][1]*y) # df1_dy self.assertAlmostEqual(df[1][0][1], 2*np.sin(A)[1][1]*y) # df_dA assert np.linalg.norm(df[0][1][0] - (np.cos(A)*np.array([x,y**2]))[0]) < 1e-10 assert np.linalg.norm(df[1][1][1] - (np.cos(A)*np.array([x,y**2]))[1]) < 1e-10
def fun(input_dict): A = 0. B = 0. for i, (k, v) in enumerate(sorted(input_dict.items(), key=op.itemgetter(0))): A = A + np.sum(np.sin(v)) * (i + 1.0) B = B + np.sum(np.cos(v)) for v in input_dict.values(): A = A + np.sum(np.sin(v)) for k in sorted(input_dict.keys()): A = A + np.sum(np.cos(input_dict[k])) return A + B
def make_pinwheel_data(radial_std, tangential_std, num_classes, num_per_class, rate): rads = np.linspace(0, 2*np.pi, num_classes, endpoint=False) features = npr.randn(num_classes*num_per_class, 2) \ * np.array([radial_std, tangential_std]) features[:,0] += 1. labels = np.repeat(np.arange(num_classes), num_per_class) angles = rads[labels] + rate * np.exp(features[:,0]) rotations = np.stack([np.cos(angles), -np.sin(angles), np.sin(angles), np.cos(angles)]) rotations = np.reshape(rotations.T, (-1, 2, 2)) return 10*npr.permutation(np.einsum('ti,tij->tj', features, rotations))
def make_pinwheel(radial_std, tangential_std, num_classes, num_per_class, rate, rs=npr.RandomState(0)): """Based on code by Ryan P. Adams.""" rads = np.linspace(0, 2*np.pi, num_classes, endpoint=False) features = rs.randn(num_classes*num_per_class, 2) \ * np.array([radial_std, tangential_std]) features[:, 0] += 1 labels = np.repeat(np.arange(num_classes), num_per_class) angles = rads[labels] + rate * np.exp(features[:,0]) rotations = np.stack([np.cos(angles), -np.sin(angles), np.sin(angles), np.cos(angles)]) rotations = np.reshape(rotations.T, (-1, 2, 2)) return np.einsum('ti,tij->tj', features, rotations)
def ackley(x): a, b, c = 20.0, -0.2, 2.0*np.pi len_recip = 1.0/len(x) sum_sqrs = sum(x*x) sum_cos = sum(np.cos(c*x)) return (-a * np.exp(b*np.sqrt(len_recip*sum_sqrs)) - np.exp(len_recip*sum_cos) + a + np.e)
def fun(input_dict): A = 0. B = 0. for i, k in enumerate(sorted(input_dict)): A = A + np.sum(np.sin(input_dict[k])) * (i + 1.0) B = B + np.sum(np.cos(input_dict[k])) return A + B
def plot_gmm(params, ax, num_points=100): angles = np.expand_dims(np.linspace(0, 2*np.pi, num_points), 1) xs, ys = np.cos(angles), np.sin(angles) circle_pts = np.concatenate([xs, ys], axis=1) * 2.0 for log_proportion, mean, chol in zip(*unpack_params(params)): cur_pts = mean + np.dot(circle_pts, chol) ax.plot(cur_pts[:, 0], cur_pts[:, 1], '-')
def build_toy_dataset(D=1, n_data=20, noise_std=0.1): rs = npr.RandomState(0) inputs = np.concatenate([np.linspace(0, 3, num=n_data/2), np.linspace(6, 8, num=n_data/2)]) targets = (np.cos(inputs) + rs.randn(n_data) * noise_std) / 2.0 inputs = (inputs - 4.0) / 2.0 inputs = inputs.reshape((len(inputs), D)) return inputs, targets
def make_pinwheel_data(num_spokes=5, points_per_spoke=40, rate=1.0, noise_std=0.005): """Make synthetic data in the shape of a pinwheel.""" spoke_angles = np.linspace(0, 2 * np.pi, num_spokes + 1)[:-1] rs = npr.RandomState(0) x = np.linspace(0.1, 1, points_per_spoke) xs = np.concatenate([x * np.cos(angle + x * rate) + noise_std * rs.randn(len(x)) for angle in spoke_angles]) ys = np.concatenate([x * np.sin(angle + x * rate) + noise_std * rs.randn(len(x)) for angle in spoke_angles]) return np.concatenate([np.expand_dims(xs, 1), np.expand_dims(ys, 1)], axis=1)
def equa2pixel(self, s_equa): if self.use_wcs: print "using wcs in equa2pixel" return self.wcs.wcs_world2pix(np.atleast_2d(s_equa), 0).squeeze() phi1rad = self.phi_n[1] / 180. * np.pi s_iwc = np.array([ (s_equa[0] - self.phi_n[0]) * np.cos(phi1rad), (s_equa[1] - self.phi_n[1]) ]) s_pix = np.dot(self.Ups_n_inv, s_iwc) + self.rho_n return s_pix
def devec_ackley(x): a, b, c = 20.0, -0.2, 2.0*np.pi len_recip = 1.0/len(x) sum_sqrs, sum_cos = 0.0, 0.0 for i in x: sum_cos += np.cos(c*i) sum_sqrs += i*i return (-a * np.exp(b*np.sqrt(len_recip*sum_sqrs)) - np.exp(len_recip*sum_cos) + a + np.e)
def test_jacobian_higher_order(): fun = lambda x: np.sin(np.outer(x, x)) + np.cos(np.dot(x, x)) jacobian(fun)(npr.randn(3)).shape == (3, 3, 3) jacobian(jacobian(fun))(npr.randn(3)).shape == (3, 3, 3, 3) jacobian(jacobian(jacobian(fun)))(npr.randn(3)).shape == (3, 3, 3, 3, 3) check_grads(lambda x: np.sum(jacobian(fun)(x)), npr.randn(3)) check_grads(lambda x: np.sum(jacobian(jacobian(fun))(x)), npr.randn(3))
def build_toy_dataset(n_data=80, noise_std=0.1): rs = npr.RandomState(0) inputs = np.concatenate([np.linspace(0, 3, num=n_data/2), np.linspace(6, 8, num=n_data/2)]) targets = np.cos(inputs) + rs.randn(n_data) * noise_std inputs = (inputs - 4.0) / 2.0 inputs = inputs[:, np.newaxis] targets = targets[:, np.newaxis] / 2.0 return inputs, targets
def plot_ellipse(ax, alpha, mean, cov, line=None): t = np.linspace(0, 2*np.pi, 100) % (2*np.pi) circle = np.vstack((np.sin(t), np.cos(t))) ellipse = 2.*np.dot(np.linalg.cholesky(cov), circle) + mean[:,None] if line: line.set_data(ellipse) line.set_alpha(alpha) else: ax.plot(ellipse[0], ellipse[1], alpha=alpha, linestyle='-', linewidth=2)
def exp(r): """ matrix exponential under the special orthogonal group SO(3) -> converts Rodrigues 3-vector r into 3x3 rotation matrix R""" theta = np.linalg.norm(r) if (theta == 0): return np.eye(3) K = hat(r / theta) # Compute w/ Rodrigues' formula return np.eye(3) + np.sin(theta) * K + \ (1 - np.cos(theta)) * np.dot(K, K)
def make_pinwheel_data(num_classes, num_per_class, rate=2.0, noise_std=0.001): spoke_angles = np.linspace(0, 2*np.pi, num_classes+1)[:-1] rs = npr.RandomState(0) x = np.linspace(0.1, 1, num_per_class) xs = np.concatenate([rate *x * np.cos(angle + x * rate) + noise_std * rs.randn(num_per_class) for angle in spoke_angles]) ys = np.concatenate([rate *x * np.sin(angle + x * rate) + noise_std * rs.randn(num_per_class) for angle in spoke_angles]) return np.concatenate([np.expand_dims(xs, 1), np.expand_dims(ys,1)], axis=1)
def build_train_dataset(n_data=20, noise_std=0.1): D = 1 rs = npr.RandomState(0) inputs = np.concatenate([np.linspace(0, 3, num=n_data/2), np.linspace(6, 8, num=n_data/2)]) targets = np.cos(inputs) + rs.randn(n_data) * noise_std inputs = (inputs - 4.0) / 4.0 inputs = inputs.reshape((len(inputs), D)) targets = targets.reshape((len(targets), D)) return inputs, targets
def build_toy_dataset(n_data=40, noise_std=0.1): D = 1 rs = npr.RandomState(0) inputs = np.concatenate([np.linspace(0, 2, num=n_data/2), np.linspace(6, 8, num=n_data/2)]) targets = np.cos(inputs) + rs.randn(n_data) * noise_std inputs = (inputs - 5.0) / 4.0 inputs = inputs.reshape((len(inputs), D)) targets = targets.reshape((len(targets), D)) return inputs, targets
def dynamics(z): x, u = z[0:n], z[n:n + m] wheel_angle = x[2] + u[1] s, c = np.sin(wheel_angle), np.cos(wheel_angle) forward_velocity = nominal_velocity + u[0] return np.array([ -forward_velocity * s, forward_velocity * c - nominal_velocity, (forward_velocity / body_length) * np.sin(u[1]) ])
def tensorexp(r): """ returns a stack of rotation matrices as a tensor """ """ r should be (3,n), n column vectors """ theta = np.sqrt(np.sum(r*r, axis=0)) # shape = (n,) # note: the case where theta == 0 is not handled; we assume there is enough # noise and bias that this won't happen K = tensorhat(r / theta) # shape = (3,3,n) KK = np.einsum('ijl,jkl->ikl', K, K) # Compute w/ Rodrigues' formula return np.eye(3)[:, :, np.newaxis] + np.sin(theta) * K + \ (1 - np.cos(theta)) * KK
def log_likelihoods(self, data, input, mask, tag): from autograd.scipy.special import i0 # Compute the log likelihood of the data under each of the K classes # Return a TxK array of probability of data[t] under class k mus, kappas = self.mus, np.exp(self.log_kappas) mask = np.ones_like(data, dtype=bool) if mask is None else mask return np.sum( (kappas * (np.cos(data[:, None, :] - mus)) - np.log(2 * np.pi) - np.log(i0(kappas))) * mask[:, None, :], axis=2)
def dderiv(self, x, xdot, u): x = State(x) xdot = State(xdot) u = Control(u) accel = u.f / self.m xddd = (-accel * np.cos(x.theta)) * x.theta_vel zddd = (-accel * np.sin(x.theta)) * x.theta_vel tddd = 0 # Really, this should be I inv * Tau_dot return np.array((xdot.x_vel, xdot.z_vel, xdot.theta_vel, xddd, zddd, tddd))
def test_involutory_variance(self, tol): """Tests qubit observable that are involutory""" dev = qml.device('default.qubit', wires=1) @qml.qnode(dev) def circuit(a): qml.RX(a, wires=0) return qml.var(qml.PauliZ(0)) a = 0.54 var = circuit(a) expected = 1 - np.cos(a)**2 assert np.allclose(var, expected, atol=tol, rtol=0) # circuit jacobians gradA = circuit.jacobian([a], method='A') gradF = circuit.jacobian([a], method='F') expected = 2 * np.sin(a) * np.cos(a) assert np.allclose(gradF, expected, atol=tol, rtol=0) assert np.allclose(gradA, expected, atol=tol, rtol=0)
def opt_f(x): u, theta = x x_t = np.array( (p_des[0], p_des[1], theta, v_des[0], v_des[1], 0)) u_t = np.array((u, 0)) fm = self.learner.predict(x_t, u_t, t) return u * np.array( (-np.sin(theta), np.cos(theta))) - np.array( (0, self.model.g)) + fm - a_des
def get_ceq(x): n = (x.shape[0] - 1) // 4 tk, xk, yk, thetak = split_state(x) xk = np.concatenate(([start_x], xk, [goal_x])) yk = np.concatenate(([start_y], yk, [goal_y])) thetak = np.concatenate(([start_theta], thetak, [goal_theta])) dx = xk[1:] - xk[0:-1] dy = yk[1:] - yk[0:-1] dk = np.array([dx, dy, np.zeros(n + 1)]).T # constant curvature (trapezoidal collocation, see teb paper) ceq = np.array([ np.cos(thetak[0:-1]) + np.cos(thetak[1:]), np.sin(thetak[0:-1]) + np.sin(thetak[1:]), np.zeros(n + 1) ]).T ceq = np.fabs(np.cross(ceq, dk, axisa=1, axisb=1)[:, 2]) return ceq
def _M(self, pos): """ Inertial Mass matrix """ x, th = pos I = self.inertial d0 = self.total_mass d1 = self.polemass_length * anp.cos(th) mass_matrix = anp.array([[d0, d1], [d1, I]]) return mass_matrix
def dataset(num_data=20, noise=0.5): num_dims = 1 inputs = np.concatenate([ np.linspace(0, 2, num=num_data / 2), np.linspace(6, 8, num=num_data / 2) ]) targets = np.cos(inputs) + np.random.randn(num_data) * noise inputs = (inputs - 4.0) / 4.0 inputs = inputs.reshape((len(inputs), num_dims)) targets = targets.reshape((len(targets), num_dims)) return inputs, targets
def square_generator(t, **kwargs): ''' Makes a random frequency square wave frequency input ''' square_freq = 0.2 if 'square_freq' in kwargs: square_freq = kwargs['square_freq'] # produce square wave based on cosine f = np.sign(np.maximum(0, np.cos(np.pi * square_freq * t))) + 1 return f
def ensemble_transfer_matrix_pi_half(NAtoms, g1d, gprime, gm, Delta1, Deltap, Omega): """ NAtoms: The number of atoms g1d: \Gamma_{1D}, the decay rate into the guided mode gprime: \Gamma', the decay rate into all the other modes gm: \Gamma_m, the decay rate from the meta-stable state Delta1: The detuning of the carrier frequency \omega_L of the quantum field from the atomic transition frequency \omega_{ab}. Delta1 = \omega_L - \omega_{ab} Deltap: The detuning of the classical drive frequency \omega_p from the transition bc. Deltap = \omega_p - \omega_{bc} """ kd = 0.5 * np.pi Mf = np.mat([[np.exp(1j * kd), 0], [0, np.exp(-1j * kd)]]) beta3 = Lambda_type_minus_r_over_t(g1d, gprime, gm, Delta1, Deltap, Omega) M3 = np.mat([[1 - beta3, -beta3], [beta3, 1 + beta3]]) beta2 = two_level_minus_r_over_t(g1d, gprime, Delta1) M2 = np.mat([[1 - beta2, -beta2], [beta2, 1 + beta2]]) Mcell = Mf * M2 * Mf * M3 NCells = NAtoms / 2 #diag, V = np.linalg.eig(Mcell) #DN = np.diag(diag**(NCells)) #V_inv = np.linalg.inv(V) #return V*DN*V_inv theta = np.arccos(0.5 * np.trace(Mcell)) Id = np.mat([[1, 0], [0, 1]]) Mensemble\ = np.mat([[np.cos(NCells*theta)+1j*1j*np.sin(NCells*theta)/np.sin(theta)*(Mcell[1,1]-Mcell[0,0])/2, -1j*1j*np.sin(NCells*theta)/np.sin(theta)*Mcell[0,1]], [-1j*1j*np.sin(NCells*theta)/np.sin(theta)*Mcell[1,0], np.cos(NCells*theta)-1j*1j*np.sin(NCells*theta)/np.sin(theta)*(Mcell[1,1]-Mcell[0,0])/2]]) return Mensemble
def unit_lobatto_nodes(order, tol=1e-15, output=True): roots=[] print("Finding roots of the derivative of the Legendre polynomial of order ", order) # The polynomials are alternately even and odd functions # so evaluate only half the number of roots # order - 1, lobatto polynomial is derivative of legendre polynomial of order n-1 order = order-1 for i in range(1,int(order/2) +1): # initial guess, x0, for ith root # the approximate values of the abscissas. # these are good initial guesses #x0=np.cos(np.pi*(i-0.25)/(order+0.5)) x0=np.cos(np.pi*(i+0.1)/(order+0.5)) # not sure why this inital guess is better # call newton to find the roots of the lobatto polynomial #Ffun, Jfun = dL(order-1), ddL(order-1) Ffun, Jfun = dL(order), ddL(order) ri, _ = newton( Ffun, Jfun, x0 ) roots.append(ri) # remove roots close to zero cleaned_roots = [] tol = 1e-08 for r in roots: if abs(r) >= tol: cleaned_roots += [r] roots = cleaned_roots # use symetric properties to find remmaining roots # the nodal abscissas are computed by finding the # nonnegative zeros of the Legendre polynomial pm(x) # with Newton’s method (the negative zeros are obtained from symmetry). roots = np.array(roots) # add -1 and 1 to tail ends # check parity of order + 1 # even. no center #if order % 2==0: if (order + 1) % 2==0: roots = np.concatenate( ([-1.0], -1.0*roots, roots[::-1], [1.0]) ) # odd. center root is 0.0 else: roots = np.concatenate( ([-1.0], -1.0*roots, [0.0], roots[::-1], [1.0] ) ) return roots
def SingleExcitation(phi): r"""Single excitation rotation. Args: phi (float): rotation angle Returns: array[float]: Single excitation rotation matrix """ c = np.cos(phi / 2) s = np.sin(phi / 2) return np.array([[1, 0, 0, 0], [0, c, -s, 0], [0, s, c, 0], [0, 0, 0, 1]])
def get_ad_t(t): if param.get('case_xd') == 0: return np.zeros((2, 1)) elif param.get('case_xd') == 1: return np.zeros((2, 1)) elif param.get('case_xd') == 2: return np.power(2 * np.pi / param.get('tf'), 2.) * np.array([ -np.cos(2 * np.pi / param.get('tf') * t), -np.sin(2 * np.pi / param.get('tf') * t) ]) return
def test_fanout(self, tol): """Tests qubit observable with repeated parameters""" dev = qml.device('default.qubit', wires=1) @qml.qnode(dev) def circuit(a): qml.RX(a, wires=0) qml.RY(a, wires=0) return qml.var(qml.PauliZ(0)) a = 0.54 var = circuit(a) expected = 0.5 * np.sin(a)**2 * (np.cos(2 * a) + 3) assert np.allclose(var, expected, atol=tol, rtol=0) # circuit jacobians gradA = circuit.jacobian([a], method='A') gradF = circuit.jacobian([a], method='F') expected = 4 * np.sin(a) * np.cos(a)**3 assert np.allclose(gradA, expected, atol=tol, rtol=0) assert np.allclose(gradF, expected, atol=tol, rtol=0)
def gaussian_sin(m, v, i, e=None): d = len(m) L = len(i) e = np.ones((1, L)) if e is None else np.atleast_2d(e) mi = np.atleast_2d(m[i]) vi = v[np.ix_(i, i)] vii = np.atleast_2d(np.diag(vi)) M = e * exp(-vii / 2) * sin(mi) M = M.flatten() lq = -(vii.T + vii) / 2 q = exp(lq) V = ((exp(lq + vi) - q) * cos(mi.T - mi) - (exp(lq - vi) - q) * cos(mi.T + mi)) V = np.dot(e.T, e) * V / 2 C = np.diag((e * exp(-vii / 2) * cos(mi)).flatten()) C = fill_mat(C, np.zeros((d, L)), i, None) return M, V, C
def dynamics(self, x, action): dt = 0.1 action = np.clip(action, -1., 1.) noise = self.noise px, py, angle, vel, ang_vel = x vel = 0.*vel + action[0] * dt + random.randn(1)*noise[0] ang_vel = 0.*ang_vel + action[1] * dt + random.randn(1)*noise[1] angle += ang_vel * dt + random.randn(1)*noise[2] angle %= 2*pi px += vel * np.cos(angle) * dt + random.randn(1)*noise[3] py += vel * np.sin(angle) * dt + random.randn(1)*noise[4] return np.array((px, py, angle, vel, ang_vel)).reshape(-1)
def get_vd_t(t): if param.get('case_xd') == 0: return np.zeros((2, 1)) elif param.get('case_xd') == 1: return np.ones((2, 1)) elif param.get('case_xd') == 2: return (2 * np.pi / param.get('tf')) * np.array([ -np.sin(2 * np.pi / param.get('tf') * t), np.cos(2 * np.pi / param.get('tf') * t) ]) return
def getA1_matrix(wb, M, N, p): Mmatrix = Marray(M, p) Nmatrix = Narray(N, p) a = np.arange(p + 1) onevec = np.ones(p + 1) A = np.vstack([onevec, (-1)**a, np.cos(wb * a), Mmatrix, Nmatrix]) print(f'A.shape: {A.shape}') return A
def draw_ellipse(mu, cov, num_sd=1): # as I understand it - # diagonalise the cov matrix # use eigenvalues for radii # use eigenvector rotation from x axis for rotation x = mu[0] #x-position of the center y = mu[1] #y-position of the center cov = cov * num_sd # show within num_sd standard deviations lam, V = np.linalg.eig(cov) # eigenvalues and vectors t_rot = np.arctan(V[1, 0] / V[0, 0]) a, b = lam[0], lam[1] t = np.linspace(0, 2 * np.pi, 100) Ell = np.array([a * np.cos(t), b * np.sin(t)]) #u,v removed to keep the same center location R_rot = np.array([[cos(t_rot), -sin(t_rot)], [sin(t_rot), cos(t_rot)]]) #2-D rotation matrix Ell_rot = np.zeros((2, Ell.shape[1])) for i in range(Ell.shape[1]): Ell_rot[:, i] = np.dot(R_rot, Ell[:, i]) return x + Ell_rot[0, :], y + Ell_rot[1, :]
def visit_Function(self, node): f = node.value if f == EXP: return np.exp(self.visit(node.expr)) if (f == LOG) or (f == LN): return np.log(self.visit(node.expr)) if f == LOG10: return np.log10(self.visit(node.expr)) if f == SQRT: return np.sqrt(self.visit(node.expr)) if f == ABS: return np.abs(self.visit(node.expr)) if f == SIGN: return np.sign(self.visit(node.expr)) if f == SIN: return np.sin(self.visit(node.expr)) if f == COS: return np.cos(self.visit(node.expr)) if f == TAN: return np.tan(self.visit(node.expr)) if f == ASIN: return np.arcsin(self.visit(node.expr)) if f == ACOS: return np.arccos(self.visit(node.expr)) if f == ATAN: return np.arctan(self.visit(node.expr)) if f == MAX: raise NotImplementedError(MAX) if f == MIN: raise NotImplementedError(MIN) if f == NORMCDF: raise NotImplementedError(NORMCDF) if f == NORMPDF: raise NotImplementedError(NORMPDF) if f == ERF: return erf(self.visit(node.expr))
def CRX(theta): r"""Two-qubit controlled rotation about the x axis. Args: theta (float): rotation angle Returns: array[complex]: unitary 4x4 rotation matrix :math:`|0\rangle\langle 0|\otimes \mathbb{I}+|1\rangle\langle 1|\otimes R_x(\theta)` """ return (np.cos(theta / 4)**2 * II - 1j * np.sin(theta / 2) / 2 * IX + np.sin(theta / 4)**2 * ZI + 1j * np.sin(theta / 2) / 2 * ZX)
def calc_constraint(self, theta, a, b, c, d, e, f1, f2): # Equations in readable format exp1 = (f2 - e) * anp.cos(theta) - f1 * anp.sin(theta) exp2 = (f2 - e) * anp.sin(theta) + f1 * anp.cos(theta) exp2 = b * anp.pi * (exp2 ** c) exp2 = anp.abs(anp.sin(exp2)) exp2 = a * (exp2 ** d) # as in the paper # val = - (exp1 - exp2) # as in the C code of NSGA2 val = 1 - exp1 / exp2 # ONE EQUATION # _val = - (anp.cos(theta) * (f2 - e) - anp.sin(theta) * f1 - # a * anp.abs(anp.sin(b * anp.pi * (anp.sin(theta) * (f2 - e) + anp.cos(theta) * f1) ** c)) ** d) return val
def GradAckleyProblem(xs): """del H/del xi = -20 * -0.2 * (xi * 1/n) / sqrt(1/n sum_j xj^2) * a + 2 pi sin(2 pi xi)/n * b""" out_shape = xs.shape a = np.exp(-0.2 * np.sqrt(1. / len(xs) * np.square(np.linalg.norm(xs, axis=0)))) b = -np.exp(1. / len(xs) * np.sum(np.cos(2 * np.pi * xs), axis=0)) a_p = -0.2 * (xs * 1. / len(xs)) / np.sqrt( 1. / len(xs) * np.square(np.linalg.norm(xs, axis=0))) b_p = -2 * np.pi * np.sin(2 * np.pi * xs) / len(xs) return np.nan_to_num(-20 * a_p * a + b_p * b).reshape( out_shape ) # only when norm(x) == 0 do we have nan and we know the grad is zero there
def bDotT(self, x): """ B dot T """ vInfMag = x[0] vInfRA = x[1] vInfDec = x[2] bScalar = x[3] bTheta = x[4] TA = x[5] BT = bScalar * np.cos(bTheta) return BT
def eVector(self, x, mu): """ eccentricity vector """ eMag = self.eMag(x, mu) TAinf = self.TAinf(x, mu) s = self.sVector(x) bUnit = self.bVector(x) bUnit = bUnit / np.linalg.norm(bUnit) e = np.cos(np.pi - TAinf) * s - np.sin(np.pi - TAinf) * bUnit e = e / np.linalg.norm(e) e = eMag * e return e
def obj_func(self, X_, g, alpha=1): f = [] for i in range(0, self.n_obj): _f = (1 + g) _f *= anp.prod(anp.cos(anp.power(X_[:, :X_.shape[1] - i], alpha) * anp.pi / 2.0), axis=1) if i > 0: _f *= anp.sin(anp.power(X_[:, X_.shape[1] - i], alpha) * anp.pi / 2.0) f.append(_f) f = anp.column_stack(f) return f
def eval(self, params, X, X2=None): w, mu, sigma = self.unpack_params(params) X2 = X if X2 is None else X2 delta = np.expand_dims(X, 1) - \ np.expand_dims(X2, 0) tau_sq = np.sum(delta**2, axis=2) tau = np.sqrt(tau_sq) out = np.zeros((X.shape[0], X2.shape[0])) for a in range(self.a): out += w[a] * np.exp(-2 * np.pi * tau_sq * sigma[0]) * \ np.cos(2 * np.pi * tau * mu[a]) return out
def make_pinwheel(radial_std, tangential_std, num_classes, num_per_class, rate, rs=npr.RandomState(0)): """Based on code by Ryan P. Adams.""" rads = np.linspace(0, 2 * np.pi, num_classes, endpoint=False) features = rs.randn(num_classes*num_per_class, 2) \ * np.array([radial_std, tangential_std]) features[:, 0] += 1 labels = np.repeat(np.arange(num_classes), num_per_class) angles = rads[labels] + rate * np.exp(features[:, 0]) rotations = np.stack( [np.cos(angles), -np.sin(angles), np.sin(angles), np.cos(angles)]) rotations = np.reshape(rotations.T, (-1, 2, 2)) return np.einsum('ti,tij->tj', features, rotations)
def rodrigues_rotate_point(rot,X): sqtheta = np.sum(np.square(rot)) if sqtheta != 0.: theta = np.sqrt(sqtheta) costheta = np.cos(theta) sintheta = np.sin(theta) theta_inverse = 1. / theta w = theta_inverse * rot w_cross_X = cross(w,X) tmp = np.dot(w,X) * (1. - costheta) return X*costheta + w_cross_X * sintheta + w * tmp else: return X + cross(rot,X)
def cd_at_pixel(self, x, y): """ translation of dustin's wcs function: (x,y) to numpy array (2,2) -- the CD matrix at pixel x,y: [ [ dRA/dx * cos(Dec), dRA/dy * cos(Dec) ], [ dDec/dx , dDec/dy ] ] in FITS these are called: [ [ CD11 , CD12 ], [ CD21 , CD22 ] ] Note: these statements have not been verified by the FDA. :( :( :) """ # TODO can this be analytically written out??? ra0, dec0 = self.pixel2equa(np.array([x, y])) step = 10. # pixels rax, decx = self.pixel2equa(np.array([x+step, y])) ray, decy = self.pixel2equa(np.array([x, y+step])) cosd = np.cos(dec0 * (np.pi / 180.)) return np.array([ [(rax - ra0)/step * cosd, (ray-ra0)/step * cosd ], [(decx - dec0)/step , (decy-dec0)/step ] ])
def test_cos(): fun = lambda x : 3.0 * np.cos(x) d_fun = grad(fun) check_grads(fun, npr.randn()) check_grads(d_fun, npr.randn())
def py_fun(node_params): messages, lognorm = natural_filter_forward_general( init_params, pair_params, node_params) return np.cos(lognorm) + messages_to_scalar(messages)
def cy_fun(node_params): dense_messages, lognorm = _natural_filter_forward_general( init_params, pair_params, node_params) messages = unpack_dense_messages(dense_messages) return np.cos(lognorm) + messages_to_scalar(messages)
n_train = 10 # Number of training points noise_var = 0.025 # Process noise of observing the true function rs = npr.RandomState(0) length_scale = 1.0 x_domain = (-5,5) n_pts = 100 n_samples = 3 num_params = 1 full_x = np.linspace(x_domain[0],x_domain[1],n_pts).reshape((-1,1)) seed = 222 true_func = lambda xx: xx**2 * np.cos(xx)/xx # true_func = lambda xx: np.sqrt(np.abs(xx)) * np.sin(xx)**2 # true_func = lambda xx: np.exp(-np.sin(xx)/xx) # Generate training points x_train = np.random.uniform(low=-5.,high=5.,size=n_train).reshape((-1,1)) x_train.sort(0) y_train = true_func(x_train) + np.random.normal(loc=0.0,scale=noise_var,size=(n_train,1)) ################################## ## DETERMINISTIC PRIOR BASE GP ## ################################## # Train Gaussian Process (only considering examples where noise is present) K = calcSigma(x_train,x_train,length_scale) # Get training covariance ks = calcSigma(x_train,full_x,length_scale) # Get covariance between train and test points
def f2(params): # one list, one numpy array input x,y = params[0] A = params[1] return np.sum(A**2) + np.cos(x) + np.exp(0.5*y)
def f2(params): return np.exp(params[0]) + params[1][0]**2 + np.cos(params[1][1])
def fun(input_tuple): A = np.sum(np.sin(input_tuple[0])) B = np.sum(np.cos(input_tuple[1])) return A + B
def fun(input_list): A = np.sum(np.sin(input_list[0])) B = np.sum(np.cos(input_list[1])) return A + B
def fun(input_dict): A = np.sum(np.sin(input_dict['item_1'])) B = np.sum(np.cos(input_dict['item_2'])) return A + B
def complicated_fun(a,b,c,d,e,f=1.1, g=9.0): return a + np.sin(b) + np.cosh(c) + np.cos(d) + np.tan(e) + f + g