Python numpy.cos() Examples
The following are 30
code examples of numpy.cos().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: mel_features.py From sklearn-audio-transfer-learning with ISC License | 8 votes |
def periodic_hann(window_length): """Calculate a "periodic" Hann window. The classic Hann window is defined as a raised cosine that starts and ends on zero, and where every value appears twice, except the middle point for an odd-length window. Matlab calls this a "symmetric" window and np.hanning() returns it. However, for Fourier analysis, this actually represents just over one cycle of a period N-1 cosine, and thus is not compactly expressed on a length-N Fourier basis. Instead, it's better to use a raised cosine that ends just before the final zero value - i.e. a complete cycle of a period-N cosine. Matlab calls this a "periodic" window. This routine calculates it. Args: window_length: The number of points in the returned window. Returns: A 1D np.array containing the periodic hann window. """ return 0.5 - (0.5 * np.cos(2 * np.pi / window_length * np.arange(window_length)))
Example #2
Source File: helper.py From pointnet-registration-framework with MIT License | 6 votes |
def rotate_point_cloud_by_angle_y(batch_data, rotation_angle): """ Rotate the point cloud along up direction with certain angle. Input: BxNx3 array, original batch of point clouds Return: BxNx3 array, rotated batch of point clouds """ rotated_data = np.zeros(batch_data.shape, dtype=np.float32) for k in range(batch_data.shape[0]): #rotation_angle = np.random.uniform() * 2 * np.pi cosval = np.cos(rotation_angle) sinval = np.sin(rotation_angle) rotation_matrix = np.array([[cosval, 0, sinval], [0, 1, 0], [-sinval, 0, cosval]]) shape_pc = batch_data[k, ...] # rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix) rotated_data[k, ...] = np.dot(rotation_matrix, shape_pc.reshape((-1, 3)).T).T # Pre-Multiplication (changes done) return rotated_data
Example #3
Source File: generators.py From FRIDA with MIT License | 6 votes |
def unit_vec(doa): """ This function takes a 2D (phi) or 3D (phi,theta) polar coordinates and returns a unit vector in cartesian coordinates. :param doa: (ndarray) An (D-1)-by-N array where D is the dimension and N the number of vectors. :return: (ndarray) A D-by-N array of unit vectors (each column is a vector) """ if doa.ndim != 1 and doa.ndim != 2: raise ValueError("DoA array should be 1D or 2D.") doa = np.array(doa) if doa.ndim == 0 or doa.ndim == 1: return np.array([np.cos(doa), np.sin(doa)]) elif doa.ndim == 2 and doa.shape[0] == 1: return np.array([np.cos(doa[0]), np.sin(doa[0])]) elif doa.ndim == 2 and doa.shape[0] == 2: s = np.sin(doa[1]) return np.array([s * np.cos(doa[0]), s * np.sin(doa[0]), np.cos(doa[1])])
Example #4
Source File: util.py From neuropythy with GNU Affero General Public License v3.0 | 6 votes |
def rotation_matrix_3D(u, th): """ rotation_matrix_3D(u, t) yields a 3D numpy matrix that rotates any vector about the axis u t radians counter-clockwise. """ # normalize the axis: u = normalize(u) # We use the Euler-Rodrigues formula; # see https://en.wikipedia.org/wiki/Euler-Rodrigues_formula a = math.cos(0.5 * th) s = math.sin(0.5 * th) (b, c, d) = -s * u (a2, b2, c2, d2) = (a*a, b*b, c*c, d*d) (bc, ad, ac, ab, bd, cd) = (b*c, a*d, a*c, a*b, b*d, c*d) return np.array([[a2 + b2 - c2 - d2, 2*(bc + ad), 2*(bd - ac)], [2*(bc - ad), a2 + c2 - b2 - d2, 2*(cd + ab)], [2*(bd + ac), 2*(cd - ab), a2 + d2 - b2 - c2]])
Example #5
Source File: __init__.py From neuropythy with GNU Affero General Public License v3.0 | 6 votes |
def test_cmag(self): ''' test_cmag() ensures that the neuropythy.vision cortical magnification function is working. ''' import neuropythy.vision as vis logging.info('neuropythy: Testing areal cortical magnification...') dset = ny.data['benson_winawer_2018'] sub = dset.subjects['S1202'] hem = [sub.lh, sub.rh][np.random.randint(2)] cm = vis.areal_cmag(hem.midgray_surface, 'prf_', mask=('inf-prf_visual_area', 1), weight='prf_variance_explained') # cmag should get smaller in general ths = np.arange(0, 2*np.pi, np.pi/3) es = [0.5, 1, 2, 4] x = np.diff([np.mean(cm(e*np.cos(ths), e*np.sin(ths))) for e in es]) self.assertTrue((x < 0).all())
Example #6
Source File: Collection.py From fullrmc with GNU Affero General Public License v3.0 | 6 votes |
def get_rotation_matrix(rotationVector, angle): """ Calculate the rotation (3X3) matrix about an axis (rotationVector) by a rotation angle. :Parameters: #. rotationVector (list, tuple, numpy.ndarray): Rotation axis coordinates. #. angle (float): Rotation angle in rad. :Returns: #. rotationMatrix (numpy.ndarray): Computed (3X3) rotation matrix """ angle = float(angle) axis = rotationVector/np.sqrt(np.dot(rotationVector , rotationVector)) a = np.cos(angle/2) b,c,d = -axis*np.sin(angle/2.) return np.array( [ [a*a+b*b-c*c-d*d, 2*(b*c-a*d), 2*(b*d+a*c)], [2*(b*c+a*d), a*a+c*c-b*b-d*d, 2*(c*d-a*b)], [2*(b*d-a*c), 2*(c*d+a*b), a*a+d*d-b*b-c*c] ] , dtype = FLOAT_TYPE)
Example #7
Source File: nav_env.py From DOTA_models with Apache License 2.0 | 6 votes |
def get_loc_axis(self, node, delta_theta, perturb=None): """Based on the node orientation returns X, and Y axis. Used to sample the map in egocentric coordinate frame. """ if type(node) == tuple: node = np.array([node]) if perturb is None: perturb = np.zeros((node.shape[0], 4)) xyt = self.to_actual_xyt_vec(node) x = xyt[:,[0]] + perturb[:,[0]] y = xyt[:,[1]] + perturb[:,[1]] t = xyt[:,[2]] + perturb[:,[2]] theta = t*delta_theta loc = np.concatenate((x,y), axis=1) x_axis = np.concatenate((np.cos(theta), np.sin(theta)), axis=1) y_axis = np.concatenate((np.cos(theta+np.pi/2.), np.sin(theta+np.pi/2.)), axis=1) # Flip the sampled map where need be. y_axis[np.where(perturb[:,3] > 0)[0], :] *= -1. return loc, x_axis, y_axis, theta
Example #8
Source File: minitaur_terrain_randomizer.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def sample(self): """Samples new points around some existing point. Removes the sampling base point and also stores the new jksampled points if they are far enough from all existing points. """ active_point = self._active_list.pop() for _ in xrange(self._max_sample_size): # Generate random points near the current active_point between the radius random_radius = np.random.uniform(self._min_radius, 2 * self._min_radius) random_angle = np.random.uniform(0, 2 * math.pi) # The sampled 2D points near the active point sample = random_radius * np.array( [np.cos(random_angle), np.sin(random_angle)]) + active_point if not self._is_in_grid(sample): continue if self._is_close_to_existing_points(sample): continue self._active_list.append(sample) self._grid[self._point_to_index_1d(sample)] = sample
Example #9
Source File: robot_locomotors.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def alive_bonus(self, z, pitch): if self.frame%30==0 and self.frame>100 and self.on_ground_frame_counter==0: target_xyz = np.array(self.body_xyz) robot_speed = np.array(self.robot_body.speed()) angle = self.np_random.uniform(low=-3.14, high=3.14) from_dist = 4.0 attack_speed = self.np_random.uniform(low=20.0, high=30.0) # speed 20..30 (* mass in cube.urdf = impulse) time_to_travel = from_dist / attack_speed target_xyz += robot_speed*time_to_travel # predict future position at the moment the cube hits the robot position = [target_xyz[0] + from_dist*np.cos(angle), target_xyz[1] + from_dist*np.sin(angle), target_xyz[2] + 1.0] attack_speed_vector = target_xyz - np.array(position) attack_speed_vector *= attack_speed / np.linalg.norm(attack_speed_vector) attack_speed_vector += self.np_random.uniform(low=-1.0, high=+1.0, size=(3,)) self.aggressive_cube.reset_position(position) self.aggressive_cube.reset_velocity(linearVelocity=attack_speed_vector) if z < 0.8: self.on_ground_frame_counter += 1 elif self.on_ground_frame_counter > 0: self.on_ground_frame_counter -= 1 # End episode if the robot can't get up in 170 frames, to save computation and decorrelate observations. self.frame += 1 return self.potential_leak() if self.on_ground_frame_counter<170 else -1
Example #10
Source File: transform_utils.py From robosuite with MIT License | 6 votes |
def random_quat(rand=None): """Return uniform random unit quaternion. rand: array like or None Three independent random variables that are uniformly distributed between 0 and 1. >>> q = random_quat() >>> np.allclose(1.0, vector_norm(q)) True >>> q = random_quat(np.random.random(3)) >>> q.shape (4,) """ if rand is None: rand = np.random.rand(3) else: assert len(rand) == 3 r1 = np.sqrt(1.0 - rand[0]) r2 = np.sqrt(rand[0]) pi2 = math.pi * 2.0 t1 = pi2 * rand[1] t2 = pi2 * rand[2] return np.array( (np.sin(t1) * r1, np.cos(t1) * r1, np.sin(t2) * r2, np.cos(t2) * r2), dtype=np.float32, )
Example #11
Source File: test_parameters.py From pywr with GNU General Public License v3.0 | 6 votes |
def test_variable(self, model): """ Test that variable updating works. """ p1 = AnnualHarmonicSeriesParameter(model, 0.5, [0.25], [np.pi/4], is_variable=True) assert p1.double_size == 3 assert p1.integer_size == 0 new_var = np.array([0.6, 0.1, np.pi/2]) p1.set_double_variables(new_var) np.testing.assert_allclose(p1.get_double_variables(), new_var) with pytest.raises(NotImplementedError): p1.set_integer_variables(np.arange(3, dtype=np.int32)) with pytest.raises(NotImplementedError): p1.get_integer_variables() si = ScenarioIndex(0, np.array([0], dtype=np.int32)) for ts in model.timestepper: doy = (ts.datetime.dayofyear - 1)/365 np.testing.assert_allclose(p1.value(ts, si), 0.6 + 0.1*np.cos(doy*2*np.pi + np.pi/2))
Example #12
Source File: FakeCatalog.py From EXOSIMS with BSD 3-Clause "New" or "Revised" License | 6 votes |
def inverse_method(self,N,d): t = np.linspace(1e-3,0.999,N) f = np.log( t / (1 - t) ) f = f/f[0] psi= np.pi*f cosPsi = np.cos(psi) sinTheta = ( np.abs(cosPsi) + (1-np.abs(cosPsi))*np.random.rand(len(cosPsi))) theta = np.arcsin(sinTheta) theta = np.pi-theta + (2*theta - np.pi)*np.round(np.random.rand(len(t))) cosPhi = cosPsi/sinTheta phi = np.arccos(cosPhi)*(-1)**np.round(np.random.rand(len(t))) coords = SkyCoord(phi*u.rad,(np.pi/2-theta)*u.rad,d*np.ones(len(phi))*u.pc) return coords
Example #13
Source File: GarrettCompleteness.py From EXOSIMS with BSD 3-Clause "New" or "Revised" License | 6 votes |
def Jac(self, b): """Calculates determinant of the Jacobian transformation matrix to get the joint probability density of dMag and s Args: b (ndarray): Phase angles Returns: f (ndarray): Determinant of Jacobian transformation matrix """ f = -2.5/(self.Phi(b)*np.log(10.0))*self.dPhi(b)*np.sin(b) - 5./np.log(10.0)*np.cos(b) return f
Example #14
Source File: keplerSTM.py From EXOSIMS with BSD 3-Clause "New" or "Revised" License | 6 votes |
def psi2c2c3(self, psi0): c2 = np.zeros(len(psi0)) c3 = np.zeros(len(psi0)) psi12 = np.sqrt(np.abs(psi0)) pos = psi0 >= 0 neg = psi0 < 0 if np.any(pos): c2[pos] = (1 - np.cos(psi12[pos]))/psi0[pos] c3[pos] = (psi12[pos] - np.sin(psi12[pos]))/psi12[pos]**3. if any(neg): c2[neg] = (1 - np.cosh(psi12[neg]))/psi0[neg] c3[neg] = (np.sinh(psi12[neg]) - psi12[neg])/psi12[neg]**3. tmp = c2+c3 == 0 if any(tmp): c2[tmp] = 1./2. c3[tmp] = 1./6. return c2,c3
Example #15
Source File: PlanetPhysicalModel.py From EXOSIMS with BSD 3-Clause "New" or "Revised" License | 6 votes |
def calc_Phi(self, beta): """Calculate the phase function. Prototype method uses the Lambert phase function from Sobolev 1975. Args: beta (astropy Quantity array): Planet phase angles at which the phase function is to be calculated, in units of rad Returns: Phi (ndarray): Planet phase function """ beta = beta.to('rad').value Phi = (np.sin(beta) + (np.pi - beta)*np.cos(beta))/np.pi return Phi
Example #16
Source File: utils.py From py360convert with MIT License | 6 votes |
def equirect_facetype(h, w): ''' 0F 1R 2B 3L 4U 5D ''' tp = np.roll(np.arange(4).repeat(w // 4)[None, :].repeat(h, 0), 3 * w // 8, 1) # Prepare ceil mask mask = np.zeros((h, w // 4), np.bool) idx = np.linspace(-np.pi, np.pi, w // 4) / 4 idx = h // 2 - np.round(np.arctan(np.cos(idx)) * h / np.pi).astype(int) for i, j in enumerate(idx): mask[:j, i] = 1 mask = np.roll(np.concatenate([mask] * 4, 1), 3 * w // 8, 1) tp[mask] = 4 tp[np.flip(mask, 0)] = 5 return tp.astype(np.int32)
Example #17
Source File: robot_manipulators.py From soccer-matlab with BSD 2-Clause "Simplified" License | 6 votes |
def calc_state(self): theta, self.theta_dot = self.central_joint.current_relative_position() self.gamma, self.gamma_dot = self.elbow_joint.current_relative_position() target_x, _ = self.jdict["target_x"].current_position() target_y, _ = self.jdict["target_y"].current_position() self.to_target_vec = np.array(self.fingertip.pose().xyz()) - np.array(self.target.pose().xyz()) return np.array([ target_x, target_y, self.to_target_vec[0], self.to_target_vec[1], np.cos(theta), np.sin(theta), self.theta_dot, self.gamma, self.gamma_dot, ])
Example #18
Source File: test_xrft.py From xrft with MIT License | 6 votes |
def test_cross_phase_2d(self, dask): Ny, Nx = (32, 16) x = np.linspace(0, 1, num=Nx, endpoint=False) y = np.ones(Ny) f = 6 phase_offset = np.pi/2 signal1 = np.cos(2*np.pi*f*x) # frequency = 1/(2*pi) signal2 = np.cos(2*np.pi*f*x - phase_offset) da1 = xr.DataArray(data=signal1*y[:,np.newaxis], name='a', dims=['y','x'], coords={'y':y, 'x':x}) da2 = xr.DataArray(data=signal2*y[:,np.newaxis], name='b', dims=['y','x'], coords={'y':y, 'x':x}) with pytest.raises(ValueError): xrft.cross_phase(da1, da2, dim=['y','x']) if dask: da1 = da1.chunk({'x': 16}) da2 = da2.chunk({'x': 16}) cp = xrft.cross_phase(da1, da2, dim=['x']) actual_phase_offset = cp.sel(freq_x=f).values npt.assert_almost_equal(actual_phase_offset, phase_offset)
Example #19
Source File: test_analytical.py From pywr with GNU General Public License v3.0 | 5 votes |
def make_simple_model(supply_amplitude, demand, frequency, initial_volume): """ Make a simple model, supply -> reservoir -> demand. supply is a annual cosine function with amplitude supply_amplitude and frequency """ model = pywr.core.Model() S = supply_amplitude w = frequency class SupplyFunc(pywr.parameters.Parameter): def value(self, ts, si): # Take the mean flow of the day (i.e. offset by half a day) t = ts.dayofyear - 0.5 v = S*np.cos(t*w)+S return v max_flow = SupplyFunc(model) supply = pywr.core.Input(model, name='supply', max_flow=max_flow, min_flow=max_flow) demand = pywr.core.Output(model, name='demand', max_flow=demand, cost=-10) res = pywr.core.Storage(model, name='reservoir', max_volume=1e6, initial_volume=initial_volume) supply_res_link = pywr.core.Link(model, name='link1') res_demand_link = pywr.core.Link(model, name='link2') supply.connect(supply_res_link) supply_res_link.connect(res) res.connect(res_demand_link) res_demand_link.connect(demand) return model
Example #20
Source File: hsc.py From openISP with MIT License | 5 votes |
def lut(self): ind = np.array([i for i in range(360)]) sin = np.sin(ind * np.pi / 180) * 256 cos = np.cos(ind * np.pi / 180) * 256 lut_sin = dict(zip(ind, [round(sin[i]) for i in ind])) lut_cos = dict(zip(ind, [round(cos[i]) for i in ind])) return lut_sin, lut_cos
Example #21
Source File: TargetList.py From EXOSIMS with BSD 3-Clause "New" or "Revised" License | 5 votes |
def gen_inclinations(self, Irange): """Randomly Generate Inclination of Star System Orbital Plane Args: Irange (numpy array): the range to generate inclinations over Returns: I (numpy array): an array of star system inclinations """ C = 0.5*(np.cos(Irange[0])-np.cos(Irange[1])) return (np.arccos(np.cos(Irange[0]) - 2.*C*np.random.uniform(size=self.nStars))).to('deg')
Example #22
Source File: timeseries_data_generator.py From fine-lm with MIT License | 5 votes |
def generate_data(timeseries_length, timeseries_params): """Generates synthetic timeseries using input parameters. Each generated timeseries has timeseries_length data points. Parameters for each timeseries are specified by timeseries_params. Args: timeseries_length: Number of data points to generate for each timeseries. timeseries_params: Parameters used to generate the timeseries. The following parameters need to be specified for each timeseries: m = Slope of the timeseries used to compute the timeseries trend. b = y-intercept of the timeseries used to compute the timeseries trend. A = Timeseries amplitude used to compute timeseries period. freqcoeff = Frequency coefficient used to compute timeseries period. rndA = Random amplitude used to inject noise into the timeseries. fn = Base timeseries function (np.cos or np.sin). Example params for two timeseries. [{"m": 0.006, "b": 300.0, "A":50.0, "freqcoeff":1500.0, "rndA":15.0, "fn": np.sin}, {"m": 0.000, "b": 500.0, "A":35.0, "freqcoeff":3500.0, "rndA":25.0, "fn": np.cos}] Returns: Multi-timeseries (list of list). """ x = range(timeseries_length) multi_timeseries = [] for p in timeseries_params: # Trend y1 = [p["m"] * i + p["b"] for i in x] # Period y2 = [p["A"] * p["fn"](i / p["freqcoeff"]) for i in x] # Noise y3 = np.random.normal(0, p["rndA"], timeseries_length).tolist() # Sum of Trend, Period and Noise. Replace negative values with zero. y = [max(a + b + c, 0) for a, b, c in zip(y1, y2, y3)] multi_timeseries.append(y) return multi_timeseries
Example #23
Source File: pick_place_task.py From robosuite with MIT License | 5 votes |
def sample_quat(self): """Samples quaternions of random rotations along the z-axis.""" if self.z_rotation: rot_angle = np.random.uniform(high=2 * np.pi, low=0) return [np.cos(rot_angle / 2), 0, 0, np.sin(rot_angle / 2)] return [1, 0, 0, 0]
Example #24
Source File: util.py From neuropythy with GNU Affero General Public License v3.0 | 5 votes |
def spherical_distance(pt0, pt1): ''' spherical_distance(a, b) yields the angular distance between points a and b, both of which should be expressed in spherical coordinates as (longitude, latitude). If a and/or b are (2 x n) matrices, then the calculation is performed over all columns. The spherical_distance function uses the Haversine formula; accordingly it may suffer from rounding errors in the case of nearly antipodal points. ''' dtheta = pt1[0] - pt0[0] dphi = pt1[1] - pt0[1] a = np.sin(dphi/2)**2 + np.cos(pt0[1]) * np.cos(pt1[1]) * np.sin(dtheta/2)**2 return 2 * np.arcsin(np.sqrt(a))
Example #25
Source File: test_parameters.py From pywr with GNU General Public License v3.0 | 5 votes |
def test_double_harmonic(self, model): p1 = AnnualHarmonicSeriesParameter(model, 0.5, [0.25, 0.3], [np.pi/4, np.pi/3]) si = ScenarioIndex(0, np.array([0], dtype=np.int32)) for ts in model.timestepper: doy = (ts.datetime.dayofyear - 1) /365 expected = 0.5 + 0.25*np.cos(doy*2*np.pi + np.pi / 4) + 0.3*np.cos(doy*4*np.pi + np.pi/3) np.testing.assert_allclose(p1.value(ts, si), expected)
Example #26
Source File: test_parameters.py From pywr with GNU General Public License v3.0 | 5 votes |
def test_load(self, model): data = { "type": "annualharmonicseries", "mean": 0.5, "amplitudes": [0.25], "phases": [np.pi/4] } p1 = load_parameter(model, data) si = ScenarioIndex(0, np.array([0], dtype=np.int32)) for ts in model.timestepper: doy = (ts.datetime.dayofyear - 1) / 365 np.testing.assert_allclose(p1.value(ts, si), 0.5 + 0.25 * np.cos(doy * 2 * np.pi + np.pi / 4))
Example #27
Source File: augmentations.py From pytorch-mri-segmentation-3D with MIT License | 5 votes |
def applyRotation(images, rot, spline_orders): transform_x = np.array([[1.0, 0.0, 0.0], [0.0, np.cos(rot[0]), -np.sin(rot[0])], [0.0, np.sin(rot[0]), np.cos(rot[0])]]) transform_y = np.array([[np.cos(rot[1]), 0.0, np.sin(rot[1])], [0.0, 1.0, 0.0], [-np.sin(rot[1]), 0.0, np.cos(rot[1])]]) transform_z = np.array([[np.cos(rot[2]), -np.sin(rot[2]), 0.0], [np.sin(rot[2]), np.cos(rot[2]), 0.0], [0.0, 0, 1]]) transform = np.dot(transform_z, np.dot(transform_x, transform_y)) new_imgs = [] for i, img in enumerate(images): mid_index = 0.5 * np.asarray(img.squeeze().shape, dtype=np.int64) offset = mid_index - mid_index.dot(np.linalg.inv(transform)) new_img = scipy.ndimage.affine_transform( input = img.squeeze(), matrix = transform, offset = offset, order = spline_orders[i], mode = 'nearest') new_img = new_img[np.newaxis,np.newaxis,:] new_imgs.append(new_img) return new_imgs
Example #28
Source File: utils.py From FRIDA with MIT License | 5 votes |
def polar2cart(rho, phi): """ convert from polar to cartesian coordinates :param rho: radius :param phi: azimuth :return: """ x = rho * np.cos(phi) y = rho * np.sin(phi) return x, y
Example #29
Source File: point_cloud.py From FRIDA with MIT License | 5 votes |
def align(self, marker, axis): ''' Rotate the marker set around the given axis until it is aligned onto the given marker Parameters ---------- marker : int or str the index or label of the marker onto which to align the set axis : int the axis around which the rotation happens ''' index = self.key2ind(marker) axis = ['x','y','z'].index(axis) if isinstance(marker, (str, unicode)) else axis # swap the axis around which to rotate to last position Y = self.X if self.dim == 3: Y[axis,:], Y[2,:] = Y[2,:], Y[axis,:] # Rotate around z to align x-axis to second point theta = np.arctan2(Y[1,index],Y[0,index]) c = np.cos(theta) s = np.sin(theta) H = np.array([[c, s],[-s, c]]) Y[:2,:] = np.dot(H,Y[:2,:]) if self.dim == 3: Y[axis,:], Y[2,:] = Y[2,:], Y[axis,:]
Example #30
Source File: test_parameters.py From pywr with GNU General Public License v3.0 | 5 votes |
def test_single_harmonic(self, model): p1 = AnnualHarmonicSeriesParameter(model, 0.5, [0.25], [np.pi/4]) si = ScenarioIndex(0, np.array([0], dtype=np.int32)) for ts in model.timestepper: doy = (ts.datetime.dayofyear - 1)/365 np.testing.assert_allclose(p1.value(ts, si), 0.5 + 0.25*np.cos(doy*2*np.pi + np.pi/4))