# Python numpy.sin() Examples

The following are 30 code examples of numpy.sin(). 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 , or try the search function .
Example #1
 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 #2
 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
"""
# 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 #3
 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 #4
 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 #5
 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_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 #6
 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 #7
 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 #8
 Source File: robot_pendula.py    From soccer-matlab with BSD 2-Clause "Simplified" License 6 votes
```def calc_state(self):
self.theta, theta_dot = self.j1.current_position()
x, vx = self.slider.current_position()
assert( np.isfinite(x) )

if not np.isfinite(x):
print("x is inf")
x = 0

if not np.isfinite(vx):
print("vx is inf")
vx = 0

if not np.isfinite(self.theta):
print("theta is inf")
self.theta = 0

if not np.isfinite(theta_dot):
print("theta_dot is inf")
theta_dot = 0

return np.array([
x, vx,
np.cos(self.theta), np.sin(self.theta), theta_dot
]) ```
Example #9
 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 #10
 Source File: GFK.py    From transferlearning with MIT License 6 votes
```def subspace_disagreement_measure(self, Ps, Pt, Pst):
"""
For more details, read section 3.4 of the paper.
**Parameters**
Ps: Source subspace
Pt: Target subspace
Pst: Source + Target subspace
"""

def compute_angles(A, B):
_, S, _ = np.linalg.svd(np.dot(A.T, B))
S[np.where(np.isclose(S, 1, atol=self.eps) == True)[0]] = 1
return np.arccos(S)

max_d = min(Ps.shape[1], Pt.shape[1], Pst.shape[1])
alpha_d = compute_angles(Ps, Pst)
beta_d = compute_angles(Pt, Pst)
d = 0.5 * (np.sin(alpha_d) + np.sin(beta_d))
return np.argmax(d) ```
Example #11
 Source File: stft.py    From stft with MIT License 6 votes
```def cosine(M):
"""Gernerate a halfcosine window of given length

Uses :code:`scipy.signal.cosine` by default. However since this window
function has only recently been merged into mainline SciPy, a fallback
calculation is in place.

Parameters
----------
M : int
Length of the window.

Returns
-------
data : array_like
The window function

"""
try:
import scipy.signal
return scipy.signal.cosine(M)
except AttributeError:
return numpy.sin(numpy.pi / M * (numpy.arange(0, M) + .5)) ```
Example #12
 Source File: test_analytical.py    From pywr with GNU General Public License v3.0 6 votes
```def test_analytical():
"""
Run the test model though a year with analytical solution values to
ensure reservoir just contains sufficient volume.
"""

S = 100.0  # supply amplitude
D = S  # demand
w = 2*np.pi/365  # frequency (annual)
V0 = S/w  # initial reservoir level

model = make_simple_model(S, D, w, V0)

T = np.arange(1, 365)
V_anal = S*(np.sin(w*T)/w+T) - D*T + V0
V_model = np.empty(T.shape)

for i, t in enumerate(T):
model.step()
V_model[i] = model.nodes['reservoir'].volume[0]

# Relative error from initial volume
error = np.abs(V_model - V_anal) / V0
assert np.all(error < 1e-4) ```
Example #13
 Source File: GarrettCompleteness.py    From EXOSIMS with BSD 3-Clause "New" or "Revised" License 6 votes
```def mindmag(self, s):
"""Calculates the minimum value of dMag for projected separation

Args:
s (float):
Projected separations (AU)

Returns:
mindmag (float):
Minimum planet delta magnitude
"""
if s == 0.0:
mindmag = self.cdmin1
elif s < self.rmin*np.sin(self.bstar):
mindmag = self.cdmin1-2.5*np.log10(self.Phi(np.arcsin(s/self.rmin)))
elif s < self.rmax*np.sin(self.bstar):
mindmag = self.cdmin2+5.0*np.log10(s)
elif s <= self.rmax:
mindmag = self.cdmin3-2.5*np.log10(self.Phi(np.arcsin(s/self.rmax)))
else:
mindmag = np.inf

return mindmag ```
Example #14
 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 #15
 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 #16
 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

"""

Phi = (np.sin(beta) + (np.pi - beta)*np.cos(beta))/np.pi

return Phi ```
Example #17
 Source File: tf_logits.py    From Black-Box-Audio with MIT License 5 votes
```def compute_mfcc(audio, **kwargs):
"""
Compute the MFCC for a given audio waveform. This is
identical to how DeepSpeech does it, but does it all in
TensorFlow so that we can differentiate through it.
"""

batch_size, size = audio.get_shape().as_list()
audio = tf.cast(audio, tf.float32)

# 1. Pre-emphasizer, a high-pass filter
audio = tf.concat((audio[:, :1], audio[:, 1:] - 0.97*audio[:, :-1], np.zeros((batch_size,1000),dtype=np.float32)), 1)

# 2. windowing into frames of 320 samples, overlapping
windowed = tf.stack([audio[:, i:i+400] for i in range(0,size-320,160)],1)

