def initAudio(self):
""" Inits the two oscillators and their channels. """
#guide tone
self.guide_osc = Oscillator('sine', self.guide, BUFFER_SIZE)
self.guide_ch = pygame.mixer.Channel(0)
self.guide_ch.set_volume(0.9 / 2.0)
#adjustable (the knob one), starts at same freq
self.osc = Oscillator('sine', self.pitch, BUFFER_SIZE)
self.osc_ch = pygame.mixer.Channel(1)
self.osc_ch.set_volume(0.9 / 2.0)
def __init__(self,
no_of_voices=2,
no_of_bass_voices=1,
waveform="sine",
samplerate=None,
transposition_factor=1.0,
attack_time=0.01,
decay_time=0.01,
after_decay_level=1.0,
release_time=1.0,
bass_attack_time=0.01,
bass_decay_time=0.01,
bass_after_decay_level=1.0,
bass_release_time=1.0,
bass_transposition_factor=1.0,
volume=0.3):
self.no_of_voices = no_of_voices
self.no_of_bass_voices = no_of_bass_voices
self.current_voice_index = 0
self.current_bass_voice_index = 0
self.samplerate = samplerate
self.oscillators = [Oscillator(waveform=waveform, \
dt=1.0/self.samplerate, frequency=100.0) \
for i in range(self.no_of_voices)]
self.bass_oscillators = [Oscillator(waveform=waveform, \
dt=1.0/self.samplerate, frequency=100.0) \
for i in range(self.no_of_bass_voices)]
self.transposition_factor = transposition_factor
self.bass_transposition_factor = bass_transposition_factor
self.envelopes = [envelope.Envelope(attack_time=attack_time, \
decay_time=decay_time, \
after_decay_level=after_decay_level, \
release_time=release_time,
dt=1.0/self.samplerate) \
for i in range(self.no_of_voices)]
self.bass_envelopes = [envelope.Envelope(attack_time=bass_attack_time, \
decay_time=bass_decay_time,\
after_decay_level=bass_after_decay_level,\
release_time=bass_release_time,
dt=1.0/self.samplerate) \
for i in range(self.no_of_bass_voices)]
self.start_envelope = False
self.release_envelope = False
self.start_bass_envelope = False
self.release_bass_envelope = False
self.is_recording = False
self.recorded_wave = []
self.volume = volume
def __init__(self):
# config
app_title = "Oscbar"
interval = 2 # seconds per calibration step
# initial oscillator settings
self.wave_type = "sine_wave"
self.amplitude = 0.5
self.frequency = 440
self.store_wave = None
self.store_freq = None
# object instances
self.app = rumps.App(app_title, icon=APP_ICON)
self.oct_timer = rumps.Timer(
lambda sender, factor=2, max_freq=880, title='Octave Walk': self.
advance_frequency(sender, factor, max_freq, title),
interval)
self.oct_thirds_timer = rumps.Timer(
lambda sender, factor=(2**(1 / 3)), max_freq=880, title
='Octave Walk â…“': self.advance_frequency(
sender, factor, max_freq, title),
interval)
self.osc = Oscillator(self.wave_type, self.amplitude, self.frequency)
# set up menu
self.build_menu()
self.osc_ready_menu()
def main(
ramp_start=START,
ramp_end=START + RISE,
ramp_seconds=RISE * 60,
feel=90,
osc_multiplier=3,
active_seceonds=2,
inactive_seconds_min=2,
inactive_seconds_max=10,
):
ramp = Ramp(ramp_start, ramp_end, ramp_seconds)
seq = Sequence()
time_osc = Oscillator(inactive_seconds_min, inactive_seconds_max, 120)
with commander() as cmd:
cmd.set_power('H')
cmd.set_mode(Mode.CONTINUOUS)
cmd.set_feel(feel)
while True:
base_level = ramp.get_value() + osc_multiplier * seq.get_value()
cmd.set_level('A', base_level)
sleep(active_seceonds)
cmd.set_level('A', 0)
# inactive_seconds = randint(inactive_seconds_min, inactive_seconds_max)
inactive_seconds = time_osc.get_value()
sleep(inactive_seconds)
def main():
ndim = 2
np.random.seed(3)
tf = 25
nsteps = 1000
u_init = [0, 0]
noise = Noise([0, tf])
oscil = Oscillator(noise, tf, nsteps, u_init)
my_map = BlackBox(map_def, args=(oscil, ))
n_init = 4
n_iter = 80
mean, cov = np.zeros(ndim), np.ones(ndim)
domain = [[-6, 6]] * ndim
inputs = GaussianInputs(domain, mean, cov)
X = inputs.draw_samples(n_init, "lhs")
Y = my_map.evaluate(X)
o = OptimalDesign(X,
Y,
my_map,
inputs,
fix_noise=True,
noise_var=0.0,
normalize_Y=True)
m_list = o.optimize(n_iter,
acquisition="US",
num_restarts=10,
parallel_restarts=True)
# Compute true pdf
filename = "map_samples{:d}D.txt".format(ndim)
try:
smpl = np.genfromtxt(filename)
pts = smpl[:, 0:-1]
yy = smpl[:, -1]
except:
pts = inputs.draw_samples(n_samples=100, sample_method="grd")
yy = my_map.evaluate(pts, parallel=True, include_noise=False)
np.savetxt(filename, np.column_stack((pts, yy)))
pdf = custom_KDE(yy, weights=inputs.pdf(pts))
for ii in np.arange(0, n_iter + 1, 10):
pb, pp, pm = model_pdf(m_list[ii], inputs, pts=pts)
plot_pdf(pdf,
pb, [pm, pp],
filename="pdfs%.4d.pdf" % (ii),
xticks=[-3, 0, 3],
yticks=[-8, -3, 2])
plot_smp(m_list[ii],
inputs,
n_init,
filename="smps%.4d.pdf" % (ii),
xticks=[-6, 0, 6],
yticks=[-5, 0, 5],
cmapticks=[-2, -1, 0, 1, 2])
def plot_theta_vs_theta_dash():
pendulum = Oscillator(alpha=0.8, radius=1)
time_steps = 400
time_max = 10.0
plt.axes(xlim=(-0.1, 0.1), ylim=(-0.25, 0.25))
trajectory = pendulum.get_trajectory(time_max, time_steps)
theta = [position for position, velocity in trajectory]
theta_dash = [velocity for position, velocity in trajectory]
plt.plot(theta, theta_dash, "b")
def plot_underdamped_pendulum():
pendulum = Oscillator(alpha=0.8, radius=1)
time_steps = 400
time_max = 10.0
time = numpy.linspace(0, time_max, time_steps + 1)
plt.axes(xlim=(0, 10), ylim=(-0.2, 0.2))
trajectory = pendulum.get_trajectory(time_max, time_steps)
theta = [position for position, velocity in trajectory]
plt.plot(time, theta, "r")
def main():
dev = OpenClDevice()
dev.build('oscillator.cl')
length_sec = 3.0
n_instances = 256 # larger values cause mysterious behavior that smells like corrupted memory or instances modifying each other's memory
local_size = 64 # must divide n_instances, and my video card prefers it to be at least 32
sample_freq = 44100.0
n_samples = int(length_sec * sample_freq)
a = instruments.violin_envelope()
vib = vibrato.generate(290, 3, 3, 6, 0.4, [3, 5, 4, 1], [1, 8, 4, 1])
partials = []
for i in range(len(a)):
n = i + 1 # n=1 for fundamental
p = Partial(
vib,
Pie.from_string("0 0,0.2 0.5 c ; , 2 1 ; , 3 0")) # gradual onset
p = copy.deepcopy(p).scale_f(n).scale_a(a[i])
partials.append(p)
# resp = lambda f:1.0 # no filtering
# resp = lambda f:instruments.log_comb_response(f)
resp = lambda f: instruments.fisher_response(f)
for partial in partials:
partial.filter(resp)
osc = Oscillator(
{
'n_samples': n_samples,
'n_instances': n_instances,
't0': 0.0,
'dt': 1 / sample_freq
}, partials)
if False:
print("graphing...")
#attack_envelope.graph("a.png",0,3,100)
partials[10].a.graph("a.png", 0, 3, 100)
print("...done")
timer_start = time.perf_counter()
osc.run(dev, local_size)
timer_end = time.perf_counter()
print("return code=", osc.error_code())
if osc.error_code() != 0:
sys.exit(" ******* exiting with an error **********")
print("wall-lock time for computation = ",
(timer_end - timer_start) * 1000, "ms")
write_file('a.wav', osc.y(), n_samples, sample_freq)
def main(
ramp_start=START,
ramp_end=START + RISE,
ramp_seconds=RISE * 60,
warn_adjustment=2,
feel=80,
warn_seconds=3,
bang_adjustment_min=10,
bang_adjustment_max=20,
active_seconds=1,
inactive_seconds_min=10,
inactive_seconds_max=30,
):
ramp = Ramp(ramp_start, ramp_end, ramp_seconds)
seq = Sequence()
time_osc = Oscillator(inactive_seconds_min, inactive_seconds_max, 120)
bang_adjustment = bang_adjustment_min
with commander() as cmd:
cmd.set_mode(Mode.CONTINUOUS)
cmd.set_power('H')
cmd.set_feel(feel)
while True:
active_level = ramp.get_value()
warn_level = active_level // warn_adjustment
if randint(1, 6) == 1:
# bang
active_level += bang_adjustment
bang_adjustment = min(bang_adjustment + 1, bang_adjustment_max)
cmd.set_level('A', warn_level)
sleep(warn_seconds)
cmd.set_level('A', active_level)
sleep(active_seconds)
cmd.set_level('A', 0)
# inactive_seconds = randint(inactive_seconds_min, inactive_seconds_max)
inactive_seconds = time_osc.get_value()
sleep(inactive_seconds)
def main(
ramp_start=START,
ramp_end=START + RISE,
ramp_seconds=RISE * 60,
feel=80,
speed=65,
osc_max=10,
osc_period_seconds=120,
step_seconds=5,
):
ramp = Ramp(ramp_start, ramp_end, ramp_seconds)
osc = Oscillator(0, osc_max, osc_period_seconds)
with commander() as cmd:
cmd.set_mode(Mode.WATERFALL)
cmd.set_power('H')
cmd.set_speed(speed)
cmd.set_feel(feel)
while True:
base_level = ramp.get_value() + osc.get_value()
cmd.set_level('A', base_level)
sleep(step_seconds)
def main(
ramp_start=START,
ramp_end=START + RISE,
ramp_seconds=RISE * 60,
warn_adjustment=10,
feel=80,
speed=90,
warn_seconds=3,
osc_multiplier=2,
active_seconds=5,
inactive_seconds_min=5,
inactive_seconds_max=15,
):
ramp = Ramp(ramp_start, ramp_end, ramp_seconds)
seq = Sequence()
time_osc = Oscillator(inactive_seconds_min, inactive_seconds_max, 120)
with commander() as cmd:
cmd.set_power('H')
cmd.set_mode(Mode.PULSE)
cmd.set_feel(feel)
cmd.set_speed(speed)
while True:
base_level = ramp.get_value() + osc_multiplier * seq.get_value()
warn_level = base_level - warn_adjustment
cmd.set_level('A', warn_level)
sleep(warn_seconds)
cmd.set_level('A', base_level)
sleep(active_seconds)
cmd.set_level('A', 0)
# inactive_seconds = randint(inactive_seconds_min, inactive_seconds_max)
inactive_seconds = time_osc.get_value()
sleep(inactive_seconds)
def scene(self):
spaceships_guns = [(10, 0), (gol.nx_c - 46, gol.ny_c - 9)]
for i in range(len(spaceships_guns)):
spaceship_guns = SpaceshipGuns(spaceships_guns[i][0],
spaceships_guns[i][1])
if (i % 2) == 1:
spaceship_guns.rot90(2)
gol.seed(spaceship_guns, spaceship_guns.pos_x,
spaceship_guns.pos_y)
oscillators = [(gol.nx_c - 27, 10), (10, gol.ny_c - 27)]
for i in oscillators:
oscilltor = Oscillator(i[0], i[1])
gol.seed(oscilltor, oscilltor.pos_x, oscilltor.pos_y)
sticks = [(5, 10), (5, 20), (gol.nx_c - 6, gol.ny_c - 11),
(gol.nx_c - 6, gol.ny_c - 21)]
for i in sticks:
stick = Stick(i[0], i[1])
gol.seed(stick, stick.pos_x, stick.pos_y)
spaceships = [Spaceship(40, 80)]
spaceships[0].rot90()
gol.seed(spaceships[0], spaceships[0].pos_x, spaceships[0].pos_y)
import matplotlib.lines as mlines
import numpy as np
from matplotlib import animation
from matplotlib import pyplot as plt
from oscillator import Oscillator
fig = plt.figure()
ax = plt.axes(xlim=(0, 10), ylim=(-0.22, 0.22))
theta_line, = ax.plot([], [], lw=2, color="green")
theta_dash_line, = ax.plot([], [], lw=2, color="blue")
time_steps = 400
time_max = 10.0
osc = Oscillator()
x = np.linspace(0, time_max, time_steps + 1)
trajectory = osc.get_trajectory(time_max, time_steps)
y = [position for position, velocity in trajectory]
y_dash = [velocity for position, velocity in trajectory]
def init():
theta_line.set_data([], [])
plt.xlabel("Time", fontsize=13, family='monospace')
plt.ylabel("Angular Displacement, Angular Velocity",
fontsize=13,
family='monospace')
plt.title("Angular Displacement and Angular Velocity v/s Time",
def test_amplitude_decreases_when_friction_present(self):
oscillator = Oscillator(alpha=1.0, radius=1.0)
self.assertTrue(
oscillator.state[0] > oscillator.get_trajectory(10.0, 500)[-1][0])
import math
from matplotlib import animation
from matplotlib import pyplot as plt
from oscillator import Oscillator
fig = plt.figure()
ax = plt.axes(xlim=(-0.1, 0.1), ylim=(-0.2, 1))
pendulum_bob, = ax.plot([], [], lw=2, marker='o', color="r", markersize=30)
pendulum_rod, = ax.plot([], [], lw=2, color="black")
time_steps = 400
time_max = 10.0
pendulum = Oscillator()
trajectory = pendulum.get_trajectory(time_max, time_steps)
y = [position for position, velocity in trajectory]
x_coord = [math.sin(position) for position, velocity in trajectory]
y_coord = [(1 - math.cos(position)) for position, velocity in trajectory]
def init():
pendulum_bob.set_data([], [])
plt.title("Damped Pendulum Motion")
plt.xlabel("X", fontsize=13, family='monospace')
plt.ylabel("Y", fontsize=13, family='monospace')
return pendulum_bob,
spike_gen_in_dn_id = 2
ei_rate = 1 # probability of an excitatory synapse between any pair of excitatory and inhibitory neurons
ie_rate = 1 # probability of an inhibitory synapse between any pair of excitatory and inhibitory neurons
nids_exc = range(exc_offset, num_exc + exc_offset)
nids_inh = range(inh_offset, num_inh + inh_offset)
# init a network generator
net_gen = n.NetworkGenerator()
# create spikegens
spikegen_input_up = Neuron(chip_id, core_id_exc, spike_gen_in_up_id, True)
spikegen_input_dn = Neuron(chip_id, core_id_exc, spike_gen_in_dn_id, True)
oscillator = Oscillator(net_gen,
spikegen_input_up,
spikegen_input_dn,
exc_offset,
inh_offset,
osc_input_rate=120)
nids_exc, nids_inh, spike_gen_osc_id = oscillator.get_ids()
# print network
net_gen.print_network()
# make a dynapse1config using the network
new_config = net_gen.make_dynapse1_configuration()
# apply the configuration
model.apply_configuration(new_config)
# get the global neuron IDs of the neurons
monitored_global_nids_exc = [
ut.get_global_id(chip_id, core_id_exc, nid_exc) for nid_exc in nids_exc
def init(self):
self.osc = Oscillator(freq=1)
self.osc2 = Oscillator(freq=5, zero=True, phase=20)
self.amplitude = 0
self.add_parameter(name="amplitude", min=10, max=60)
def __init__(self):
self.acc = PVector()
self.vel = PVector(random(-1, 1), random(-1, 1))
self.loc = PVector(random(width), random(height))
self.mass = random(8, 16)
self.osc = Oscillator(self.mass * 2)
def test_state_unchanged_after_zero_time(self):
oscillator = Oscillator()
self.assertListEqual(oscillator.state,
list(oscillator.get_trajectory(0, 1)[0]))
