def test_mask(self): "Test generation of a mask" # 1. Test mask from problem discription myfft = fft.FFT() self.assertEqual(myfft.mask(2, 15), MASK_TEXT) # 2. Test masks from example myfft = fft.FFT() for num in range(1, 9): self.assertEqual(myfft.mask(num, 8), MASK_EXAMPLE[num])
def setup_audio(self): """Setup audio file and setup the output. device.output is a lambda that will send data to fm process or to the specified ALSA sound card """ # Set up audio force_header = False if any([ax for ax in [".mp4", ".m4a", ".m4b"] if ax in self.song_filename]): force_header = True self.music_file = decoder.open(self.song_filename, force_header) self.sample_rate = self.music_file.getframerate() self.num_channels = self.music_file.getnchannels() self.fft_calc = fft.FFT(self.chunk_size, self.sample_rate, cm.hardware.gpio_len, cm.audio_processing.min_frequency, cm.audio_processing.max_frequency, cm.audio_processing.custom_channel_mapping, cm.audio_processing.custom_channel_frequencies) # setup output device self.set_audio_device() chunks_per_sec = ((16 * self.num_channels * self.sample_rate) / 8) / self.chunk_size self.light_delay = int(cm.lightshow.light_delay * chunks_per_sec) # Output a bit about what we're about to play to the logs num_frames = str(self.music_file.getnframes() / self.sample_rate) log.info("Playing: " + self.song_filename + " (" + num_frames + " sec)")
def cache_song(song_filename, chunk_size): music_file = audio_decoder.open(song_filename) sample_rate = music_file.getframerate() num_channels = music_file.getnchannels() logging.info("Sample rate: %s" % sample_rate) logging.info("Channels: %s" % num_channels) logging.info("Frame size: %s" % music_file.getsampwidth()) fft_calc = fft.FFT(chunk_size, sample_rate, hc.GPIOLEN, _MIN_FREQUENCY, _MAX_FREQUENCY, _CUSTOM_CHANNEL_MAPPING, _CUSTOM_CHANNEL_FREQUENCIES) # Init cache matrix cache_matrix = np.empty(shape=[0, hc.GPIOLEN]) cache_filename = os.path.dirname(song_filename) + "/." + os.path.basename( song_filename) + ".sync" cache_found = fft_calc.compare_config(cache_filename) if cache_found: mean, std, cache_matrix = load_cached_fft(fft_calc, cache_filename) else: # The values 12 and 1.5 are good estimates for first time playing back # (i.e. before we have the actual mean and standard deviations # calculated for each channel). mean = [12.0] * hc.GPIOLEN std = [1.5] * hc.GPIOLEN total = 0 while True: data = music_file.readframes(chunk_size) if not data: break total += len(data) matrix = fft_calc.calculate_levels(data) # Add the matrix to the end of the cache cache_matrix = np.vstack([cache_matrix, matrix]) for i in range(0, hc.GPIOLEN): std[i] = np.std([item for item in cache_matrix[:, i] if item > 0]) mean[i] = np.mean( [item for item in cache_matrix[:, i] if item > 0]) # Add mean and std to the top of the cache cache_matrix = np.vstack([mean, cache_matrix]) cache_matrix = np.vstack([std, cache_matrix]) # Save the cache using numpy savetxt np.savetxt(cache_filename, cache_matrix) # Save fft config fft_calc.save_config() logging.info("Cached sync data written to '." + cache_filename + "' [" + str(len(cache_matrix)) + " rows]") logging.info("Cached config data written to '." + fft_calc.config_filename) music_file.close() return mean, std, cache_matrix
def test_empty_init(self): """Test default FFT object creation""" # 1. Create default FFT object myfft = fft.FFT() # 2. Make sure it has the default values self.assertEqual(myfft.pattern, fft.BASE_PATTERN)
def test_value_init(self): "Test FFT object creation with values" # 1. Create Panel object with values myfft = fft.FFT(pattern=[1, 2, 3]) # 2. Make sure it has the specified values self.assertEqual(myfft.pattern, [1, 2, 3])
def __init__(self, model: str, market: EvalArgs, use_fft: bool, fft_alpha=None): self.model = model self.market = market if use_fft and model in fft.supported_models: self.price_impl = lambda pars, args: fft.FFT(model=model, args=args, alpha=fft_alpha).price(pars=pars) else: try: self.price_impl = lambda pars, args: optimization.models[self.model](pars=pars, args=args) except KeyError: raise ValueError(f"Unsupported model: {model}")
def test_short(self): "Test short transformations" # 1. Create a transformer myfft = fft.FFT() # 2. Do the transformation digits = myfft.transform(PHASES[0], phases=4) # 3. Verify the results self.assertEqual(digits, [int(_) for _ in PHASES[4]])
def test_fft(): spot = 100 strikes = np.array([90, 100, 110]) t = 1.2 r = .008 q = r args_vg = (spot, strikes, t, r, q, True) pars_vg = (.2, -.4, .1) vg_prices1 = vg.price_vg(pars=pars_vg, args=args_vg) vg_prices2 = fft.FFT(model='vg', args=args_vg).price(pars_vg) pass
def part_two(args, input_lines): "Process part two of the puzzle" # 1. Create the transfomer (Robots in Disguise) rid = fft.FFT() # 2. Transform the ingut solution = rid.real_signal(input_lines[0], watch=args.verbose) print("The eight-digits message embedded in the final output list is %s" % (str(solution))) # 3. Return result return solution is not None
def test_phase(self): "Test phase transformations" # 1. Create a transformer myfft = fft.FFT() # 2. Get the starting digite digits = [int(_) for _ in PHASES[0]] # 3. Do four phases, checking the result for num in range(1, 5): digits = myfft.phase(digits) self.assertEqual(digits, [int(_) for _ in PHASES[num]])
def part_one(args, input_lines): "Process part one of the puzzle" # 1. Create the transfomer (Robots in Disguise) rid = fft.FFT() # 2. Transform the ingut result = rid.transform(input_lines[0], watch=args.verbose) solution = result[:8] print("The first eight digits in the final output list is %s" % (str(solution))) # 3. Return result return solution is not None
def test_real_signal(self): "Test transformations of real_signals" # 1. Create a transformer myfft = fft.FFT() # 2. Loop for the three examples for num in range(3): # 3. Transform the digits digits = myfft.real_signal(REAL_INP[num]) # 4. Verify the results self.assertEqual(digits, REAL_OUT[num])
def test_larger(self): "Test transformations of larger inputs" # 1. Create a transformer myfft = fft.FFT() # 2. Loop for the three examples for num in range(3): # 3. Transform the digits digits = myfft.transform(LARGER_INP[num]) # 4. Verify the results self.assertEqual('%d%d%d%d%d%d%d%d' % (digits[0], digits[1], digits[2], digits[3], digits[4], digits[5], digits[6], digits[7]), LARGER_OUT[num])
def setup_audio(song_filename): """Setup audio file and setup setup the output device.output is a lambda that will send data to fm process or to the specified ALSA sound card :param song_filename: path / filename to music file :type song_filename: str :return: output, fm_process, fft_calc, music_file :rtype tuple: lambda, subprocess, fft.FFT, decoder """ # Set up audio force_header = False if any([ax for ax in [".mp4", ".m4a", ".m4b"] if ax in song_filename]): force_header = True music_file = decoder.open(song_filename, force_header) sample_rate = music_file.getframerate() num_channels = music_file.getnchannels() fft_calc = fft.FFT(CHUNK_SIZE, sample_rate, hc.GPIOLEN, cm.audio_processing.min_frequency, cm.audio_processing.max_frequency, cm.audio_processing.custom_channel_mapping, cm.audio_processing.custom_channel_frequencies) # setup output device output = set_audio_device(sample_rate, num_channels) chunks_per_sec = ((16 * num_channels * sample_rate) / 8) / CHUNK_SIZE light_delay = int(cm.audio_processing.light_delay * chunks_per_sec) # Output a bit about what we're about to play to the logs nframes = str(music_file.getnframes() / sample_rate) log.info("Playing: " + song_filename + " (" + nframes + " sec)") return output, fft_calc, music_file, light_delay
def audio_in(): """Control the lightshow from audio coming in from a USB audio card""" sample_rate = cm.lightshow()['audio_in_sample_rate'] input_channels = cm.lightshow()['audio_in_channels'] # Open the input stream from default input device audio_in_card = cm.lightshow()['audio_in_card'] stream = aa.PCM(aa.PCM_CAPTURE, aa.PCM_NORMAL, audio_in_card) stream.setchannels(input_channels) stream.setformat(aa.PCM_FORMAT_S16_LE) # Expose in config if needed stream.setrate(sample_rate) stream.setperiodsize(CHUNK_SIZE) logging.debug("Running in audio-in mode - will run until Ctrl+C " "is pressed") print "Running in audio-in mode, use Ctrl+C to stop" # Start with these as our initial guesses - will calculate a rolling # mean / std as we get input data. mean = np.array([12.0] * hc.GPIOLEN, dtype='float64') std = np.array([1.5] * hc.GPIOLEN, dtype='float64') count = 2 running_stats = running_stats.Stats(hc.GPIOLEN) # preload running_stats to avoid errors, and give us a show that looks # good right from the start running_stats.preload(mean, std, count) try: hc.initialize() fft_calc = fft.FFT(CHUNK_SIZE, sample_rate, hc.GPIOLEN, _MIN_FREQUENCY, _MAX_FREQUENCY, _CUSTOM_CHANNEL_MAPPING, _CUSTOM_CHANNEL_FREQUENCIES, input_channels) # Listen on the audio input device until CTRL-C is pressed while True: length, data = stream.read() if length > 0: # if the maximum of the absolute value of all samples in # data is below a threshold we will disreguard it audio_max = audioop.max(data, 2) if audio_max < 250: # we will fill the matrix with zeros and turn the # lights off matrix = np.zeros(hc.GPIOLEN, dtype="float64") logging.debug("below threshold: '" + str(audio_max) + "', turning the lights off") else: matrix = fft_calc.calculate_levels(data) running_stats.push(matrix) mean = running_stats.mean() std = running_stats.std() update_lights(matrix, mean, std) except KeyboardInterrupt: pass finally: print "\nStopping" hc.clean_up()
def audio_in(self): """Control the lightshow from audio coming in from a real time audio""" self.sample_rate = cm.lightshow.input_sample_rate self.num_channels = cm.lightshow.input_channels stream_reader, outq = self.set_audio_source() log.debug("Running in %s mode - will run until Ctrl+C is pressed" % cm.lightshow.mode) print "Running in %s mode, use Ctrl+C to stop" % cm.lightshow.mode # setup light_delay. chunks_per_sec = ( (16 * self.num_channels * self.sample_rate) / 8) / self.chunk_size light_delay = int(cm.lightshow.light_delay * chunks_per_sec) matrix_buffer = deque([], 1000) self.set_audio_device() # Start with these as our initial guesses - will calculate a rolling mean / std # as we get input data. # preload running_stats to avoid errors, and give us a show that looks # good right from the start count = 2 running_stats = RunningStats.Stats(cm.hardware.gpio_len) running_stats.preload(self.mean, self.std, count) hc.initialize() fft_calc = fft.FFT(self.chunk_size, self.sample_rate, cm.hardware.gpio_len, cm.audio_processing.min_frequency, cm.audio_processing.max_frequency, cm.audio_processing.custom_channel_mapping, cm.audio_processing.custom_channel_frequencies, 1) if self.server: self.network.set_playing() songcount = 0 # Listen on the audio input device until CTRL-C is pressed while True: if cm.lightshow.mode == 'stream-in': try: streamout = outq.get_nowait().strip('\n\r') except Empty: pass else: print streamout if cm.lightshow.stream_song_delim in streamout: songcount += 1 streamout = streamout.replace('\033[2K', '') streamout = streamout.replace( cm.lightshow.stream_song_delim, '') streamout = streamout.replace('"', '') os.system("/bin/echo " + "Now Playing \"" + streamout + "\"" + " >" + cm.home_dir + "/logs/now_playing.txt") if cm.lightshow.songname_command: os.system(cm.lightshow.songname_command + ' "Now Playing ' + streamout + '"') if cm.lightshow.stream_song_exit_count > 0 and songcount > cm.lightshow.stream_song_exit_count: break try: data = stream_reader() except OSError as err: if err.errno == errno.EAGAIN or err.errno == errno.EWOULDBLOCK: continue try: self.output(data) except aa.ALSAAudioError: continue if len(data): # if the maximum of the absolute value of all samples in # data is below a threshold we will disregard it audio_max = audioop.max(data, 2) if audio_max < 250: # we will fill the matrix with zeros and turn the lights off matrix = np.zeros(cm.hardware.gpio_len, dtype="float32") log.debug("below threshold: '" + str(audio_max) + "', turning the lights off") else: matrix = fft_calc.calculate_levels(data) running_stats.push(matrix) self.mean = running_stats.mean() self.std = running_stats.std() matrix_buffer.appendleft(matrix) if len(matrix_buffer) > light_delay: matrix = matrix_buffer[light_delay] self.update_lights(matrix)
def audio_in(): """Control the lightshow from audio coming in from a real time audio""" global streaming stream_reader = None streaming = None songcount = 0 sample_rate = cm.lightshow.input_sample_rate num_channels = cm.lightshow.input_channels if cm.lightshow.mode == 'audio-in': # Open the input stream from default input device streaming = aa.PCM(aa.PCM_CAPTURE, aa.PCM_NORMAL, cm.lightshow.audio_in_card) streaming.setchannels(num_channels) streaming.setformat(aa.PCM_FORMAT_S16_LE) # Expose in config if needed streaming.setrate(sample_rate) streaming.setperiodsize(CHUNK_SIZE) stream_reader = lambda: streaming.read()[-1] elif cm.lightshow.mode == 'stream-in': outq = Queue() if cm.lightshow.use_fifo: streaming = subprocess.Popen(cm.lightshow.stream_command_string, stdin=subprocess.PIPE, stdout=subprocess.PIPE, preexec_fn=os.setsid) io = os.open(cm.lightshow.fifo, os.O_RDONLY | os.O_NONBLOCK) stream_reader = lambda: os.read(io, CHUNK_SIZE) outthr = Thread(target=enqueue_output, args=(streaming.stdout, outq)) else: # Open the input stream from command string streaming = subprocess.Popen(cm.lightshow.stream_command_string, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stream_reader = lambda: streaming.stdout.read(CHUNK_SIZE) outthr = Thread(target=enqueue_output, args=(streaming.stderr, outq)) outthr.daemon = True outthr.start() log.debug("Running in %s mode - will run until Ctrl+C is pressed" % cm.lightshow.mode) print "Running in %s mode, use Ctrl+C to stop" % cm.lightshow.mode # setup light_delay. chunks_per_sec = ((16 * num_channels * sample_rate) / 8) / CHUNK_SIZE light_delay = int(cm.audio_processing.light_delay * chunks_per_sec) matrix_buffer = deque([], 1000) output = set_audio_device(sample_rate, num_channels) # Start with these as our initial guesses - will calculate a rolling mean / std # as we get input data. mean = np.array([12.0 for _ in range(hc.GPIOLEN)], dtype='float32') std = np.array([1.5 for _ in range(hc.GPIOLEN)], dtype='float32') count = 2 running_stats = RunningStats.Stats(hc.GPIOLEN) # preload running_stats to avoid errors, and give us a show that looks # good right from the start running_stats.preload(mean, std, count) hc.initialize() fft_calc = fft.FFT(CHUNK_SIZE, sample_rate, hc.GPIOLEN, cm.audio_processing.min_frequency, cm.audio_processing.max_frequency, cm.audio_processing.custom_channel_mapping, cm.audio_processing.custom_channel_frequencies, 1) if server: network.set_playing() # Listen on the audio input device until CTRL-C is pressed while True: try: streamout = outq.get_nowait().strip('\n\r') except Empty: pass else: print streamout if cm.lightshow.stream_song_delim in streamout: songcount += 1 if cm.lightshow.songname_command: streamout = streamout.replace('\033[2K', '') streamout = streamout.replace( cm.lightshow.stream_song_delim, '') streamout = streamout.replace('"', '') os.system(cm.lightshow.songname_command + ' "Now Playing ' + streamout + '"') if cm.lightshow.stream_song_exit_count > 0 and songcount > cm.lightshow.stream_song_exit_count: break try: data = stream_reader() except OSError as err: if err.errno == errno.EAGAIN or err.errno == errno.EWOULDBLOCK: continue try: output(data) except aa.ALSAAudioError: continue if len(data): # if the maximum of the absolute value of all samples in # data is below a threshold we will disregard it audio_max = audioop.max(data, 2) if audio_max < 250: # we will fill the matrix with zeros and turn the lights off matrix = np.zeros(hc.GPIOLEN, dtype="float32") log.debug("below threshold: '" + str(audio_max) + "', turning the lights off") else: matrix = fft_calc.calculate_levels(data) running_stats.push(matrix) mean = running_stats.mean() std = running_stats.std() matrix_buffer.appendleft(matrix) if len(matrix_buffer) > light_delay: matrix = matrix_buffer[light_delay] update_lights(matrix, mean, std)
import fft import sys filename = sys.argv[1] f = fft.FFT(filename) print(f.process(100))
import fft import matplotlib.pyplot as plt import numpy as np import sys lattice = fft.FFT(2, 32, mass=0.5) steps = int(50000) ones = [] twos = [] threes = [] fours = [] total_actions = [] def update_progress(progress): barLength = 50 # Modify this to change the length of the progress bar status = "" if isinstance(progress, int): progress = float(progress) if not isinstance(progress, float): progress = 0 status = "error: progress var must be float\r\n" if progress < 0: progress = 0 status = "Halt...\r\n" if progress >= 1: progress = 1 status = "Done...\r\n" block = int(round(barLength * progress)) text = "\rPercent: [{0}] {1}% {2}".format( "#"*block +\
import hardware_adapter import services.Service import configuration_manager from log import setup_logger cm = configuration_manager.Configuration() GPIO_LEN = 6 config_path = os.path.dirname( os.path.realpath(__file__)) + '/../config/mopidy.conf' logger = setup_logger("Light Show Service") decay = np.zeros(GPIO_LEN, dtype='float32') fft_calc = fft.FFT(cm.light_show.chunk_size, cm.light_show.sample_rate, GPIO_LEN, cm.light_show.min_frequency, cm.light_show.max_frequency, cm.light_show.custom_channel_mapping, cm.light_show.custom_channel_frequencies, 1) class LightShowService(services.Service.Service): def __init__(self): super().__init__() self.requires_gpio = True self.process = None def run(self): hardware_adapter.enable_gpio() setup_fifo() self.process = subprocess.Popen(['mopidy', '--config', config_path], stdout=subprocess.PIPE,
def calculate(self, **kwargs): ''' Calculate power/bispectrum for catalog ''' # FFt files D_fft = spec_fft.FFT('data', self.catalog, **kwargs) D_fft_file = D_fft.file_name R_fft = spec_fft.FFT('random', self.catalog, **kwargs) R_fft_file = R_fft.file_name # if FFT file does not exist if not os.path.isfile(D_fft_file): D_fft.calculate() if not os.path.isfile(R_fft_file): R_fft.calculate() spec_code = spec_fort.fortran_code(self.Type, self.catalog, **kwargs) spec_exe = spec_fort.fortran_code2exe(spec_code) # code and exe modification time spec_code_mod_time = os.path.getmtime(spec_code) if not os.path.isfile(spec_exe): spec_exe_mod_time = 0 else: spec_exe_mod_time = os.path.getmtime(spec_exe) # if code was changed since exe file was last compiled then # compile spec code if spec_exe_mod_time < spec_code_mod_time: spec_fort.compile_fortran_code(spec_code) spec = self.catalog['spec'] if self.Type == 'power': # power spectrum code input: # random fft file, data fft file, powerspectrum file, Lbox, Nbins spec_cmd = ' '.join([ spec_exe, R_fft_file, D_fft_file, self.file_name, str(spec['sscale']), str(spec['grid'] / 2) ]) elif self.Type == 'bispec': # bispectrum # double check that the counts are there # hardcoded count_file = '/home/users/rs123/Code/Fortran/counts2quad_n360_nmax40_ncut3_s3' self.count_file = count_file if not os.path.isfile(count_file): raise NotImplementedError('Count File does not exist') # bispectrum code input: # period/data, random fft file, data fft file, bispectrum file spec_cmd = ' '.join( [spec_exe, '2', R_fft_file, D_fft_file, self.file_name]) print spec_cmd subprocess.call(spec_cmd.split()) return None
type=int, help='fft frame size') parser.add_argument('--fft_step', default=256, type=int, help='fft step') parser.add_argument('--phase_smooth', default=4, type=int, help='phase smoothing') args = parser.parse_args(''.split()) jack_to_accumulator = queue.Queue(maxsize=128) accumulator_to_delay_tracker = queue.Queue(maxsize=128) delay_tracker_to_fft = queue.Queue(maxsize=128) fft_to_graphics = queue.Queue(maxsize=128) jcli = jack_client.JackClient(jack_to_accumulator, args.num_channels, 'shark') acc = accumulator.Accumulator(jack_to_accumulator, accumulator_to_delay_tracker, args.accumulator) dtracker = delay_tracker.DelayTracker(accumulator_to_delay_tracker, delay_tracker_to_fft) fftop = fft.FFT(delay_tracker_to_fft, fft_to_graphics, fft_params=args) render = display.Display(fft_to_graphics, jcli.client.samplerate, fft_params=args) render.start() fftop.start() dtracker.start() acc.start() jcli.activate()
def cache_song(song_filename): """Play the next song from the play list (or --file argument).""" # Initialize FFT stats matrix = [0 for _ in range(GPIOLEN)] # get length of gpio and assign it to a variable # Set up audio if song_filename.endswith('.wav'): musicfile = wave.open(song_filename, 'r') else: musicfile = decoder.open(song_filename) sample_rate = musicfile.getframerate() num_channels = musicfile.getnchannels() fft_calc = fft.FFT(CHUNK_SIZE, sample_rate, GPIOLEN, _MIN_FREQUENCY, _MAX_FREQUENCY, _CUSTOM_CHANNEL_MAPPING, _CUSTOM_CHANNEL_FREQUENCIES) song_filename = os.path.abspath(song_filename) # create empty array for the cache_matrix cache_matrix = np.empty(shape=[0, GPIOLEN]) cache_filename = \ os.path.dirname(song_filename) + "/." + os.path.basename(song_filename) + ".sync" # The values 12 and 1.5 are good estimates for first time playing back # (i.e. before we have the actual mean and standard deviations # calculated for each channel). mean = [12.0 for _ in range(GPIOLEN)] std = [1.5 for _ in range(GPIOLEN)] # Process audio song_filename row = 0 data = musicfile.readframes(CHUNK_SIZE) # move chunk_size to configuration_manager while data != '': # No cache - Compute FFT in this chunk, and cache results matrix = fft_calc.calculate_levels(data) # Add the matrix to the end of the cache cache_matrix = np.vstack([cache_matrix, matrix]) # Read next chunk of data from music song_filename data = musicfile.readframes(CHUNK_SIZE) row = row + 1 # Compute the standard deviation and mean values for the cache for i in range(0, GPIOLEN): std[i] = np.std([item for item in cache_matrix[:, i] if item > 0]) mean[i] = np.mean([item for item in cache_matrix[:, i] if item > 0]) # Add mean and std to the top of the cache cache_matrix = np.vstack([mean, cache_matrix]) cache_matrix = np.vstack([std, cache_matrix]) # Save the cache using numpy savetxt np.savetxt(cache_filename, cache_matrix)
import fft import sys import logging logging.getLogger("fft").setLevel(logging.DEBUG) filename = sys.argv[1] f = fft.FFT(filename, 10000) print(f.process(100))
import matplotlib.pyplot as plt import rsg import numpy as np import fft plt.style.use('bmh') harmonics_count = 8 frequency = 1500 N = 1024 signals = rsg.generateSignal(harmonics_count,frequency,N) AFFT = np.abs(fft.FFT(signals)) fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1) fig.subplots_adjust(hspace=0.5) fig.set_size_inches(12,6) ax1.plot(signals) ax1.set_xlim(0, int(N/4)) ax1.set(xlabel='Time', ylabel='Signal(t)', title='Random generated signals') ax2.plot(AFFT) ax2.set_xlim(0, int(N/4)) ax2.set(xlabel='Time', ylabel='Freq (Hz)', title='Frequency spectrum(FFT)') fig.savefig("plot(fft).png") plt.show()
import rsg import fft import numpy as np from time import perf_counter harmonics_count = 8 frequency = 1500 for i in range(2, 13): N = 2**i signals = rsg.generateSignal(harmonics_count, frequency, N) t_start = perf_counter() fft.FFT(signals) t_end = perf_counter() time1 = t_end - t_start t_start = perf_counter() np.fft.fft(signals) t_end = perf_counter() time2 = t_end - t_start print("N = 2^{0} ".format(i)) print("time : {0}s (my fft)".format(time1)) print("time : {0}s (numpy fft)\n".format(time2))