# 3. Take the FFT to convert to frequency space
ffted = tf.spectral.rfft(windowed, [512])
ffted = 1.0 / 512 * tf.square(tf.abs(ffted))

# 4. Compute the Mel windowing of the FFT
energy = tf.reduce_sum(ffted,axis=2)+1e-30
feat = tf.matmul(ffted, np.array([filters]*batch_size,dtype=np.float32))+1e-30

# 5. Take the DCT again, because why not
feat = tf.log(feat)
feat = tf.spectral.dct(feat, type=2, norm='ortho')[:,:,:26]

# 6. Amplify high frequencies for some reason
_,nframes,ncoeff = feat.get_shape().as_list()
n = np.arange(ncoeff)
lift = 1 + (22/2.)*np.sin(np.pi*n/22)
feat = lift*feat
width = feat.get_shape().as_list()[1]

# 7. And now stick the energy next to the features
feat = tf.concat((tf.reshape(tf.log(energy),(-1,width,1)), feat[:, :, 1:]), axis=2)

return feat ```
Example #18
 Source File: model.py    From aospy with Apache License 2.0 5 votes
```def _grid_sfc_area(lon, lat, lon_bounds=None, lat_bounds=None):
"""Calculate surface area of each grid cell in a lon-lat grid."""
# Compute the bounds if not given.
if lon_bounds is None:
lon_bounds = _bounds_from_array(
lon, internal_names.LON_STR, internal_names.LON_BOUNDS_STR)
if lat_bounds is None:
lat_bounds = _bounds_from_array(
lat, internal_names.LAT_STR, internal_names.LAT_BOUNDS_STR)
# Compute the surface area.
dlon = _diff_bounds(utils.vertcoord.to_radians(lon_bounds, is_delta=True),
lon)
is_delta=True))
dsinlat = np.abs(_diff_bounds(sinlat_bounds, lat))
# Rename the coordinates such that they match the actual lat / lon.
try:
sfc_area = sfc_area.rename(
{internal_names.LAT_BOUNDS_STR: internal_names.LAT_STR,
internal_names.LON_BOUNDS_STR: internal_names.LON_STR})
except ValueError:
pass
# Clean up: correct names and dimension order.
sfc_area = sfc_area.rename(internal_names.SFC_AREA_STR)
sfc_area[internal_names.LAT_STR] = lat
sfc_area[internal_names.LON_STR] = lon
return sfc_area.transpose() ```
Example #19
 Source File: moving_mnist.py    From DDPAE-video-prediction with MIT License 5 votes
```def get_random_trajectory(self, seq_length):
''' Generate a random sequence of a MNIST digit '''
canvas_size = self.image_size_ - self.digit_size_
x = random.random()
y = random.random()
theta = random.random() * 2 * np.pi
v_y = np.sin(theta)
v_x = np.cos(theta)

start_y = np.zeros(seq_length)
start_x = np.zeros(seq_length)
for i in range(seq_length):
# Take a step along velocity.
y += v_y * self.step_length_
x += v_x * self.step_length_

# Bounce off edges.
if x <= 0:
x = 0
v_x = -v_x
if x >= 1.0:
x = 1.0
v_x = -v_x
if y <= 0:
y = 0
v_y = -v_y
if y >= 1.0:
y = 1.0
v_y = -v_y
start_y[i] = y
start_x[i] = x

# Scale to the size of the canvas.
start_y = (canvas_size * start_y).astype(np.int32)
start_x = (canvas_size * start_x).astype(np.int32)
return start_y, start_x ```
Example #20
 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 #21
 Source File: utils.py    From FRIDA with MIT License 5 votes
```def polar2cart(rho, phi):
"""
convert from polar to cartesian coordinates
:param phi: azimuth
:return:
"""
x = rho * np.cos(phi)
y = rho * np.sin(phi)
return x, y ```
Example #22
 Source File: doa.py    From FRIDA with MIT License 5 votes
```def spher2cart(r, theta, phi):
"""
Convert a spherical point to cartesian coordinates.
"""
# convert to cartesian
x = r * np.cos(theta) * np.sin(phi)
y = r * np.sin(theta) * np.sin(phi)
z = r * np.cos(phi)
return np.array([x, y, z]) ```
Example #23
 Source File: pre_submission.py    From MPContribs with MIT License 5 votes
```def load_RSM(filename):
om, tt, psd = xu.io.getxrdml_map(filename)
wavelength = 1.54056

q_y = (1 / wavelength) * (np.cos(tt) - np.cos(2 * om - tt))
q_x = (1 / wavelength) * (np.sin(tt) - np.sin(2 * om - tt))

xi = np.linspace(np.min(q_x), np.max(q_x), 100)
yi = np.linspace(np.min(q_y), np.max(q_y), 100)
psd[psd < 1] = 1
data_grid = griddata(
(q_x, q_y), psd, (xi[None, :], yi[:, None]), fill_value=1, method="cubic"
)
nx, ny = data_grid.shape

