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]))