range_values = [np.min(q_x), np.max(q_x), np.min(q_y), np.max(q_y)]
output_data = (
Panel(np.log(data_grid).reshape(nx, ny, 1), minor_axis=["RSM"])
.transpose(2, 0, 1)
.to_frame()
)

return range_values, output_data ```
Example #24
 Source File: bh.py    From dustmaps with GNU General Public License v2.0 5 votes
```def _lb2RN_northcap(self, l, b):
R = 100. + (90. - b) * np.sin(np.radians(l)) / 0.3
N = 100. + (90. - b) * np.cos(np.radians(l)) / 0.3
return np.round(R).astype('i4'), np.round(N).astype('i4') ```
Example #25
 Source File: bh.py    From dustmaps with GNU General Public License v2.0 5 votes
```def _lb2RN_southcap(self, l, b):
R = 100. + (90. + b) * np.sin(np.radians(l)) / 0.3
N = 100. + (90. + b) * np.cos(np.radians(l)) / 0.3
return np.round(R).astype('i4'), np.round(N).astype('i4') ```
Example #26
 Source File: simulate_sin.py    From deep-learning-note with MIT License 5 votes
```def generate_data(seq):
X = []
y = []
# 输入是 第 i 项和后面 TIMESTEPS-1 项合在一起
# 输出是 第 i+TIEMSTEPS 项
# 即用 sin 函数前面 TIMESTEPS 个点的信息，预测第 i+TIMESTEMPS 个点的函数值
for i in range(len(seq) - TIMESTEPS):
X.append([seq[i:i+TIMESTEPS]])
y.append([seq[i+TIMESTEPS]])
return np.array(X, dtype=np.float32), np.array(y, dtype=np.float32) ```
Example #27
 Source File: 4_simulate_sin.py    From deep-learning-note with MIT License 5 votes
```def draw_correct_line():
x = np.arange(0, 2 * np.pi, 0.01)
x = x.reshape((len(x), 1))
y = np.sin(x)

pylab.plot(x, y, label='标准 sin 曲线')
plt.axhline(linewidth=1, color='r')

# 返回训练样本 ```
Example #28
 Source File: 4_simulate_sin.py    From deep-learning-note with MIT License 5 votes
```def get_train_data():
train_x = np.random.uniform(0.0, 2*np.pi, (1))
train_y = np.sin(train_x)
return train_x, train_y

# 定义前向结构 ```
Example #29
 Source File: conftest.py    From NiBetaSeries with MIT License 5 votes
```def preproc_file(deriv_dir, sub_metadata, deriv_bold_fname=deriv_bold_fname):
deriv_bold = deriv_dir.ensure(deriv_bold_fname)
with open(str(sub_metadata), 'r') as md:
# time_points
tp = 200
ix = np.arange(tp)
# create voxel timeseries
# add activations at every 40 time points
# waffles
# fries
# milkshakes
# csf
csf = np.cos(2*np.pi*ix*(50/tp)) * 0.1
# white matter
wm = np.sin(2*np.pi*ix*(22/tp)) * 0.1
# voxel time series (signal and noise)
voxel_ts = signal + csf + wm
# a 4d matrix with 2 identical timeseries
img_data = np.array([[[voxel_ts, voxel_ts]]])
# make a nifti image
img = nib.Nifti1Image(img_data, np.eye(4))
# save the nifti image
img.to_filename(str(deriv_bold))

return deriv_bold ```
Example #30
 Source File: conftest.py    From NiBetaSeries with MIT License 5 votes
```def confounds_file(deriv_dir, preproc_file,
deriv_regressor_fname=deriv_regressor_fname):
confounds_file = deriv_dir.ensure(deriv_regressor_fname)
confound_dict = {}
ix = np.arange(tp)
# csf
confound_dict['csf'] = np.cos(2*np.pi*ix*(50/tp)) * 0.1
# white matter
confound_dict['white_matter'] = np.sin(2*np.pi*ix*(22/tp)) * 0.1
# framewise_displacement
confound_dict['framewise_displacement'] = np.random.random_sample(tp)
confound_dict['framewise_displacement'][0] = np.nan
# motion outliers
for motion_outlier in range(0, 5):
mo_name = 'motion_outlier0{}'.format(motion_outlier)
confound_dict[mo_name] = np.zeros(tp)
confound_dict[mo_name][motion_outlier] = 1
# derivatives
derive1 = [
'csf_derivative1',
'csf_derivative1_power2',
'global_signal_derivative1_power2',
'trans_x_derivative1',
'trans_y_derivative1',
'trans_z_derivative1',
'trans_x_derivative1_power2',
'trans_y_derivative1_power2',
'trans_z_derivative1_power2',
]
for d in derive1:
confound_dict[d] = np.random.random_sample(tp)
confound_dict[d][0] = np.nan

# transformations
for dir in ["trans_x", "trans_y", "trans_z"]:
confound_dict[dir] = np.random.random_sample(tp)

confounds_df = pd.DataFrame(confound_dict)
confounds_df.to_csv(str(confounds_file), index=False, sep='\t', na_rep='n/a')
return confounds_file ```